【Java心得总结六】Java容器中——Collection

• Z时代
• 2024-01-10
• 分类：综合

在【Java心得总结五】Java容器上——容器初探这篇博文中，我对Java容器类库从一个整体的偏向于宏观的角度初步认识了Java容器类库。而在这篇博文中，我想着重对容器类库中的Collection容器做一个着重的探索与总结。

Collection：一个独立元素的序列，这些元素都服从一条或多条规则。（注：Collection其实就是将一组数据对象按照一维线性的方式组织起来）List必须按照插入的顺序保存元素，而set不能有重复元素。Queue按照排队规则来确定对象产生的顺序（通常与它们被插入的顺序相同）。

废话不说先上图！

Java容器类库

——摘自《Thinking in java》

从上图中我们可以看出Collection是Java类库中的一个大的子模块，它主要包含了：List和Set两部分

Java中List可以将元素维护在特定的序列中（这里元素既可以是基本类型也可以自定义类【Java心得总结一】Java基本类型和包装类型解析）

List接口主要有两种实现类型：

• 基本的ArrayList，它长于随机访问元素，但是在List的中间插入和移除元素时较慢
• LinkedList，它通过代价较低的在List中间进行的插入和删除操作，提供了优化的顺序访问。LinkedList在随机访问方面相对比较慢。

（二者的关系基本就是数据机构中我们学过的顺序存储结构和链表的关系）

ArrayList：

声明：

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 
 4 class MyClass{}
 5 
 6 public class ArrayListTest{
 7   // 声明存放整数的列表，这里必须用包装器类型  
 8   List<Integer> l1 = new ArrayList<Integer>();  
 9   // 声明存放自定义类的列表  
10   List<MyClass>  l2 = new ArrayList<MyClass>();
11   // 也可以像这样不给出类型参数，编译器会在向l3中加入元素的时候进行判定  
12   List l3 = new ArrayList();  
13 }

声明一个List容器的时候，用到了泛型的知识（【Java心得总结四】Java泛型下——万恶的擦除）

还有一点有趣的是，我们声明了ArrayList对象，却将引用赋值给了List引用，从上面图中可以看出ArrayList是List接口的实现，所以我们用List引用来持有ArrayList对象是完全可行的。

方法：

代码示例：

 1 //: holding/ListFeatures.java 
 2 import java.util.*;
 3 
 4 public class ArrayListTest {
 5     public static void main(String[] args) {
 6         Random rand = new Random(47);
 7         List<String> ls = new ArrayList<String>();
 8         ls.add("s1");
 9         ls.add("s2");
10         ls.add("s3");
11         ls.add("s4");
12         ls.add("s5");
13         System.out.println("1: " + ls);
14         String s6 = new String("s6");
15         ls.add(s6); // Automatically resizes
16         System.out.println("2: " + ls);
17         System.out.println("3: " + ls.contains(s6));
18         ls.remove(s6); // Remove by object
19         String s3 = ls.get(2);
20         System.out.println("4: " + s3 + " " + ls.indexOf(s3));
21         String s7 = new String();
22         System.out.println("5: " + ls.indexOf(s7));
23         System.out.println("6: " + ls.remove(s7));
24         // Must be the exact object:
25         System.out.println("7: " + ls.remove(s3));
26         System.out.println("8: " + ls);
27         ls.add(3, new String("s8")); // Insert at an index
28         System.out.println("9: " + ls);
29         List<String> sub = ls.subList(1, 4);
30         System.out.println("subList: " + sub);
31         System.out.println("10: " + ls.containsAll(sub));
32         Collections.sort(sub); // In-place sort
33         System.out.println("sorted subList: " + sub);
34         // Order is not important in containsAll():
35         System.out.println("11: " + ls.containsAll(sub));
36         Collections.shuffle(sub, rand); // Mix it up
37         System.out.println("shuffled subList: " + sub);
38         System.out.println("12: " + ls.containsAll(sub));
39         List<String> copy = new ArrayList<String>(ls);
40         sub = Arrays.asList(ls.get(1), ls.get(4));
41         System.out.println("sub: " + sub);
42         copy.retainAll(sub);
43         System.out.println("13: " + copy);
44         copy = new ArrayList<String>(ls); // Get a fresh copy
45         copy.remove(2); // Remove by index
46         System.out.println("14: " + copy);
47         copy.removeAll(sub); // Only removes exact objects
48         System.out.println("15: " + copy);
49         copy.set(1, new String("s9")); // Replace an element
50         System.out.println("16: " + copy);
51         copy.addAll(2, sub); // Insert a list in the middle
52         System.out.println("17: " + copy);
53         System.out.println("18: " + ls.isEmpty());
54         ls.clear(); // Remove all elements
55         System.out.println("19: " + ls);
56         System.out.println("20: " + ls.isEmpty());
57         List newLs = new ArrayList<String>();
58         newLs.add("newS1");
59         newLs.add("newS2");
60         newLs.add("newS3");
61         newLs.add("newS4");
62         newLs.add("newS5");
63         ls.addAll(newLs);
64         System.out.println("21: " + ls);
65         Object[] o = ls.toArray();
66         System.out.println("22: " + o[3]);
67         String[] str = ls.toArray(new String[0]);
68         System.out.println("23: " + str[3]);
69     }
70 }
71 /*
72 1: [s1, s2, s3, s4, s5]
73 2: [s1, s2, s3, s4, s5, s6]
74 3: true
75 4: s3 2
76 5: -1
77 6: false
78 7: true
79 8: [s1, s2, s4, s5]
80 9: [s1, s2, s4, s8, s5]
81 subList: [s2, s4, s8]
82 10: true
83 sorted subList: [s2, s4, s8]
84 11: true
85 shuffled subList: [s4, s2, s8]
86 12: true
87 sub: [s4, s5]
88 13: [s4, s5]
89 14: [s1, s4, s8, s5]
90 15: [s1, s8]
91 16: [s1, s9]
92 17: [s1, s9, s4, s5]
93 18: false
94 19: []
95 20: true
96 21: [newS1, newS2, newS3, newS4, newS5]
97 22: newS4
98 23: newS4
99 *///:~

