1.Array & Arrays 与Collection & Collections区别
(1)Collection": 是一个接口，与其子类共同组成一个Collection集合框架；
Collections: 是一个类，一个服务于集合的工具类, 提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
(2)Array: 提供了动态创建和访问 Java 数组的方法；
Arrays: 用于操作数组的工具类，里面都是操作数组的静态方法。其中一个比较重要的方法：asList() 将数组转化为List集合。
2.Collections常用方法(参见API)
(1)public static <T extends Comparable<? super T>> void sort(List<T> list)
根据元素的自然顺序进行排列
(2)public static <T> void sort(List<T> list, Comparator<? super T> c)
根据指定比较器的顺序对指定列表进行排序
1 import java.util.ArrayList;
2 import java.util.Collections;
3 import java.util.Comparator;
4 import java.util.List;
5
6 /**
7 * sort方法演示：
8 *
9 */
10 public class SortDemo
11 {
12 public static void main(String[] args)
13 {
14 List<String> al = new ArrayList<String>();
15
16 al.add("013");
17 al.add("03");
18 al.add("002");
19 System.out.println(al);
20
21 Collections.sort(al);
22 System.out.println(al);
23
24 Collections.sort(al,new LenCompare());
25 System.out.println(al);
26 }
27 }
28
29 //定义一个比较器，按照长度排序
30 class LenCompare implements Comparator<String>
31 {
32 public int compare(String s1,String s2)
33 {
34 if (s1.length()>s2.length())
35 return 1;
36 if (s1.length()<s2.length())
37 return -1;
38 return s1.compareTo(s2);
39 }
40 }
41
(3)public static <T> int binarySearch(List<? extends Comparable<? super T>> list ,T key): 二分法查找
使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序
(4)public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据指定的比较器对列表进行升序排序.
(5)public static void reverse(List<?> list)：反转指定列表中元素的顺序
(6)public static void swap(List<?> list, int i, int j):在指定列表的指定位置处交换元素
(7)public static <T> void fill(List<? super T> list, T obj)
使用指定元素替换指定列表中的所有元素。
(8)public static <T> void copy(List<? super T> dest, List<? extends T> src)
将所有元素从一个列表复制到另一个列表。执行此操作后，目标列表中每个已复制元素的索引将等同于源列表中该元素的索引。目标列表的长度至少必须等于源列表。如果目标列表更长一些，也不会影响目标列表中的其余元素。
(9)public static <T extends Object & Comparable<? super T>> T min(Collection<? exten ds T> coll)
根据元素的自然顺序 返回给定 collection 的最小元素.
(10)public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器产生的顺序，返回给定 collection 的最小元素。
(11)public static <T extends Object & Comparable<? super T>>T max(Collection<? extends T> coll)
根据元素的自然顺序，返回给定 collection 的最大元素。
(12)public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
使用另一个值替换列表中出现的所有某一指定值。
3.Arrays常用方法(参见API)
(1)public static <T> List<T> asList(T... a)
返回一个受指定数组支持的固定大小的列表。此方法同 Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。
(2)public static void sort(long/char/int/double/byte/Object[] a)
对指定的类型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法。
(3)public static void sort(long/char/int/double/byte/Object[] a, int fromIndex, int toIndex)
对指定类型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）
(4)public static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
(5)public static int binarySearch(类型[] a, long key)
使用二分搜索法来搜索指定的类型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(long[]) 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
(6)public static boolean equals(类型[] a, long[] a2)
如果两个指定的类型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。
(7)public static void fill(类型[] a, long val)
将指定的类型值分配给指定 long 型数组的每个元素。
(8)public static int hashCode(类型[] a)：基于指定数组的内容返回hashcode
(9)public static String toString(类型[] a)：返回指定数组内容的字符串表示形式。
1 public class ArraysDemo {
2
3 /**
4 * @param args
5 */
6 public static void main(String[] args) {
7
8 // String[] arr = new String[3];
9 // swap(arr,1,2);
10
11 // int[] arr = {45,23,78,11,99};
12 // System.out.println(Arrays.toString(arr));
13
14
15
16 String[] strs = {"abc","haha","nba","zz"};
17
18 // boolean b = myContains(strs, "nba");
19 // System.out.println(b);
20
21
22 //发现集合中本身有这个方法。contains。
23 //将数组转成集合。就哦了，数组转成list集合，就是为了使用集合的方法操作数组中的元素。
24 List<String> list = Arrays.asList(strs);
25 // list.add("qq");//java.lang.UnsupportedOperationException//注意，不能使用集合的增删方法。不能改变长度。
26 // System.out.println(list.contains("nba"));
27
28
29 /*
30 * 如果数组中都是引用数据类型，转成集合时，数组元素直接作为集合元素。
31 * 如果数组中都是基本数据类型，会将数组对象作为集合中的元素。
32 *
33 */
34 int[] arr = {45,23,78,11,99};
35 List<int[]> list2 = Arrays.asList(arr);
36 System.out.println(list2.get(0));
37
38 }
39
40 /**
41 *
42 * @param arr
43 * @param key
44 * @return
45 */
46 public static boolean myContains(String[] arr,String key){
47
48 for (int i = 0; i < arr.length; i++) {
49 String str = arr[i];
50
51 if(str.equals(key))
52 return true;
53
54 }
55 return false;
56
57 }
58
59 public static <T> void swap(T[] arr,int x,int y)
60 {
61 T temp = arr[x];
62 arr[x] = arr[y];
63 arr[y] = temp;
64 }
65
66 }
1 public class CollectionToArray {
2
3 /**
4 * @param args
5 */
6 public static void main(String[] args) {
7
8 //集合转成数组。Collection toArray
9
10
11 List<String> list = new ArrayList<String>();
12
13 list.add("abc");
14 list.add("haha");
15 /*
16 * 传入的的数组长度，如果小于集合长度，方法中会创建一个新的长度和集合长度一致的数组。
17 * 如果传入的数组长度大于等于集合长度，会使用传入的数组。所以建议长度定义为 集合的size();
18 *
19 *
20 * 为什么要把集合转成数组。
21 * 就是为了限定对元素的操作，比如增删。
22 *
23 */
24 String[] arr = list.toArray(new String[list.size()]);
25
26 System.out.println(Arrays.toString(arr));
27
28 }
29
30 }
代码来自创智播客
2018-01-03
原文地址：https://www.cnblogs.com/zhuweiheng/p/8179841.html