zoukankan      html  css  js  c++  java

  • 集合类整理

    Collection接口：

    *一个独立的元素的序列（单列，即一个位置放一个元素）

    *Collection接口下主要分为List集合和Set集合

    *List集合的特点是元素有序（先进先出）、允许有重复元素

    *Set集合的特点是元素无序（没有先后顺序）、不允许有重复元素

    Map接口：

    *一组成对的“键值对”对象，允许根据键来查找值

    *Map集合的键值不允许有重复（因为是根据键来查找值的），所以Map的所有键构成了一个Set集合

    Iterator接口：

    *JDK1.5新定义的接口作为Collection的付接口

    *主要为了实现增强for循环


                                                         List集合（特点）                                                

    ArrayList：

    *底层数组实现

    *查找快，增删慢(原因是这个集合是有序的，删除一个元素的时候，后一个元素需要往前挪动一个位置，增加的时候需要往后挪动一个位置)

    *线程不安全（线程不同步）

    Vector：

    *与ArrayLis基本一样

    *线程安全（线程同步）

    LinkedList：

    *底层链表实现

    *增删快，查找慢

    *线程不安全

    集合元素的存取：

    *List集合元素存取方法一致

    *使用add()方法增加元素

    *由于List集合有序，可以使用get(int i)方法获取元素

    *元素的迭代（Iterator）

    1.通过集合对象的iterator()方法获得迭代器Iterator

    2.通过Iterator迭代器的hasNext()方法判断是否存在下一个元素

    3.通过Iterator迭代器的next()方法获取下一个元素

    *元素的迭代（Enumeration）

    1.迭代Vector集合中的元素可以使用Enumeration（也只有Vector集合才有这种迭代方式）

    2.通过Enumeration的hasNextElements()方法判断是否还有元素

    3.通过Enumeration的nextElement()方法返回下一个元素


    遍历Collection集合分支下,List集合的实现类所有方法如下所示：

    [java] view plaincopyprint?
    1. Vector<String> al = new Vector<String>();  
    2. al.add("xxc");  
    3. al.add("pkq");  
    4. al.add("xxm");  
    5. //1.使用枚举遍历Vector集合(只有Vector集合有)  
    6. Enumeration<String> e = al.elements();  
    7. while(e.hasMoreElements()){  
    8.     System.out.println("枚举----->"+e.nextElement());  
    9. }  
    10. //2.使用Iterator的while循环结构遍历集合  
    11. Iterator<String> t = al.iterator();  
    12. while(t.hasNext()){  
    13.     System.out.println("while循环---->"+t.next());  
    14. }  
    15. //3.使用Iterator的for循环结构遍历集合  
    16. for(Iterator<String> t1 = al.iterator();t1.hasNext();){  
    17.     System.out.println("for循环----->"+t1.next());  
    18. }  
    19. //4.使用增强for循环遍历  如果前面没有指定泛型则String的位置需要写Object  
    20. for(String s : al){  
    21.     System.out.println("增强for循环----->"+s);  
    22. }  
    23. //5.使用一般for循环遍历数组  
    24. for(int i=0;i<al.size();i++){  
    25.     System.out.println("使用一般for循环------>"+al.get(i));  
    26. }  

    可变参数：

    [java] view plaincopyprint?
    1. public class Test {  
    2.     public static void main(String[] args) {  
    3.         run("1","2");  
    4.     }  
    5.     static void run(String s1,String s2){  
    6.         System.out.println("固定参数调用");//这个方法调用  
    7.     }  
    8.     static void run(String s1,String...str){  
    9.         System.out.println("可变参数调用");  
    10.     }  
    11. }  
    当固定参数和可变参数方法都满足要求时，优先固定参数



    [java] view plaincopyprint?
    1. public class Test {  
    2.     public static void main(String[] args) {  
    3.         run("1","2");//这时候这个run方法是没法正确执行的,因为以下两个方法都满足  
    4.     }  
    5.     static void run(String s1,String...str){  
    6.         System.out.println("可变参数调用");  
    7.     }  
    8.     static void run(String s1,String s2,String...str){  
    9.         System.out.println("可变参数调用");  
    10.     }  
    11. }  
    当两个可变参数的方法都满足要求时,无法执行

    注意：可变参数必须是参数列表中最后一个参数。


    例如：去除ArrayList中的重复元素，元素是对象类型

    方法一：建立一个新的ArrayList集合，遍历需要被去重的集合，用contains判断，如果新的集合中不包含此元素，则往新的集合中增加此元素，反之不增加。最后，得到的新集合中的元素都是没有重复的。

    （注意：因为对象去重复元素，而contains底层用的还是equals，所以我们要在比较的对象中覆写equals方法）

    Person类（覆写了equals方法）

    [java] view plaincopyprint?
    1. public class Person {  
    2.     private String name;  
    3.     private int age;  
    4.       
    5.     public Person(String name, int age) {  
    6.         this.name = name;  
    7.         this.age = age;  
    8.     }  
    9.   
    10.     public String getName() {  
    11.         return name;  
    12.     }  
    13.   
    14.     public void setName(String name) {  
    15.         this.name = name;  
    16.     }  
    17.   
    18.     public int getAge() {  
    19.         return age;  
    20.     }  
    21.   
    22.     public void setAge(int age) {  
    23.         this.age = age;  
    24.     }  
    25.   
    26.     @Override  
    27.     public boolean equals(Object obj){  
    28.         if(this == obj){  
    29.             return true;  
    30.         }  
    31.         if(obj instanceof Person){  
    32.             Person p = (Person)obj;  
    33.             if(this.name.endsWith(p.name) && this.age == p.age){  
    34.                 return true;  
    35.             }  
    36.         }  
    37.         return false;  
    38.     }  
    39. }  



    测试类

    [java] view plaincopyprint?
    1. public class ArrayListTest {  
    2.     public static void main(String[] args) {  
    3.         ArrayList<Person> a = new ArrayList<Person>();  
    4.         a.add(new Person("xxc1",10));  
    5.         a.add(new Person("xxc2",20));  
    6.         a.add(new Person("xxc1",10));  
    7.         a = getSingleElement(a);  
    8.         System.out.println(a.size());//打印2  
    9.         for(Person p : a){  
    10.             System.out.println(p.getName());  
    11.         }  
    12.           
    13.     }  
    14.   
    15.     private static ArrayList<Person> getSingleElement(ArrayList<Person> a) {  
    16.         ArrayList<Person> al = new ArrayList<Person>();  
    17.         Iterator<Person> i = a.iterator();  
    18.         while(i.hasNext()){  
    19.             Person p = (Person)i.next();  
    20.             if(!al.contains(p)){  
    21.                 al.add(p);  
    22.             }  
    23.         }  
    24.         return al;  
    25.     }  
    26. }  



    方法二：因为HashSet集合是不能存在重复元素的，那我们可以遍历ArrayList集合，将每一个元素往HashSet中存，这样就能去掉重复元素。当然，千万别忘记要在对象里覆写HashCode()和equals()。

    Person类（覆写了equals方法和hashCode方法）

    [java] view plaincopyprint?
    1. public class Person {  
    2.     private String name;  
    3.     private int age;  
    4.       
    5.     public Person(String name, int age) {  
    6.         this.name = name;  
    7.         this.age = age;  
    8.     }  
    9.   
    10.     public String getName() {  
    11.         return name;  
    12.     }  
    13.   
    14.     public void setName(String name) {  
    15.         this.name = name;  
    16.     }  
    17.   
    18.     public int getAge() {  
    19.         return age;  
    20.     }  
    21.   
    22.     public void setAge(int age) {  
    23.         this.age = age;  
    24.     }  
    25.   
    26.     @Override  
    27.     public boolean equals(Object obj){  
    28.         if(this == obj){  
    29.             return true;  
    30.         }  
    31.         if(obj instanceof Person){  
    32.             Person p = (Person)obj;  
    33.             if(this.name.endsWith(p.name) && this.age == p.age){  
    34.                 return true;  
    35.             }  
    36.         }  
    37.         return false;  
    38.     }  
    39.       
    40.     @Override  
    41.     public int hashCode(){  
    42.         return this.name.hashCode()*31+age;  
    43.     }  
    44. }  

    测试类

    [java] view plaincopyprint?
    1. public class ArrayListTest {  
    2.     public static void main(String[] args) {  
    3.         ArrayList<Person> a = new ArrayList<Person>();  
    4.         a.add(new Person("xxc1",10));  
    5.         a.add(new Person("xxc2",20));  
    6.         a.add(new Person("xxc1",10));  
    7.         HashSet<Person> hs = getSingleElement(a);  
    8.         for(Person p : hs){  
    9.             System.out.println(p.getName());  
    10.         }  
    11.     }  
    12.   
    13.     private static HashSet<Person> getSingleElement(ArrayList<Person> a) {  
    14.         HashSet<Person> hs = new HashSet<Person>();  
    15.         for(Person p : a){  
    16.             hs.add(p);  
    17.         }  
    18.         return hs;  
    19.     }  
    20. }  


    证明remove方法在删除元素时，是用equals方法来进行判断相同元素的。


    [java] view plaincopyprint?
    1. public class ArrayListTest {  
    2.     public static void main(String[] args) {  
    3.         ArrayList<Person> a = new ArrayList<Person>();  
    4.         a.add(new Person("xxc1",10));  
    5.         a.add(new Person("xxc2",20));  
    6.         a.add(new Person("xxc1",10));  
    7.         a.remove(new Person("xxc1",20));  
    8.         for(Person p : a){  
    9.             System.out.println(p.getName());  
    10.         }  
    11.     }  
    12. }  
    删除以后剩下 第二个和第三个元素。从以上例子可以看出，虽然remove方法里是新new了一个Person对象，但是还是能删除，就证明了比较的不是引用的内存地址值，而是equals比较了各个属性。




                                                      Set集合（特点）                                                     

    Set集合通过存入对象的equals方法来保证集合中没有重复元素

    HashSet：

    *线程不同步的

    *HashSet是Set的子类，因此也没有重复元素

    *底层使用哈希算法保证没有重复元素

    *存储对象时，先调用对象的HashCode()方法，找到存储位置，再和当前存储上已经存在的元素通过equals方法进行比较吗如果返回false，才能进行存储

    *往HashSet集合里存储的对象必须正确重写hashCode和equals方法，如果没有重写，那么就算是两个对象的属性值都相同，他们的hashCode也是不相同的，从而被认为是两个不同的对象存入到HashSet中

    *如果只是String类型和Integer类型的，则不需要覆写这两个方法也能进行重复元素的去除。

    注意：在重写HashCode的时候让属性乘以31，可以更好的防止重复检验

    Person类（重写了equals和HashCode方法）

    [java] view plaincopyprint?
    1. public class Person {  
    2.     String name;  
    3.     int age;  
    4.       
    5.     public Person(String name,int age){  
    6.         this.name = name;  
    7.         this.age = age;  
    8.     }  
    9.       
    10.     public boolean equals(Object obj){//重写equals方法  
    11.         if(obj == this){  
    12.             return true;  
    13.         }  
    14.         if(obj instanceof Person){  
    15.             Person p = (Person)obj;  
    16.             if(this.name.equals(p.name) && this.age == p.age){  
    17.                 return true;  
    18.             }  
    19.         }  
    20.         return false;  
    21.     }  
    22.       
    23.     public int hashCode(){//重写hashCode方法  
    24.         return name.hashCode()*31+age;  
    25.     }  
    26.   
    27.     @Override  
    28.     public String toString() {  
    29.         return "Person [name=" + name + ", age=" + age + "]";  
    30.     }  
    31.       
    32. }  


    测试类

    [java] view plaincopyprint?
    1. public class HashSetTest {  
    2.     public static void main(String[] args) {  
    3.         HashSet<Person> hs = new HashSet<Person>();  
    4.         hs.add(new Person("xxc1",10));  
    5.         hs.add(new Person("xxc2",20));  
    6.         hs.add(new Person("xxc3",30));  
    7.         hs.add(new Person("xxc1",10));  
    8.         hs.add(new Person("xxc4",40));  
    9.         for(Person p : hs){  
    10.             System.out.println(p);  
    11.         }  
    12.     }  
    13. }  


    LinkedHashSet：

    *线程不同步

    *这个集合和HashSet唯一不同的是，此集合类型是有序的，也就是先进先出。而且也是去重复元素的。

    [java] view plaincopyprint?
    1. HashSet<String> lhs = new LinkedHashSet<String>();  
    2.     lhs.add("22");  
    3.     lhs.add("dd");  
    4.     lhs.add("zz");  
    5.     for(String str : lhs){  
    6.         System.out.println(str);  
    7.     }  

    输出顺序还是22  dd  zz。先进先出，有序。

    TreeSet：

    *线程不同步

    *可以对Set集合中的元素进行排序。

    *TreeSet判断元素唯一性的方式：根据比较方法的返回值是否为0，如果为0，叫表示两个对象是相同元素，则不往TreeSet集合中存。

    *TreeSet存入两个以上的对象元素，要么此对象必须实现Comparable接口，覆写compareTo方法，要么TreeSet在创建的时候就带有比较器。注意：比较器在自定义类中定义不灵活，因为自定义类可能不是我们定义的，而是别人定义的，此时我们又不能再改变这个自定义类。

    *如果希望元素有序地输出（先进先出）那么可以将对象类中的compareTo或比较器中的comparator的返回值定义为1，先进后出的话就返回-1。


    利用TreeSet集合进行排序


    方法一：在对象中实现Comparable接口，覆写compareTo方法。让元素自身带有排序功能。

    Person对象类

    [java] view plaincopyprint?
    1. public class Person implements Comparable{//实现接口  
    2.     String name;  
    3.     int age;  
    4.   
    5.     public Person(String name, int age) {  
    6.         this.name = name;  
    7.         this.age = age;  
    8.     }  
    9.   
    10.     @Override  
    11.     public String toString() {  
    12.         return "Person [name=" + name + ", age=" + age + "]";  
    13.     }  
    14.   
    15.     public String getName() {  
    16.         return name;  
    17.     }  
    18.   
    19.     public void setName(String name) {  
    20.         this.name = name;  
    21.     }  
    22.   
    23.     public int getAge() {  
    24.         return age;  
    25.     }  
    26.   
    27.     public void setAge(int age) {  
    28.         this.age = age;  
    29.     }  
    30.       
    31.     public int compareTo(Object o){//覆写接口中的放  
    32.         Person p = null;  
    33.         if(o instanceof Person){  
    34.             p = (Person)o;  
    35.         }  
    36.         /*if(this.age > p.age){ 
    37.             return 1; 
    38.         } 
    39.         if(this.age < p.age){ 
    40.             return -1; 
    41.         } 
    42.         if(this.age == p.age){ 
    43.             int temp = this.name.compareTo(p.name); 
    44.             if(temp > 0){ 
    45.                 return 1; 
    46.             }else if(temp < 0){ 
    47.                 return -1; 
    48.             } 
    49.             return 0; 
    50.         } 
    51.         return 0;//写这个只是为了编译通过 
    52. */         
    53.         //上面这一片被注释的代码的功能，可以用下面两句话就能完成功能  
    54.         int temp = this.age - p.age;//由于age肯定是正整数，所以不怕有小数，可以直接相减后比大小  
    55.         return temp ==0?this.name.compareTo(p.name):temp;  
    56.     }  
    57. }  

    测试类

    [java] view plaincopyprint?
    1. public class TreeSetTest {  
    2.     public static void main(String[] args) {  
    3.         TreeSet<Person> ts = new TreeSet<Person>();  
    4.         ts.add(new Person("xxc1",40));  
    5.         ts.add(new Person("xxc2",20));  
    6.         ts.add(new Person("xxc3",30));  
    7.         ts.add(new Person("xxc4",30));  
    8.         ts.add(new Person("xxc0",20));  
    9.         for(Person p : ts){  
    10.             System.out.println(p);  
    11.         }  
    12.     }  
    13. }  



    方法二：在TreeSet构造的时候就传入一个比较器，这个比较器需要实现Comparator接口，覆写compare方法。让集合具有比较功能。

    注意：当对象类中具有比较规则，定义TreeSet时又传入了比较器，最后以比较器为准。


    定义比较器，实现Comparator接口，覆写compare方法

    [java] view plaincopyprint?
    1. public class ComparatorByName implements Comparator{  
    2.   
    3.     public int compare(Object o1, Object o2) {  
    4.         Person p1 = null;  
    5.         Person p2 = null;  
    6.         if(o1 instanceof Person){  
    7.             p1 = (Person)o1;  
    8.         }  
    9.         if(o2 instanceof Person){  
    10.             p2 = (Person)o2;  
    11.         }  
    12.         int temp = p1.getName().compareTo(p2.getName());  
    13.         return temp==0?p1.getAge()-p2.getAge():temp;  
    14.     }  
    15.   
    16. }  


    测试类

    [java] view plaincopyprint?
    1. public class TreeSetTest {  
    2.     public static void main(String[] args) {  
    3.         TreeSet<Person> ts = new TreeSet<Person>(new ComparatorByName());  
    4.         ts.add(new Person("xxc1",40));  
    5.         ts.add(new Person("xxc2",20));  
    6.         ts.add(new Person("xxc3",30));  
    7.         ts.add(new Person("xxc4",30));  
    8.         ts.add(new Person("xxc0",20));  
    9.         for(Person p : ts){  
    10.             System.out.println(p);  
    11.         }  
    12.     }  
    13. }  


                                                         Map集合（特点）                                                

    Map集合（双列集合）一次添加一对元素。Collection（单列集合）一次添加一个元素

    Map集合中必须保证键的唯一性。

    添加方法：value put(key,value)  返回前一个和key关联的值,如果没有则返回null.

    [java] view plaincopyprint?
    1. HashMap<Integer,String> hm = new HashMap<Integer,String>();  
    2.     System.out.println(hm.put(1, "xxc1"));//打印null  
    3.     System.out.println(hm.put(1, "xxc2"));//打印xxc1  
    删除方法：

    *void clear()：清空map集合

    [java] view plaincopyprint?
    1. HashMap<Integer,String> hm = new HashMap<Integer,String>();  
    2.     hm.put(1, "xxc1");  
    3.     hm.put(2, "xxc2");  
    4.     hm.clear();  
    5.     System.out.println(hm);//是一个空集合{}  
    *value remove(key)：根据指定的key删除这个键值对

    [java] view plaincopyprint?
    1. HashMap<Integer,String> hm = new HashMap<Integer,String>();  
    2.     hm.put(1, "xxc1");  
    3.     hm.put(2, "xxc2");  
    4.     hm.remove(2);  
    5.     System.out.println(hm);//打印{1=xxc1}  
    判断方法：判断集合中是否包含某个键

    [java] view plaincopyprint?
    1. HashMap<Integer,String> hm = new HashMap<Integer,String>();  
    2.     hm.put(1, "xxc1");  
    3.     hm.put(2, "xxc2");  
    4.     System.out.println(hm.containsKey(1));//返回true  
    获取方法：根据某个键，获取value。如果键不存在，则返回null。

    [java] view plaincopyprint?
    1. HashMap<Integer,String> hm = new HashMap<Integer,String>();  
    2.     hm.put(1, "xxc1");  
    3.     hm.put(2, "xxc2");  
    4.     System.out.println(hm.get(1));  

    HashMap：

    *允许空值空键

    *线程是不同步的

    *内部结构是哈希表

    *HashMap是不允许有重复键的，如果是自定义对象去重复元素，那么去重的方法和HashSet是一样的，在对象类定义的时候覆写HashCode和Equals方法

    和HashSet一样，HashMap也有一个LinkedHashMap子类，可以实现有序。即先进先出。

    HashTable：

    *不允许空值空键

    *线程是同步的

    *内部结构是哈希表

    *已经被HashMap替代

    TreeMap：

    *线程不同步

    *通过二叉树算法保证键唯一性

    *可以进行排序，排序的方式和在TreeSet中一样，要不就是在自定义对象中实现Comparable接口，覆写compareTo(Object o)

           要不就是在TreeMap创建的时候传入一个实现了Comparator接口并覆写compare方法的实现类

    至于TreeMap是怎么去自定义类的重复元素的，其实他并不是靠覆写hashCode和equals来实现的，而是靠比较两个对象后返回的整数大于0等于0小于0来判断的。


    HashMap中存入自定义对象，并去掉自定义类的重复值。

    [java] view plaincopyprint?
    1. public class Person {  
    2.     private String name;  
    3.     private int age;  
    4.       
    5.     public Person(String name, int age) {  
    6.         this.name = name;  
    7.         this.age = age;  
    8.     }  
    9.       
    10.     public String getName() {  
    11.         return name;  
    12.     }  
    13.     public void setName(String name) {  
    14.         this.name = name;  
    15.     }  
    16.     public int getAge() {  
    17.         return age;  
    18.     }  
    19.     public void setAge(int age) {  
    20.         this.age = age;  
    21.     }  
    22.   
    23.     public String toString() {  
    24.         return "Person [name=" + name + ", age=" + age + "]";  
    25.     }  
    26.     @Override  
    27.     public int hashCode(){//和HashSet一样需要覆写  
    28.         return this.name.hashCode()*31+age;  
    29.     }  
    30.     @Override  
    31.     public boolean equals(Object obj){//和HashSet一样需要覆写  
    32.         Person p = null;  
    33.         if(obj instanceof Person){  
    34.             p = (Person)obj;  
    35.         }  
    36.         return this.name.equals(p.name) && this.age == p.age;  
    37.     }  
    38. }  


    测试类

    [java] view plaincopyprint?
    1. public class HashMapTest {  
    2.     public static void main(String[] args) {  
    3.         HashMap<Person,String> hs = new HashMap<Person,String>();  
    4.         hs.put(new Person("xxc1",10),"火星");  
    5.         hs.put(new Person("xxc2",20),"北京");  
    6.         hs.put(new Person("xxc3",30),"上海");  
    7.         hs.put(new Person("xxc3",30),"上海");  
    8.         Iterator<Map.Entry<Person,String>> i = hs.entrySet().iterator();  
    9.         while(i.hasNext()){  
    10.             Map.Entry<Person, String> me = i.next();  
    11.             Person p = me.getKey();  
    12.             String value = me.getValue();  
    13.             System.out.println(p.getName()+"-----"+p.getAge()+"---老家-->"+value);  
    14.         }  
    15.     }  
    16. }  


    TreeSet进行自定义元素的排序

    Person类

    [java] view plaincopyprint?
    1. public class Person implements Comparable<Person>{//继承接口  
    2.     private String name;  
    3.     private int age;  
    4.       
    5.     public Person(String name, int age) {  
    6.         this.name = name;  
    7.         this.age = age;  
    8.     }  
    9.       
    10.     public String getName() {  
    11.         return name;  
    12.     }  
    13.     public void setName(String name) {  
    14.         this.name = name;  
    15.     }  
    16.     public int getAge() {  
    17.         return age;  
    18.     }  
    19.     public void setAge(int age) {  
    20.         this.age = age;  
    21.     }  
    22.   
    23.     public String toString() {  
    24.         return "Person [name=" + name + ", age=" + age + "]";  
    25.     }  
    26.   
    27.     public int compareTo(Person o) {//覆写方法,定义在元素中的就一个参数的,因为是拿外面的元素和自身比  
    28.         Person p = null;  
    29.         if(o instanceof Person){  
    30.             p = (Person)o;  
    31.         }  
    32.         int temp = this.age-p.age;  
    33.         return temp==0?this.name.compareTo(p.name):temp;  
    34.     }  
    35. }  


    测试类


    [java] view plaincopyprint?
    1. public class TreeMapTest {  
    2.     public static void main(String[] args) {  
    3.         TreeMap<Person,String> tm = new TreeMap<Person,String>(new Comparator<Person>() {//在TreeMap创建的时候就传入一个比较器。两个参数的。  
    4.             public int compare(Person p1, Person p2) {  
    5.                 int temp = p1.getName().compareTo(p2.getName());  
    6.                 return temp==0?p1.getAge()-p2.getAge():temp;  
    7.             }  
    8.         });  
    9.         tm.put(new Person("xxc4",10),"杭州");  
    10.         tm.put(new Person("xxc2",20),"北京");  
    11.         tm.put(new Person("xxc2",20),"北京");  
    12.         tm.put(new Person("xxc3",30),"上海");  
    13.         Set<Person> s = tm.keySet();  
    14.         Iterator<Person> i = s.iterator();  
    15.         while(i.hasNext()){  
    16.             Person p = i.next();  
    17.             String value = tm.get(p);  
    18.             System.out.println(p.getName()+"------------"+p.getAge()+"------------"+value);  
    19.         }  
    20.           
    21.     }  
    22. }  



                                                         Collections工具类(用于集合)                                                

    这个类中的方法都是静态的

    1.将集合反转

    reverseOrder()：返回一个比较器，它强行逆转实现了Comparable 接口的对象 collection 的自然顺序。

    reverseOrder(Comparator<T> cmp)：返回一个比较器，它强行逆转指定比较器的顺序。（这个方法可以反转已经有比较器的Tree集合）

    [java] view plaincopyprint?
    1. public class CollectionsTets {  
    2.     public static void main(String[] args) {  
    3.         TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new LengthComparator()));//反转已有的比较器规则  
    4.         ts.add("w");  
    5.         ts.add("azweewew");  
    6.         ts.add("abreew");  
    7.         ts.add("cads");  
    8.         System.out.println(ts);  
    9.     }  
    10. }  
    11.   
    12. class LengthComparator implements Comparator<String>{//根据字符串长度进行从短到长的排序  
    13.     public int compare(String o1, String o2) {  
    14.         return o1.length()-o2.length();  
    15.     }  
    16. }  

    2.将集合中的指定元素全部替换成另一个元素

    replaceAll(List<T> list, T oldVal, T newVal)：使用另一个值替换列表中出现的所有某一指定值。

    [java] view plaincopyprint?
    1. public class CollectionsTets {  
    2.     public static void main(String[] args) {  
    3.         ArrayList<String> al = new ArrayList<String>();  
    4.         al.add("w");  
    5.         al.add("aa");  
    6.         al.add("azweewew");  
    7.         al.add("abreew");  
    8.         al.add("cads");  
    9.         al.add("aa");  
    10.         System.out.println(al);  
    11.         Collections.replaceAll(al, "aa", "xxc");//将list集合中的aa全部替换成xxc  set(indexOf("aa"),"xxc");一样，就是将这两步封装成一个方法了  
    12.         System.out.println(al);  
    13.     }  
    14. }  
    2.将集合中的所有元素全部替换成另一个元素

    fill(List<? super T> list, T obj)：使用指定元素替换指定列表中的所有元素。

    [java] view plaincopyprint?
    1. public class CollectionsTets {  
    2.     public static void main(String[] args) {  
    3.         ArrayList<String> al = new ArrayList<String>();  
    4.         al.add("w");  
    5.         al.add("aa");  
    6.         al.add("azweewew");  
    7.         al.add("abreew");  
    8.         al.add("cads");  
    9.         al.add("aa");  
    10.         System.out.println(al);  
    11.         Collections.fill(al, "ss");  
    12.         System.out.println(al);  
    13.     }  
    14. }  
    3.将集合里的元素随机存放不同位置

    shuffle(List<?> list) ：使用默认随机源对指定列表进行置换。

    [java] view plaincopyprint?
    1. public class CollectionsTets {  
    2.     public static void main(String[] args) {  
    3.         ArrayList<String> al = new ArrayList<String>();  
    4.         al.add("w");  
    5.         al.add("aa");  
    6.         al.add("azweewew");  
    7.         al.add("abreew");  
    8.         al.add("cads");  
    9.         al.add("aa");  
    10.         System.out.println(al);  
    11.         Collections.shuffle(al);//将list元素的集合随机存放，假如做扑克牌洗牌操作就会用到  
    12.         System.out.println(al);  
    13.     }  
    14. }  
    4.将枚举类型集合转换为ArrayList类型集合

    list(Enumeration<T> e)：返回一个数组列表，它按返回顺序包含指定枚举返回的元素。

    [java] view plaincopyprint?
    1. public class CollectionsTets {  
    2.     public static void main(String[] args) {  
    3.         Vector<String> v = new Vector<String>();  
    4.         v.add("xa");  
    5.         v.add("xqwa");  
    6.         v.add("sddsxa");  
    7.         Enumeration<String> e = v.elements();  
    8.         ArrayList<String> al = Collections.list(e);  
    9.         System.out.println(al);  
    10.     }  
    11. }  
    5.可以将线程不同步的集合变成线程同步

    static
    <T> Collection<T>
    		synchronizedCollection(Collection<T> c)
              返回指定 collection 支持的同步（线程安全的）collection。
    static
    <T> List<T>
    		synchronizedList(List<T> list)
              返回指定列表支持的同步（线程安全的）列表。
    static
    <K,V> Map<K,V>
    		synchronizedMap(Map<K,V> m)
              返回由指定映射支持的同步（线程安全的）映射。
    static
    <T> Set<T>
    		synchronizedSet(Set<T> s)
              返回指定 set 支持的同步（线程安全的）set。

    4.将集合转换成数组（为了是集合里的元素转换成数组后不能增删操作）

     Object[] toArray()
              返回包含此 collection 中所有元素的数组。
    <T> T[]
    		toArray(T[] a)
              返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
    第一个方法和第二个的区别，就是第二个指定了类型，而使用第一个时，当被转换成数组时，里面的每个元素都向上提升为Object类型。

    当使用第二种方法时，参数的数组长度该如何定义呢？

    1.如果长度小于集合的size，那么该方法会创建一个同类型并且和集合size相同length的数组。

    2.如果长度大于集合的size，那么该方法就会使用指定的数组，存储集合中的元素，多余位置默认为null。

    所以建议数组长度为需要被转换的集合的size。

    [java] view plaincopyprint?
    1. public class ToStringTest {  
    2.     public static void main(String[] args) {  
    3.         List<String> list = new ArrayList<String>();  
    4.         list.add("xx1");  
    5.         list.add("xx2");  
    6.         list.add("xx3");  
    7.         String[] arr = list.toArray(new String[list.size()]);  
    8.         System.out.println(Arrays.toString(arr));  
    9.     }  
    10. }  




                                                         Arrays工具类(用于数组)                                                

    1.将数组打印出元素内容，而不是哈希值。

    [java] view plaincopyprint?
    1. public class ToStringTest {  
    2.     public static void main(String[] args) {  
    3.         int[] arr = {1,2,3,4,5};  
    4.         System.out.println(Arrays.toString(arr));  
    5.     }  
    6. }  

    2.将数组转换成list集合（为了使用集合中有的而数组中没的方法）

    static
    <T> List<T>
    		asList(T... a)
              返回一个受指定数组支持的固定大小的列表。

    [java] view plaincopyprint?
    1. public class ToStringTest {  
    2.     public static void main(String[] args) {  
    3.         String[] arr = {"1","2","3","4","5"};  
    4.         List<String> list1 = Arrays.asList(arr);  
    5.         list1.add("xxc");//java.lang.UnsupportedOperationException 执行到这句话会出异常  
    6.     }  
    7. }  
    出异常的原因是：经分析java源代码Arrys.asList();方法返回的不是平常熟悉的java.util.ArrayList类的对象。而是Arrays类的内部类的对象，而Arrays类里的内部类ArrayList没有实现AbstractList类的add方法，导致抛此异常!

    如果一定要将一个数组转换成一个集合，并且想往集合里添加或删除元素的话，可以用以下方法解决：

    [java] view plaincopyprint?
    1. public class ToStringTest {  
    2.     public static void main(String[] args) {  
    3.         String[] arr = {"1","2","3","4","5"};  
    4.         List<String> list2 = new ArrayList<String>(Arrays.asList(arr));//new一个新的集合，并且在构造的时候就传入一个集合（数组转换后的集合）  
    5.         list2.add("xxx");  
    6.         System.out.println(list2);  
    7.     }  
    8. }  

    注意：如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储。

        如果数组中的元素是基本类型数值，那么会将该数组作为集合中的元素进行存储。

    [java] view plaincopyprint?
    1. public class ToStringTest {  
    2.     public static void main(String[] args) {  
    3.         int[] arr = {1,2,3,4,5};  
    4.         List<int[]> list2 = Arrays.asList(arr);//因为被转换的数组的元素是基本数据类型，所以转换成的集合里的类型是数组类型  
    5.         System.out.println(list2);  
    6.     }  
    7. }  
  • 相关阅读:
    mysql常用函数
    快看看你躺枪了吗？最全搞笑中式英语大集合
    浏览器 返回状态码汇总
    Eclipse 快捷键 篇
    Spring定时任务的几种实现
    mysql ---复制表结构---创建新表
    日志级别的选择：Debug、Info、Warn、Error还是Fatal
    关闭网页时如何弹出消息框 提醒用户:您确认关闭吗 ？
    处理session丢失的问题
    工作中存在的问题
  • 原文地址：https://www.cnblogs.com/baiduligang/p/4247661.html
Copyright © 2011-2022 走看看