如题，Collection 和 Collections的区别？

Collections是针对集合类的一个帮助类。提供了一系列静态方法实现对各种集合的搜索、排序、线程完全化等操作。
相当于对Array进行类似操作的类——Arrays。如，Collections.max(Collection coll); 取coll中最大的元素。Collections.sort(List list); 对list中元素排序

你可以查一下java API文档，看看他们属于什么，以及都有哪些方法和哪些子类。
java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态、多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

个是接口一个是类，
Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

1. 1) 排序(Sort)
   
2. 使用sort方法可以根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的
   
3. double array[] = {112, 111, 23, 456, 231 };
   
4. for (int i = 0; i < array.length; i++) {
   
5. list.add(new Double(array[i]));
   
6. }
   
7. Collections.sort(list);
   
8. for (int i = 0; i < array.length; i++) {
   
9.    System.out.println(li.get(i));
   
10. }
    
11. //结果：112,111,23,456,231
    
12. 2) 混排（Shuffling）
    
13. 混排算法所做的正好与 sort 相反: 它打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List, 这样的排列具有相同的可能性（假设随机源是公正的）。这个算法在实现一个碰运气的游戏中是非常有用的。例如，它可被用来混排代表一副牌的 Card 对象的一个 List 。另外，在生成测试案例时，它也是十分有用的。
    
14. Collections.Shuffling(list)
    
15. double array[] = {112, 111, 23, 456, 231 };
    
16. for (int i = 0; i < array.length; i++) {
    
17. list.add(new Double(array[i]));
    
18. }
    
19. Collections.shuffle(list);
    
20. for (int i = 0; i < array.length; i++) {
    
21.    System.out.println(li.get(i));
    
22. }
    
23. //结果：112,111,23,456,231
    
24. 3) 反转(Reverse)
    
25.        使用Reverse方法可以根据元素的自然顺序 对指定列表按降序进行排序。
    
26. Collections.reverse(list)
    
27. double array[] = {112, 111, 23, 456, 231 };
    
28. for (int i = 0; i < array.length; i++) {
    
29. list.add(new Double(array[i]));
    
30. }
    
31. Collections. reverse (list);
    
32. for (int i = 0; i < array.length; i++) {
    
33.    System.out.println(li.get(i));
    
34. }
    
35. //结果：231,456,23,111,112
    
36. 4) 替换所以的元素(Fill)
    
37. 使用指定元素替换指定列表中的所有元素。
    
38. String str[] = {"dd","aa","bb","cc","ee"};
    
39. for(int j=0;j<str.length;j++){
    
40. li.add(new String(str[j]));
    
41. }
    
42. Collections.fill(li,"aaa");
    
43. for (int i = 0; i < li.size(); i++) {
    
44. System.out.println("list[" + i + "]=" + li.get(i));
    
45. 
    
46. }
    
47. //结果：aaa,aaa,aaa,aaa,aaa
    
48. 
    
49. 5) 拷贝(Copy)
    
50. 用两个参数，一个目标 List 和一个源 List, 将源的元素拷贝到目标，并覆盖它的内容。目标 List 至少与源一样长。如果它更长，则在目标 List 中的剩余元素不受影响。
    
51. Collections.copy(list,li): 后面一个参数是目标列表 ,前一个是源列表
    
52. double array[] = {112, 111, 23, 456, 231 };
    
53. List list = new ArrayList();
    
54. List li = new ArrayList();
    
55. for (int i = 0; i < array.length; i++) {
    
56. list.add(new Double(array[i]));
    
57. }
    
58. double arr[] = {1131,333};
    
59. String str[] = {"dd","aa","bb","cc","ee"};
    
60. for(int j=0;j<arr.length;j++){
    
61. li.add(new Double(arr[j]));
    
62. }
    
63. Collections.copy(list,li);
    
64. for (int i = 0; i <list.size(); i++) {
    
65. System.out.println("list[" + i + "]=" + list.get(i));
    
66. }
    
67. //结果：1131,333,23,456,231
    
68. 6) 返回Collections中最小元素(min)
    
69. 根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须是通过指定比较器可相互比较的
    
70. Collections.min(list)
    
71. double array[] = {112, 111, 23, 456, 231 };
    
72. List list = new ArrayList();
    
73. for (int i = 0; i < array.length; i++) {
    
74. list.add(new Double(array[i]));
    
75. }
    
76. Collections.min(list);
    
77. for (int i = 0; i <list.size(); i++) {
    
78. System.out.println("list[" + i + "]=" + list.get(i));
    
79. }
    
80. //结果：23
    
81. 7) 返回Collections中最小元素(max)
    
82. 根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的
    
83. Collections.max(list)
    
84. double array[] = {112, 111, 23, 456, 231 };
    
85. List list = new ArrayList();
    
86. for (int i = 0; i < array.length; i++) {
    
87. list.add(new Double(array[i]));
    
88. }
    
89. Collections.max(list);
    
