Collection

引用自：http://blog.csdn.net/itlwc/article/details/10148321

Collection层次结构

Collection

子接口  

  1. Set,List  
  2. 集合中只能放置对象的引用,不能放置原生数据类型,  
  3. 我们需要使用原生数据类型的封装类才能加入到集合中  

Ordered与Sorted接口

  1. Ordered排序,按照某种由具体情况决定的顺序排序,是后天指定的  
  2. Sorted排序,按照天然顺序进行排序,是先天指定的  

List

  1. 实现类包括  
  2.     LinkedList,Vector,ArrayList  
  3. 列表接口,继承与Collection,可以按索引的顺序访问,有索引的Collection  
  4.     具有列表的功能,元素顺序均是按添加的先后进行排列的,  
  5.     允许重复的元素,允许多个null元素

List常用方法

[java] view plain copy
  1. package com.itlwc;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. public class Test {  
  7.     public static void main(String[] args) {  
  8.         List list = new ArrayList();  
  9.         // 向列表的尾部追加指定的元素  
  10.         list.add("lwc");  
  11.         // 在列表的指定位置插入指定元素  
  12.         list.add(1, "nxj");  
  13.         // 追加指定 collection 中的所有元素到此列表的结尾  
  14.         list.addAll(new ArrayList());  
  15.         // 从列表中移除所有元素  
  16.         list.clear();  
  17.         // 如果列表包含指定的元素,则返回true  
  18.         list.contains("nxj");  
  19.         // 如果列表包含指定 collection 的所有元素,则返回 true  
  20.         list.containsAll(new ArrayList());  
  21.         // 比较指定的对象与列表是否相等  
  22.         list.equals(new ArrayList());  
  23.         // 返回列表中指定位置的元素  
  24.         list.get(0);  
  25.         // 返回列表的哈希码值  
  26.         list.hashCode();  
  27.         // 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1  
  28.         list.indexOf("lwc");  
  29.         // 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1  
  30.         list.lastIndexOf("lwc");  
  31.         // 如果列表不包含元素,则返回 true  
  32.         list.isEmpty();  
  33.         // 移除列表中指定位置的元素  
  34.         list.remove(0);  
  35.         // 移除列表中出现的首个指定元素  
  36.         list.remove("lwc");  
  37.         // 从列表中移除指定 collection 中包含的所有元素  
  38.         list.removeAll(new ArrayList());  
  39.         // 用指定元素替换列表中指定位置的元素  
  40.         list.set(0, "lp");  
  41.         // 返回列表中的元素数  
  42.         list.size();  
  43.         // 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图  
  44.         list.subList(1, 2);  
  45.         // 返回以正确顺序包含列表中的所有元素的数组  
  46.         list.toArray();  
  47.         // 返回以正确顺序包含列表中所有元素的数组  
  48.         list.toArray(new String[] { "a", "b" });  
  49.     }  
  50. }  

ArrayList

[plain] view plain copy
  1. 构造方法  
  2.     public ArrayList()  
  3.     public ArrayList(int initialCapacity)  
  4.     public ArrayList(Collection c)  
  5. ArrayList依赖于数组实现的,初始长度为10的Object[],并且可随需要而增加的动态数组  
  6.     当元素超过10,那么ArrayList底层会新生成一个数组,长度为原来的1.5倍+1,  
  7.     然后将原数组内容复制到新数组中,并且后续增加的内容会放到新数组中,  
  8.     当新数组无法容纳增加的元素,重复该过程  
  9. ArrayList对随机访问性能很好,但进行大量插入,删除操作,性能很差,  
  10.     因为操作之后后续元素需要移动  

遍历ArrayList

[java] view plain copy
  1. package com.itlwc;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Iterator;  
  5. import java.util.List;  
  6.   
  7. public class Test {  
  8.     public static void main(String[] args) {  
  9.         List<String> list = new ArrayList<String>();  
  10.         list.add("lwc");  
  11.         list.add("nxj");  
  12.         // 方法一  
  13.         Iterator<String> ite1 = list.iterator();  
  14.         while (ite1.hasNext()) {  
  15.             String str = ite1.next();  
  16.             System.out.println(str);  
  17.         }  
  18.         System.out.println("---------------------");  
  19.         // 方法二(方法一的变形)  
  20.         for (Iterator<String> ite2 = list.iterator(); ite2.hasNext();) {  
  21.             String str = ite2.next();  
  22.             System.out.println(str);  
  23.         }  
  24.         System.out.println("---------------------");  
  25.         // 方法三  
  26.         for(String s : list){  
  27.             System.out.println(s);  
  28.         }  
  29.     }  
  30. }  
  31. /* 
  32. 打印结果: 
  33.     lwc 
  34.     nxj 
  35.     --------------------- 
  36.     lwc 
  37.     nxj 
  38.     --------------------- 
  39.     lwc 
  40.     nxj 
  41. */  

