Collections工具类和Arrays工具类常见方法

Collections⼯具类和Arrays⼯具类常见⽅法
⼀、Collections
Collections ⼯具类常⽤⽅法:
排序
查找
替换操作
同步控制(不推荐，需要线程安全的集合类型时请考虑使⽤ JUC 包下的并发集合)
排序操作
1void reverse(List list)//反转
2void shuffle(List list)//随机排序
3void sort(List list)//按⾃然排序的升序排序
4void sort(List list, Comparator c)//定制排序，由Comparator控制排序逻辑
5void swap(List list, int i , int j)//交换两个索引位置的元素
6void rotate(List list, int distance)//旋转。

当distance为正数时，将list后distance个元素整体移到前⾯。

当distance为负数时，将 list的前distance个元素整体移到后⾯。

⽰例代码:
1 ArrayList<Integer> arrayList = new ArrayList<Integer>();
2 arrayList.add(-1);
3 arrayList.add(3);
4 arrayList.add(3);
5 arrayList.add(-5);
6 arrayList.add(7);
7 arrayList.add(4);
8 arrayList.add(-9);
9 arrayList.add(-7);
10 System.out.println("原始数组:");
11 System.out.println(arrayList);
12// void reverse(List list)：反转
13 Collections.reverse(arrayList);
14 System.out.println("Collections.reverse(arrayList):");
15 System.out.println(arrayList);
16
17
18 Collections.rotate(arrayList, 4);
19 System.out.println("Collections.rotate(arrayList, 4):");
20 System.out.println(arrayList);
21
22// void sort(List list),按⾃然排序的升序排序
23 Collections.sort(arrayList);
24 System.out.println("Collections.sort(arrayList):");
25 System.out.println(arrayList);
26
27// void shuffle(List list),随机排序
28 Collections.shuffle(arrayList);
29 System.out.println("Collections.shuffle(arrayList):");
30 System.out.println(arrayList);
31
32// void swap(List list, int i , int j),交换两个索引位置的元素
33 Collections.swap(arrayList, 2, 5);
34 System.out.println("Collections.swap(arrayList, 2, 5):");
35 System.out.println(arrayList);
36
37// 定制排序的⽤法
38 Collections.sort(arrayList, new Comparator<Integer>() {
39
40 @Override
41public int compare(Integer o1, Integer o2) {
42return pareTo(o1);
43 }
44 });
45 System.out.println("定制排序后：");
46 System.out.println(arrayList);
查找,替换操作
1int binarySearch(List list, Object key)//对List进⾏⼆分查找，返回索引，注意List必须是有序的
2int max(Collection coll)//根据元素的⾃然顺序，返回最⼤的元素。

类⽐int min(Collection coll)
3int max(Collection coll, Comparator c)//根据定制排序，返回最⼤元素，排序规则由Comparatator类控制。

类⽐int min(Collection coll, Comparator c)
4void fill(List list, Object obj)//⽤指定的元素代替指定list中的所有元素。

5int frequency(Collection c, Object o)//统计元素出现次数
6int indexOfSubList(List list, List target)//统计target在list中第⼀次出现的索引，找不到则返回-1，类⽐int lastIndexOfSubList(List source, list target).
7boolean replaceAll(List list, Object oldVal, Object newVal), ⽤新元素替换旧元素
⽰例代码：
1 ArrayList<Integer> arrayList = new ArrayList<Integer>();
2 arrayList.add(-1);
3 arrayList.add(3);
4 arrayList.add(3);
5 arrayList.add(-5);
6 arrayList.add(7);
7 arrayList.add(4);
8 arrayList.add(-9);
9 arrayList.add(-7);
10 ArrayList<Integer> arrayList2 = new ArrayList<Integer>();
11 arrayList2.add(-3);
12 arrayList2.add(-5);
13 arrayList2.add(7);
14 System.out.println("原始数组:");
15 System.out.println(arrayList);
16
17 System.out.println("Collections.max(arrayList):");
18 System.out.println(Collections.max(arrayList));
19
20 System.out.println("Collections.min(arrayList):");
21 System.out.println(Collections.min(arrayList));
22
23 System.out.println("Collections.replaceAll(arrayList, 3, -3):");
24 Collections.replaceAll(arrayList, 3, -3);
25 System.out.println(arrayList);
26
27 System.out.println("Collections.frequency(arrayList, -3):");
28 System.out.println(Collections.frequency(arrayList, -3));
29
30 System.out.println("Collections.indexOfSubList(arrayList, arrayList2):");
31 System.out.println(Collections.indexOfSubList(arrayList, arrayList2));
32
33 System.out.println("Collections.binarySearch(arrayList, 7):");
34// 对List进⾏⼆分查找，返回索引，List必须是有序的
35 Collections.sort(arrayList);
36 System.out.println(Collections.binarySearch(arrayList, 7));
同步控制
Collections提供了多个synchronizedXxx()⽅法·，该⽅法可以将指定集合包装成线程同步的集合，从⽽解决多线程并发访问集合时的线程安全问题。