上面的代码我们以String作为List容器的存储对象，基本涵盖了所有基本的ArrayList操作。

我们在代码36行使用了Collections的shuffle方法，它的作用就是将容器中的元素打乱。

LinkedList

正如我们前面提到的，像ArrayList一样LinkedList也实现了基本的List接口，但是在某些方面它要比ArrayList要高效一些，如插入和移除操作，但是在随机访问方面要逊色一些。

另外LinkedList还有一个重要的作用是用来实现栈、队列以及双端队列等数据结构中的一些基本结构

声明：

 1 import java.util.*;
 2 class MyClass{}
 3 public class LinkedListTest {
 4     // 声明持有String类型的列表，同样这里我们可以用List来持有LinkedList的引用
 5     List<String> ls = new LinkedList<String>();
 6     // 声明持有自定义类型的列表
 7     List<MyClass> lsm = new LinkedList<MyClass>();
 8     // 同样我们可以用LinkedList的引用来持有它
 9     LinkedList<String> lss = new LinkedList<String>();
10     // 同ArrayList一样我们也可以并不在声明时赋以类型参数，而再赋值时再确定
11     List l = new LinkedList();
12 }

上面的声明方式同ArrayList是基本一样的，我们可以利用List接口来持有LinkedList对象的引用，同样也可以用LinkedList自己来持有这个引用

方法：

因为LinkedList也实现了List接口，当然上面ArrayList中的方法也都包含，除此之外它还包含如下方法

代码示例

 1 import java.util.*;
 2 
 3 public class LinkedListTest {
 4     public static void main(String[] args) {
 5         LinkedList<String> ls = new LinkedList<String>();
 6         ls.add("s1");
 7         ls.addFirst("s2");
 8         ls.addLast("s3");
 9         System.out.println(ls);
10         // Identical:
11         System.out.println("ls.getFirst(): " + ls.getFirst());
12         System.out.println("ls.element(): " + ls.element());
13         // Only differs in empty-list behavior:
14         System.out.println("ls.peek(): " + ls.peek());
15         // Identical; remove and return the first element:
16         System.out.println("ls.remove(): " + ls.remove());
17         System.out.println("ls.removeFirst(): " + ls.removeFirst());
18         // Only differs in empty-list behavior:
19         System.out.println("ls.poll(): " + ls.poll());
20         System.out.println(ls);
21         ls.addFirst(new String("s4"));
22         System.out.println("After addFirst(): " + ls);
23         ls.offer(new String("s5"));
24         System.out.println("After offer(): " + ls);
25         ls.add(new String("s6"));
26         System.out.println("After add(): " + ls);
27         ls.addLast(new String("s7"));
28         System.out.println("After addLast(): " + ls);
29         System.out.println("ls.removeLast(): " + ls.removeLast());
30     }
31 }
32 /*
33 [s2, s1, s3]
34 ls.getFirst(): s2
35 ls.element(): s2
36 ls.peek(): s2
37 ls.remove(): s2
38 ls.removeFirst(): s1
39 ls.poll(): s3
40 []
41 After addFirst(): [s4]
42 After offer(): [s4, s5]
43 After add(): [s4, s5, s6]
44 After addLast(): [s4, s5, s6, s7]
45 ls.removeLast(): s7
46 *///:~