Vector

[plain] view plain copy
  1. 向量,历史比较悠久,Java诞生就有了,特点与ArrayList相同,  
  2.     不同的是Vector操作元素的方法是同步的,同一时刻只能有一个线程访问,没有特殊需求都使用ArrayList  
  3. 构造方法  
  4.     public Vector()  
  5.     public Vector(int initialCapacity)  
  6.     public Vector(int initialCapacity,int capacityIncrement)  
  7.         第一个参数是初始容量,第二个参数是当Vector满时的增量  
  8.     public Vector(Collection c)  
  9. Vector也是依赖数组实现的  

案例

[java] view plain copy
  1. package com.itlwc;  
  2.   
  3. import java.util.Enumeration;  
  4. import java.util.Vector;  
  5.   
  6. public class Test {  
  7.     public static void main(String[] args) {  
  8.         Vector v = new Vector();  
  9.         v.add("123");  
  10.         v.add("lwc");  
  11.         v.add("你好");  
  12.         // Vector转换为枚举  
  13.         Enumeration e = v.elements();  
  14.         while (e.hasMoreElements()) {  
  15.             System.out.println(e.nextElement());  
  16.         }  
  17.     }  
  18. }  

Stack

[java] view plain copy
  1. Vector的子类  
案例
[java] view plain copy
  1. package com.itlwc;  
  2.   
  3. import java.util.Enumeration;  
  4. import java.util.Stack;  
  5.   
  6. public class Test {  
  7.     public static void main(String[] args) {  
  8.         Stack stack = new Stack();  
  9.         // 向栈里面压一个整数  
  10.         stack.push(new Integer(123));  
  11.         stack.push("lwc");  
  12.         stack.push(new Double(88.88));  
  13.         // 遍历  
  14.         Enumeration items = stack.elements();  
  15.         while (items.hasMoreElements()) {  
  16.             System.out.print(items.nextElement() + " ");  
  17.         }  
  18.         System.out.println();  
  19.         // 出栈  
  20.         while (stack.size() != 0) {  
  21.             System.out.print(stack.pop() + " ");  
  22.         }  
  23.     }  
  24. }  
  25. /* 
  26. 打印结果: 
  27.     123 lwc 88.88  
  28.     88.88 lwc 123 
  29. */  

LinkedList

[plain] view plain copy
  1. LinkedList功能与ArrayList,Vector相同,内部是依赖双链表实现的,  
  2.     因此有很好的插入和删除性能,但随机访问元素的性能很差  
  3. 构造方法  
  4.     public LinkedList()  
  5.     public LinkedList(Collection c)  
  6. LinkedList类中有一个Entry内部类,Entry内部类包含3个部分向前的引用,向后的引用,数据  
  7.     header.next = header.previous = header;  

遍历LinkedList

[java] view plain copy
  1. package com.itlwc;  
  2.   
  3. import java.util.LinkedList;  
  4. import java.util.List;  
  5. import java.util.ListIterator;  
  6.   
  7. public class Test {  
  8.     public static void main(String[] args) {  
  9.         List link = new LinkedList();  
  10.         link.add(123);  
  11.         link.add("lwc");  
  12.         link.add(8.8);  
  13.         link.add("nxj");  
  14.         link.add(520);  
  15.         printList(link);  
  16.         printReversedList(link);  
  17.     }  
  18.   
  19.     private static void printList(List link) {  
  20.         System.out.println("正序链表中的元素");  
  21.         // 的到链表的迭代器,位置指向链头  
  22.         ListIterator li = link.listIterator();  
  23.         // 判断迭代器中是否有下一个元素  
  24.         while (li.hasNext()) {  
  25.             // 返回下个元素  
  26.             System.out.print(li.next() + " ");  
  27.         }  
  28.         System.out.println();  
  29.     }  
  30.   
  31.     private static void printReversedList(List link) {  
  32.         System.out.println("逆向链表中的元素");  
  33.         // 的到链表的迭代器,位置指向link.size()结尾  
  34.         ListIterator li = link.listIterator(link.size());  
  35.         // 判断迭代器中是否有前一个元素  
  36.         while (li.hasPrevious()) {  
  37.             // 返回前一个元素  
  38.             System.out.print(li.previous() + " ");  
  39.         }  
  40.         System.out.println();  
  41.     }  
  42. }  
  43. /* 
  44. 打印结果: 
  45.     正序链表中的元素 
  46.     123 lwc 8.8 nxj 520  
  47.     逆向链表中的元素 
  48.     520 nxj 8.8 lwc 123  
  49. */  