我们知道 HashSet，TreeSet，ArrayList,LinkedList,HashMap,TreeMap 都是线程不安全的。

Collections提供了多个静态⽅法可以把他们包装成线程同步的集合。

最好不要⽤下⾯这些⽅法，效率⾮常低，需要线程安全的集合类型时请考虑使⽤ JUC 包下的并发集合。

⽅法如下：
1 synchronizedCollection(Collection<T> c) //返回指定 collection ⽀持的同步（线程安全的）collection。

2 synchronizedList(List<T> list)//返回指定列表⽀持的同步（线程安全的）List。

3 synchronizedMap(Map<K,V> m) //返回由指定映射⽀持的同步（线程安全的）Map。

4 synchronizedSet(Set<T> s) //返回指定 set ⽀持的同步（线程安全的）set。

Collections还可以设置不可变集合，提供了如下三类⽅法：
1 emptyXxx(): 返回⼀个空的、不可变的集合对象，此处的集合既可以是List，也可以是Set，还可以是Map。

2 singletonXxx(): 返回⼀个只包含指定对象（只有⼀个或⼀个元素）的不可变的集合对象，此处的集合可以是：List，Set，Map。

3 unmodifiableXxx(): 返回指定集合对象的不可变视图，此处的集合可以是：List，Set，Map。

4上⾯三类⽅法的参数是原有的集合对象，返回值是该集合的”只读“版本。