说完了List，我们一定会想到数据结构中非常重要的两种，队列和栈，在Java中这两种数据结构我们应该怎么实现呢？这就要用到我们刚介绍的LinkedList

栈和队列

栈：

“栈”通常指后进先出（LIFO）的容器，在博文刚开始的图中，我们肯定会发现Java容器类库的结构图中已经包含了栈这个结构，但是基于在Java1.0中设计者的失误导致Stack在新版本的Java中是不推荐使用（这里原因不具体废话了，反正就是不用它便是），然而有了LinkedList，我们完全可以自己很快的写一个，因为说到底栈无非就是操作受限的链表（它只允许在链表的一端进行读写操作）。

代码：

 1 import java.util.LinkedList;
 2 
 3 public class Stack<T> {
 4     private LinkedList<T> storage = new LinkedList<T>();
 5 
 6     public void push(T v) {
 7         storage.addFirst(v);
 8     }
 9 
10     public T peek() {
11         return storage.getFirst();
12     }
13 
14     public T pop() {
15         return storage.removeFirst();
16     }
17 
18     public boolean empty() {
19         return storage.isEmpty();
20     }
21 
22     public String toString() {
23         return storage.toString();
24     }
25 } // /:~ 

这里我们将LinkedList用组合的方式封装在我们的Stack类中，切记这里不能使用继承，因为如果我们的Stack类继承自LinkedList，那么从外部我们就可以获得所有LinkedList的public接口，那么栈就没意义了（其实Java1.0中的Stack的设计就犯了这个错误）

队列：

“队列”是一个典型的先进先出（FIFO）的容器，并且在【Java心得总结五】Java容器上——容器初探博文的图中我们可以看到LinkedList除了实现了List接口还实现了Queue接口，这也就是为什么我们在上面介绍LinkedList时会有那么多功能重复但是名字不同的方法的原因了。

代码：

 1 import java.util.*;
 2 
 3 public class QueueDemo {
 4     public static void printQ(Queue queue) {
 5         while (queue.peek() != null)
 6             System.out.print(queue.remove() + " ");
 7         System.out.println();
 8     }
 9 
10     public static void main(String[] args) {
11         Queue<Integer> queue = new LinkedList<Integer>();
12         Random rand = new Random(47);
13         for (int i = 0; i < 10; i++)
14             queue.offer(rand.nextInt(i + 10));
15         printQ(queue);
16         Queue<Character> qc = new LinkedList<Character>();
17         for (char c : "Brontosaurus".toCharArray())
18             qc.offer(c);
19         printQ(qc);
20     }
21 } /*
22  * Output: 8 1 1 1 5 14 3 1 0 1 B r o n t o s a u r u s
23  */// :~ 

其实从上面我们可以看出我们利用Queue来持有LinkedList对象时，Queue窄化了LinkedList的方法访问权限，以使得有恰当的方法才可以使用。（这很合理，因为同栈一样，队列说到底也是操作受限的链表，它只允许在一端写入另一端读）

List的遍历

像数组一样，我们对容器列表经常做得操作就是遍历，当然了我们可以向遍历数组一样用一个迭代变量进行叠加，然后利用get()方法来取出对应索引位置的元素来达到遍历的目的。但是还有一个更好的方法就是利用Iterator接口（参见【Java心得总结五】Java容器上——容器初探）

二、Set接口

Set最最重要的特征就是不保存重复元素。从博文开始的图中我们可以看出Set接口主要有两种具体的实现：HashSet和TreeSet，而在HashSet的基础上还实现了一个LinkedHashSet。