自定义LinkedList结构

[java] view plain copy
  1. package com.itlwc;  
  2.   
  3. class Node {  
  4.     Node previous;// 前驱  
  5.     String data;// 数据  
  6.     Node next;// 后驱  
  7.   
  8.     public Node(String data) {  
  9.         this.data = data;  
  10.     }  
  11. }  
  12.   
  13. public class Test {  
  14.     public static void main(String[] args) {  
  15.         Node node1 = new Node("node1");  
  16.         Node node2 = new Node("node2");  
  17.         Node node3 = new Node("node3");  
  18.         node1.next = node2;  
  19.         node2.previous = node1;  
  20.         node2.next = node3;  
  21.         node3.previous = node2;  
  22.         node3.next = node1;  
  23.         node1.previous = node3;  
  24.   
  25.         // 增加node4  
  26.         Node node4 = new Node("node4");  
  27.         node1.next = node4;  
  28.         node4.previous = node1;  
  29.         node4.next = node2;  
  30.         node2.previous = node4;  
  31.         // 删除node4  
  32.         node1.next = node2;  
  33.         node2.previous = node1;  
  34.         node4.previous = null;  
  35.         node4.next = null;  
  36.   
  37.     }  
  38. }  

依赖倒置原理

[plain] view plain copy
  1. 依赖应该尽量在抽象层进行,避免在具体层进行,  
  2.     在实际开发中尽量使用接口类型的引用,避免采用具体类型的引用  

案例

[java] view plain copy
  1. package com.itlwc;  
  2.   
  3. import java.util.LinkedList;  
  4. import java.util.List;  
  5.   
  6. public class Test {  
  7.     //如果我们需要传入参数是ArrayList就需要改动代码  
  8.     public void printLinkedList(LinkedList ll){  
  9.         System.out.println(ll);  
  10.     }  
  11.     //如果我们传入参数是List的子类,我们不需要改动代码,灵活性大  
  12.     public void printList(List l){  
  13.         System.out.println(l);  
  14.     }  
  15. }  

将数组转换为列表

[java] view plain copy
  1. package com.itlwc;  
  2.   
  3. import java.util.Arrays;  
  4. import java.util.List;  
  5.   
  6. public class Test {  
  7.     public static void main(String[] args) {  
  8.         String[] str = { "l", "w", "c" };  
  9.         //使用Java类库中java.util.Arrays类的静态方法asList()  
  10.         List l = Arrays.asList(str);  
  11.         System.out.println(str);  
  12.     }  
  13.   
  14. }  
  15. /* 
  16. 打印结果: 
  17.     [l, w, c] 
  18. */  

ArrayList VS LinkedList

[plain] view plain copy
  1. ArrayList底层采用数组实现,LinkedList底层采用双链表实现  
  2. 如果为列表增加对象  
  3.     ArrayList是ArrayList底层数组维护的,LinkedList是LinkedList底层Entry对象维护的  
  4.     LinkedList底层Entry结构  
  5.         Entry{  
  6.             Entry previous;  
  7.             Object element;  
  8.             Entry next;  
  9.         }  
  10.         其中element就是我们添加的元素,最后将生成的Entry对象加入到链表中  
  11. 插入和删除操作时,采用LinkedList好,搜索时,采用ArrayList好  

List<Map>遍历