⽰例代码：
1 ArrayList<Integer> arrayList = new ArrayList<Integer>();
2 arrayList.add(-1);
3 arrayList.add(3);
4 arrayList.add(3);
5 arrayList.add(-5);
6 arrayList.add(7);
7 arrayList.add(4);
8 arrayList.add(-9);
9 arrayList.add(-7);
10 HashSet<Integer> integers1 = new HashSet<>();
11 integers1.add(1);
12 integers1.add(3);
13 integers1.add(2);
14 Map scores = new HashMap();
15 scores.put("语⽂" , 80);
16 scores.put("Java" , 82);
17
18//Collections.emptyXXX();创建⼀个空的、不可改变的XXX对象
19 List<Object> list = Collections.emptyList();
20 System.out.println(list);//[]
21 Set<Object> objects = Collections.emptySet();
22 System.out.println(objects);//[]
23 Map<Object, Object> objectObjectMap = Collections.emptyMap();
24 System.out.println(objectObjectMap);//{}
25
26//Collections.singletonXXX();
27 List<ArrayList<Integer>> arrayLists = Collections.singletonList(arrayList);
28 System.out.println(arrayLists);//[[-1, 3, 3, -5, 7, 4, -9, -7]]
29//创建⼀个只有⼀个元素，且不可改变的Set对象
30 Set<ArrayList<Integer>> singleton = Collections.singleton(arrayList);
31 System.out.println(singleton);//[[-1, 3, 3, -5, 7, 4, -9, -7]]
32 Map<String, String> nihao = Collections.singletonMap("1", "nihao");
33 System.out.println(nihao);//{1=nihao}
34
35//unmodifiableXXX();创建普通XXX对象对应的不可变版本
36 List<Integer> integers = Collections.unmodifiableList(arrayList);
37 System.out.println(integers);//[-1, 3, 3, -5, 7, 4, -9, -7]
38 Set<Integer> integers2 = Collections.unmodifiableSet(integers1);
39 System.out.println(integers2);//[1, 2, 3]
40 Map<Object, Object> objectObjectMap2 = Collections.unmodifiableMap(scores);
41 System.out.println(objectObjectMap2);//{Java=82, 语⽂=80}
42
43//添加出现异常：ng.UnsupportedOperationException
44// list.add(1);
45// arrayLists.add(arrayList);
46// integers.add(1);
⼆、Arrays类的常见操作
排序 : sort()
查找 : binarySearch()
⽐较: equals()
填充 : fill()
转列表: asList()
转字符串 : toString()
复制: copyOf()
排序 : sort()
1// *************排序 sort****************
2int a[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
3// sort(int[] a)⽅法按照数字顺序排列指定的数组。

4 Arrays.sort(a);
5 System.out.println("Arrays.sort(a):");
6for (int i : a) {
7 System.out.print(i);
8 }
9// 换⾏
10 System.out.println();
11
12// sort(int[] a,int fromIndex,int toIndex)按升序排列数组的指定范围
13int b[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
14 Arrays.sort(b, 2, 6);
15 System.out.println("Arrays.sort(b, 2, 6):");
16for (int i : b) {
17 System.out.print(i);
18 }
19// 换⾏
20 System.out.println();
21
22int c[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
23// parallelSort(int[] a) 按照数字顺序排列指定的数组(并⾏的)。

同sort⽅法⼀样也有按范围的排序
24 Arrays.parallelSort(c);
25 System.out.println("Arrays.parallelSort(c)：");
26for (int i : c) {
27 System.out.print(i);
28 }
29// 换⾏
30 System.out.println();
31
32// parallelSort给字符数组排序，sort也可以
33char d[] = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
34 Arrays.parallelSort(d);
35 System.out.println("Arrays.parallelSort(d)：");
36for (char d2 : d) {
37 System.out.print(d2);
38 }
39// 换⾏
40 System.out.println();
在做算法⾯试题的时候，我们还可能会经常遇到对字符串排序的情况,Arrays.sort() 对每个字符串的特定位置进⾏⽐较，然后按照升序排序。

1 String[] strs = { "abcdehg", "abcdefg", "abcdeag" };
2 Arrays.sort(strs);
3 System.out.println(Arrays.toString(strs));//[abcdeag, abcdefg, abcdehg]
查找 : binarySearch()
1// *************查找 binarySearch()****************
2char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
3// 排序后再进⾏⼆分查找，否则找不到
4 Arrays.sort(e);
5 System.out.println("Arrays.sort(e)" + Arrays.toString(e));
6 System.out.println("Arrays.binarySearch(e, 'c')：");
7int s = Arrays.binarySearch(e, 'c');
8 System.out.println("字符c在数组的位置：" + s);
⽐较: equals()
1// *************⽐较 equals****************
2char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
3char[] f = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
4/*
5 * 元素数量相同，并且相同位置的元素相同。

另外，如果两个数组引⽤都是null，则它们被认为是相等的。

6*/
7// 输出true
8 System.out.println("Arrays.equals(e, f):" + Arrays.equals(e, f));
填充 : fill()
1// *************填充fill(批量初始化)****************
2int[] g = { 1, 2, 3, 3, 3, 3, 6, 6, 6 };
3// 数组中所有元素重新分配值
4 Arrays.fill(g, 3);
5 System.out.println("Arrays.fill(g, 3)：");
6// 输出结果：333333333
7for (int i : g) {
8 System.out.print(i);
9 }
10// 换⾏
11 System.out.println();
12
13int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, };
14// 数组中指定范围元素重新分配值
15 Arrays.fill(h, 0, 2, 9);
16 System.out.println("Arrays.fill(h, 0, 2, 9);：");
17// 输出结果：993333666
18for (int i : h) {
19 System.out.print(i);
20 }
转列表 asList()
1// *************转列表 asList()****************
2/*
3 * 返回由指定数组⽀持的固定⼤⼩的列表。

4 * （将返回的列表更改为“写⼊数组”。

）该⽅法作为基于数组和基于集合的API之间的桥梁，与Collection.toArray()相结合。

5 * 返回的列表是可序列化的，并实现RandomAccess 。

6 * 此⽅法还提供了⼀种⽅便的⽅式来创建⼀个初始化为包含⼏个元素的固定⼤⼩的列表如下：
7*/
8 List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
9 System.out.println(stooges);
转字符串 toString()
1// *************转字符串 toString()****************
2/*
3 * 返回指定数组的内容的字符串表⽰形式。

4*/
5char[] k = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
6 System.out.println(Arrays.toString(k));// [a, f, b, c, e, A, C, B]
复制 copyOf()
1// *************复制 copy****************
2// copyOf ⽅法实现数组复制,h为数组，6为复制的长度
3int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, };
4int i[] = Arrays.copyOf(h, 6);
5 System.out.println("Arrays.copyOf(h, 6);：");
6// 输出结果：123333
7for (int j : i) {
8 System.out.print(j);
9 }
10// 换⾏
11 System.out.println();
12// copyOfRange将指定数组的指定范围复制到新数组中
13int j[] = Arrays.copyOfRange(h, 6, 11);
14 System.out.println("Arrays.copyOfRange(h, 6, 11)：");
15// 输出结果66600(h数组只有9个元素这⾥是从索引6到索引11复制所以不⾜的就为0) 16for (int j2 : j) {
17 System.out.print(j2);
18 }
19// 换⾏
20 System.out.println();。