• HashSet：拥有最快的查询速度，存入HashSet的元素必须定义hashCode()方法
• TreeSet：保持元素处于排序状态，底层为树结构。使用它可以从Set中提取有序的序列。元素必须实现Comparable接口
• LinkedHashSet：以插入顺序保持元素，用迭代器进行遍历时会按照插入时的顺序显示，但也必须定义hashCode()方法

Set具有与Collection完全一样的接口，因此没有任何额外的功能，不像前面有两个不同的List。实际上Set就是Collection，只是行为不同。（这是继承与多态思想的典型应用：表现不同的行为。）Set是基于对象的值来确定对象的归属性的。

代码示例：

 1 import java.util.*;
 2 
 3 class SetType {
 4     int i;
 5 
 6     public SetType(int n) {
 7         i = n;
 8     }
 9 
10     public boolean equals(Object o) {
11         return o instanceof SetType && (i == ((SetType) o).i);
12     }
13 
14     public String toString() {
15         return Integer.toString(i);
16     }
17 }
18 
19 class HashType extends SetType {
20     public HashType(int n) {
21         super(n);
22     }
23 
24     public int hashCode() {
25         return i;
26     }
27 }
28 
29 class TreeType extends SetType implements Comparable<TreeType> {
30     public TreeType(int n) {
31         super(n);
32     }
33 
34     public int compareTo(TreeType arg) {
35         return (arg.i < i ? -1 : (arg.i == i ? 0 : 1));
36     }
37 }
38 
39 public class TypesForSets {
40     static <T> Set<T> fill(Set<T> set, Class<T> type) {
41         try {
42             for (int i = 0; i < 10; i++)
43                 set.add(type.getConstructor(int.class).newInstance(i));
44         }
45         catch (Exception e) {
46             throw new RuntimeException(e);
47         }
48         return set;
49     }
50 
51     static <T> void test(Set<T> set, Class<T> type) {
52         fill(set, type);
53         fill(set, type); // Try to add duplicates
54         fill(set, type);
55         System.out.println(set);
56     }
57 
58     public static void main(String[] args) {
59         test(new HashSet<HashType>(), HashType.class);
60         test(new LinkedHashSet<HashType>(), HashType.class);
61         test(new TreeSet<TreeType>(), TreeType.class);
62         // Things that don’t work:
63         test(new HashSet<SetType>(), SetType.class);
64         test(new HashSet<TreeType>(), TreeType.class);
65         test(new LinkedHashSet<SetType>(), SetType.class);
66         test(new LinkedHashSet<TreeType>(), TreeType.class);
67         try {
68             test(new TreeSet<SetType>(), SetType.class);
69         }
70         catch (Exception e) {
71             System.out.println(e.getMessage());
72         }
73         try {
74             test(new TreeSet<HashType>(), HashType.class);
75         }
76         catch (Exception e) {
77             System.out.println(e.getMessage());
78         }
79     }
80 }
81 /*
82 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
83 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
84 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
85 [8, 9, 2, 1, 6, 7, 1, 5, 8, 7, 8, 0, 5, 5, 2, 0, 1, 6, 4, 7, 3, 2, 9, 0, 6, 9, 4, 4, 3, 3]
86 [0, 9, 4, 0, 8, 5, 6, 7, 7, 9, 8, 6, 1, 4, 1, 3, 3, 7, 6, 2, 0, 4, 3, 5, 9, 2, 8, 5, 1, 2]
87 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
88 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
89 java.lang.ClassCastException: SetType cannot be cast to java.lang.Comparable
90 java.lang.ClassCastException: HashType cannot be cast to java.lang.Comparable
91 *///:~

这里不得不提的是hashCode()和Comparable接口这会在下篇博文中进行详细解释（【Java心得总结七】Java容器下——Map）

代码中SetType作为基类，而HashType和TreeType分别对HashSet和TreeSet做了展示（二者分别实现了hashCode()和Comparable接口）

总结：

这篇博文对Java容器类库中的Collection部分做了详细的阐述，在Set这里还留了个尾巴即hashCode()和Comparable接口的问题（要不篇幅太长了），将在下篇博文进行总结。

以上是 【Java心得总结六】Java容器中——Collection 的全部内容， 来源链接： utcz.com/z/391756.html