[java] view plain copy
  1. package com.itlwc;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.HashMap;  
  5. import java.util.Iterator;  
  6. import java.util.List;  
  7. import java.util.Map;  
  8.   
  9. public class Test {  
  10.     public static void main(String[] args) {  
  11.         Map<Integer, String> map1 = new HashMap<Integer, String>();  
  12.         map1.put(new Integer(1), "lwc");  
  13.         map1.put(new Integer(2), "nxj");  
  14.         Map<Integer, String> map2 = new HashMap<Integer, String>();  
  15.         map2.put(new Integer(3), "tom");  
  16.         map2.put(new Integer(4), "cat");  
  17.         List<Map<Integer, String>> list = new ArrayList<Map<Integer, String>>();  
  18.         list.add(map1);  
  19.         list.add(map2);  
  20.         // 方法一  
  21.         Iterator<Map<Integer, String>> ite1 = list.iterator();  
  22.         while (ite1.hasNext()) {  
  23.             Map<Integer, String> m = ite1.next();  
  24.             System.out.println(m);  
  25.         }  
  26.         System.out.println("-----------------------------");  
  27.         // 方法二(方法一的变形)  
  28.         for (Iterator<Map<Integer, String>> ite2 = list.iterator(); ite2.hasNext();) {  
  29.             Map<Integer, String> m = ite2.next();  
  30.             System.out.println(m);  
  31.         }  
  32.         System.out.println("-----------------------------");  
  33.         // 方法三:  
  34.         for (Map<Integer, String> m : list) {  
  35.             System.out.println(m);  
  36.         }  
  37.     }  
  38. }  
  39. /*  
  40. 打印结果:  
  41.     {1=lwc, 2=nxj} 
  42.     {3=tom, 4=cat} 
  43.     ----------------------------- 
  44.     {1=lwc, 2=nxj} 
  45.     {3=tom, 4=cat} 
  46.     ----------------------------- 
  47.     {1=lwc, 2=nxj} 
  48.     {3=tom, 4=cat} 
  49. */  

Set

[plain] view plain copy
  1. 实现类  
  2.     HashSet,LinkedHashSet  
  3. 子接口  
  4.     SortSet  
  5.     实现类  
  6.         TreeSet  
  7. 不包含重复元素,最多包含一个null,元素没有顺序  

HashSet

[plain] view plain copy
  1. HashSet不是Ordered也不是Sorted,存储对象引用时是按照哈希策略来实现的,  
  2.     HashSet中是否存在一个对象是通过equals()和hashCode()协同判断  
  3. 不保证顺序  
  4. 构造方法  
  5.     public HashSet()    
  6.     public HashSet(int initialCapacity)    
  7.     public HashSet(Collection c)  
  8. HashSet底层是使用HashMap实现的  
  9. HashSet的add()方法详解:  
  10.     判断已经存储在集合中的对象hashCode值是否与增加对象的hashCode值一致  
  11.     如果不一致,直接加进去  
  12.     如果一致,再进行equals()比较  
  13.         如果equals()返回true,对象已经存在不增加进去  
  14.         如果equals()返回false,把对象增加进去  

LinkedHashSet

[plain] view plain copy
  1. LinkedHashSet是Ordered,采用双链表实现的  
  2. 有固定顺序,也就是插入顺序  
  3. LinkedHashSet底层是使用LinkedHashMap实现的  
  4. 构造方法  
  5.     public LinkedHashSet()    
  6.     public LinkedHashSet(int initialCapacity)    
  7.     public LinkedHashSet(Collection c)  

SortedSet接口

[plain] view plain copy
  1. 保证迭代器按照元素递增顺序遍历的集合,可以按照元素的自然顺序进行排序  
  2. 常用方法  
  3.     Object first()  
  4.          返回此有序集合中当前第一个(最小的)元素  
  5.     Object last()  
  6.         返回此有序集合中最后一个(最大的)元素  
  7.     SortedSet headSet(Object toElement)  
  8.         返回此有序集合的部分视图,其元素严格小于toElement  
  9.     SortedSet tailSet(Object fromElement)  
  10.         返回此有序集合的部分视图,其元素大于或等于fromElement  
  11.     SortedSet subSet(Object fromElement,Object toElement)  
  12.         返回此有序集合的部分视图,元素范围从fromElement(包括)到toElement(不包括)  
  13.     Comparator comparator()  
  14.         返回与此有序集合关联的比较器,如果使用元素的自然顺序,则返回 null  

TreeSet