90. for (int i = 0; i <list.size(); i++) {
    
91. System.out.println("list[" + i + "]=" + list.get(i));
    
92. }
    
93. //结果：456
    
94. 8) lastIndexOfSubList
    
95. 返回指定源列表中最后一次出现指定目标列表的起始位置
    
96. int count = Collections.lastIndexOfSubList(list,li);
    
97. double array[] = {112, 111, 23, 456, 231 };
    
98. List list = new ArrayList();
    
99. List li = new ArrayList();
    
100. for (int i = 0; i < array.length; i++) {
     
101. list.add(new Double(array[i]));
     
102. }
     
103. double arr[] = {111};
     
104. String str[] = {"dd","aa","bb","cc","ee"};
     
105. for(int j=0;j<arr.length;j++){
     
106. li.add(new Double(arr[j]));
     
107. }
     
108. Int locations = Collections. lastIndexOfSubList (list,li);
     
109. System.out.println(“===”+ locations);
     
110. //结果 3
     
111. 9) IndexOfSubList
     
112. 返回指定源列表中第一次出现指定目标列表的起始位置
     
113. int count = Collections.indexOfSubList(list,li);
     
114. double array[] = {112, 111, 23, 456, 231 };
     
115. List list = new ArrayList();
     
116. List li = new ArrayList();
     
117. for (int i = 0; i < array.length; i++) {
     
118. list.add(new Double(array[i]));
     
119. }
     
120. double arr[] = {111};
     
121. String str[] = {"dd","aa","bb","cc","ee"};
     
122. for(int j=0;j<arr.length;j++){
     
123. li.add(new Double(arr[j]));
     
124. }
     
125. Int locations = Collections.indexOfSubList(list,li);
     
126. System.out.println(“===”+ locations);
     
127. //结果 1
     
128. 10) Rotate
     
129. 根据指定的距离循环移动指定列表中的元素
     
130. Collections.rotate(list,-1);
     
131. 如果是负数，则正向移动，正数则方向移动
     
132. double array[] = {112, 111, 23, 456, 231 };
     
133. List list = new ArrayList();
     
134. for (int i = 0; i < array.length; i++) {
     
135. list.add(new Double(array[i]));
     
136. }
     
137. Collections.rotate(list,-1);
     
138. for (int i = 0; i <list.size(); i++) {
     
139. System.out.println("list[" + i + "]=" + list.get(i));
     
140. }
     
141. //结果：111,23,456,231,112
     
142. 
     

复制代码

Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections 是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

Collection是一个接口，它是List、Set和Queue接口的父接口，该接口里定义的方法既可以用于操作Set集合也可以用于气喘吁吁 作List和Queue集合;而Collections是一个操作集合的工具类，它可以用来操作Set、List和Map之类的集合，Collections里定义了大量方法对集合元素进行排序、查询和修改等操作，还可以将集合对象设为不可变、对集合对象实现同步控制等方法。

看到好多问这两个的区别的、好像面试的时候也要问吧、
个人感觉这两个也没什么不好区别的呀，只是名字有点像罢了、

Collection是个java.util下的接口，它是各种集合结构的父接口。
Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。

网上有篇文章写得很好，就是来说明这两个东东的、给你看一下：
Collection 层次结构中的根接口。
Collection 表示一组对象，这些对象也称为 collection的元素。
一些 collection 允许有重复的元素，而另一些则不允许。
一些 collection 是有序的，而另一些则是无序的。
JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和List）实现。
此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

Collection   
├List   
│├LinkedList   
│├ArrayList   
│└Vector   
│　└Stack   
└Set

collections
此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
它包含在 collection 上操作的多态算法，即“包装器”，
包装器返回由指定 collection 支持的新 collection，以及少数其他内容。
如果为此类的方法所提供的 collection 或类对象为 null，则这些方法都会抛出 NullPointerException。
lection 支持的新 collection，以及少数其他内容。
如果为此类的方法所提供的 collection 或类对象为 null，则这些方法都会抛出 NullPointerException。

那、这是代码：

1. import java.util.ArrayList;   
   
2. import java.util.Collections;   
   
3. import java.util.List;   
   
4.   
   
5. public class TestCollections {   
   
6.       
   
7.     public static void main(String args[]) {   
   
8.         //注意List是实现Collection接口的   
   
9.         List list = new ArrayList();   
   
10.         double array[] = { 112, 111, 23, 456, 231 };   
    
11.         for (int i = 0; i < array.length; i++) {   
    
12.             list.add(new Double(array[i]));   
    
13.         }   
    
14.         Collections.sort(list);   
    
15.         for (int i = 0; i < array.length; i++) {   
    
16.             System.out.println(list.get(i));   
    
17.         }   
    
18.         // 结果：23.0 111.0 112.0 231.0 456.0   
    
19.     }   
    
20. }

复制代码

Collection是集合类的上级接口，继承与他的接口主要有Set 和List。
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。