[java] view plain copy
  1. TreeSet是SortedSet接口的实现,元素不论以什么元素插入,在遍历的时候,都会以天然顺序遍历  
  2. TreeSet底层是使用TreeMap实现的  
  3. 构造方法  
  4.     public TreeSet()  
  5.     public TreeSet(SortedSet s)    
  6.     public TreeSet(int initialCapacity)  
  7.     public TreeSet(Comparator<? super E>)  
  8.     public TreeSet(Collection c)  
  9. 因为TreeSet是带排序的,所以想要为TreeSet增加自定义类型,必须指定排序规则  

TreeSet排序规则Comparator案例

[java] view plain copy
  1. package com.itlwc;  
  2.   
  3. import java.util.Comparator;  
  4. import java.util.Iterator;  
  5. import java.util.TreeSet;  
  6.   
  7. public class Test {  
  8.     public static void main(String[] args) {  
  9.         TreeSet set = new TreeSet(new PersonComparator());  
  10.         set.add(new Person("lwc", 80));  
  11.         set.add(new Person("nxj", 70));  
  12.         set.add(new Person("lp", 60));  
  13.         set.add(new Person("fy", 75));  
  14.         Iterator ite = set.iterator();  
  15.         while (ite.hasNext()) {  
  16.             Person p = (Person)ite.next();  
  17.             System.out.println(p.name);  
  18.         }  
  19.     }  
  20. }  
  21.   
  22. class Person {  
  23.     String name;  
  24.     int score;  
  25.   
  26.     public Person(String name, int score) {  
  27.         this.name = name;  
  28.         this.score = score;  
  29.     }  
  30. }  
  31.   
  32. class PersonComparator implements Comparator {  
  33.     public int compare(Object o1, Object o2) {  
  34.         Person p1 = (Person) o1;  
  35.         Person p2 = (Person) o2;  
  36.         return p1.score - p2.score;  
  37.     }  
  38. }  

Collections

[plain] view plain copy
  1. 操作Collection类的工具类,类中方法都是静态的  

Collections常用方法

[java] view plain copy
  1. package com.itlwc;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Collections;  
  5. import java.util.Comparator;  
  6.   
  7. public class Test {  
  8.     public static void main(String[] args) {  
  9.         // 将所有元素从一个列表复制到另一个列表  
  10.         Collections.copy(new ArrayList(), new ArrayList());  
  11.         // 如果两个指定collection中没有相同的元素,则返回 true  
  12.         Collections.disjoint(new ArrayList(), new ArrayList());  
  13.         // 使用指定元素替换指定列表中的所有元素  
  14.         Collections.fill(new ArrayList(), new Object());  
  15.         // 返回指定 collection 中等于指定对象的元素数  
  16.         Collections.frequency(new ArrayList(), new Object());  
  17.         // 返回指定源列表中第一次出现指定目标列表的起始位置,如果没有出现这样的列表,则返回 -1  
  18.         Collections.indexOfSubList(new ArrayList(), new ArrayList());  
  19.         // 根据元素的自然顺序，返回给定 collection 的最大元素  
  20.         Collections.max(new ArrayList());  
  21.         // //根据元素的自然顺序，返回给定 collection 的最大元素  
  22.         Collections.min(new ArrayList());  
  23.         // 使用另一个值替换列表中出现的所有某一指定值  
  24.         Collections.replaceAll(new ArrayList(), "oldVal", "newVal");  
  25.         // 反转指定列表中元素的顺序  
  26.         Collections.reverse(new ArrayList());  
  27.         // 返回一个比较器,它强行反转  
  28.         Collections.reverseOrder();  
  29.         // 返回一个比较器,它强行反转指定比较器的顺序  
  30.         Collections.reverseOrder(new Comparator() {  
  31.             @Override  
  32.             public int compare(Object o1, Object o2) {  
  33.                 return 0;  
  34.             }  
  35.         });  
  36.         // 使用默认随机源随机更改指定列表的序列  
  37.         Collections.shuffle(new ArrayList());  
  38.         // 根据元素的自然顺序对指定列表按升序进行排序  
  39.         Collections.sort(new ArrayList());  
  40.         // 根据元素的自然顺序对指定列表按降序进行排序  
  41.         Collections.sort(new ArrayList(), Collections.reverseOrder());  
  42.         // 在指定列表的指定位置处交换元素  
  43.         Collections.swap(new ArrayList(), 1, 2);  
  44.   
  45.     }  
  46. } 
posted @ 2016-03-30 11:39  上官沐沐  阅读(192)  评论(0)  编辑  收藏  举报