【Java】集合系列18（Arrays和Collections工具类）

1、Arrays类

Arrays类常用方法概述：
本类所有方法都是静态的，本类方法是针对数组的操作。

//部分Arrays的静态方法（JDK1.8）
static <T> List<T> asList(T... a) 
返回由指定数组支持的固定大小的列表。 

static int binarySearch(byte[] a, byte key) 
使用二进制搜索算法搜索指定值的指定字节数组。  

static int[] copyOf(int[] original, int newLength) 
复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。  

static int[] copyOfRange(int[] original, int from, int to) 
将指定数组的指定范围复制到新数组中。  

static boolean deepEquals(Object[] a1, Object[] a2) 
如果两个指定的数组彼此 深度相等 ，则返回 true 。 

static int deepHashCode(Object[] a) 
根据指定数组的“深度内容”返回哈希码。  

static String deepToString(Object[] a) 
返回指定数组的“深度内容”的字符串表示形式。  

static boolean equals(int[] a, int[] a2) 
如果两个指定的int数组彼此 相等 ，则返回 true 。  

static void fill(int[] a, int val) 
将指定的int值分配给指定的int数组的每个元素。  

static int hashCode(int[] a) 
根据指定数组的内容返回哈希码。  

static void parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op) 
对于数组的给定子范围执行 parallelPrefix(int[], IntBinaryOperator) 。  

static void parallelSetAll(int[] array, IntUnaryOperator generator) 
使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。  

static void parallelSort(int[] a) 
按照数字顺序排列指定的数组。  

static void setAll(int[] array, IntUnaryOperator generator) 
使用提供的生成函数来计算每个元素，设置指定数组的所有元素。  

static void sort(int[] a, int fromIndex, int toIndex) 
按升序排列数组的指定范围。  

static Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive) 
返回Spliterator.OfInt覆盖指定数组的指定范围内。  

static IntStream stream(int[] array) 
返回顺序IntStream与指定的数组作为源。  

static String toString(int[] a) 
返回指定数组的内容的字符串表示形式。  

1.1Arrays常用方法实例

asList

这个方法可以把数组转换成List,List提供了很多的操作方法，更便于使用。

        String[] array = new String[]{"a","c","2","1","b"};
        Integer[] ints = new Integer[]{5,1,4,3,2};
        List<String> lists = Arrays.asList(array);
        List<Integer> lints = Arrays.asList(ints);
        System.out.println(lists);
        System.out.println(lints);

运行结果：

[a, c, 2, 1, b]
[5, 1, 4, 3, 2]

sort排序和parallelSort并行排序

sort比较常用了，根据元素按照自然排序规则排序，也可以设置排序元素的起始位置。

        Arrays.sort(array);
        for(String str : array){
            System.out.print(str);
        }
        Arrays.sort(array,2,5);
        System.out.println(Arrays.deepToString(array));

运行结果：

12abc
[1, 2, a, b, c]

parallelSort则采用并行的排序算法排序.但是我自己测试，可能数据量太小，速度上并没有明显的变化。

binarySearch

查找目标元素所在的位置，注意需要先进行排序。

        //binarySearch需要保证是排好序的
        System.out.println(Arrays.binarySearch(array,"c"));//-6
        Arrays.sort(array);
        System.out.println(Arrays.binarySearch(array,"c"));//4

copyOf

拷贝数组，第一种用法，如果目标长度不够，会使用0进行补位。第二种用法，支持拷贝目标起始位置到结束为止的数组。

       //如果位数不够，需要补位
        Integer[] result = Arrays.copyOf(ints,10);
        for(int i=0;i<result.length;i++){
            System.out.print(result[i]+" ");
        }
        System.out.println();
        //如果位数够，就取最小的数组
        result = Arrays.copyOf(ints,3);
        for(int i : result){
            System.out.print(i+" ");
        }
        System.out.println();
        result = Arrays.copyOfRange(ints,2,4);
        for(int i : result){
            System.out.print(i+" ");
        }

运行结果：

5 1 4 3 2 null null null null null 
5 1 4 
4 3 

deepEquals深度比较、deepHashCode生成hashcode、deepToString深度打印

这几个方法基本都是采用递归的写法使用。

String[] array2 = new String[]{"a","c","2","1","b"};
System.out.println(Arrays.deepEquals(array,array2));//深度比较两个数组是否相同
System.out.println(Arrays.deepHashCode(array));
System.out.println(Arrays.deepHashCode(array2));//如果两个数组deepEquals，那么他们的hashcode一定相同

//格式化输出数组
System.out.println(Arrays.deepToString(array));

运行结果：

true
121209664
121209664
[a, c, 2, 1, b]

equals比较

对比两个数组是否相等。

        String[] array2 = new String[]{"a","c","2","1","b"};

        //1 对比引用是否相同
        //2 对比是否存在null
        //3 对比长度是否相同
        //4 挨个元素对比
        System.out.println(Arrays.equals(array,array2));//true

fill

基于目标元素填充数组

        Arrays.fill(array,"test");
        System.out.println(Arrays.deepToString(array));//[test, test, test, test, test]

toString

打印数组元素

System.out.println(Arrays.toString(array));//[a, c, 2, 1, b]

toStream

把数组转换成stream,然后可以使用java8的stream特性了。

Arrays.stream(array).forEach(s-> System.out.println(s));

parallelPrefix

这个有点像spark的reduceByKey，即根据传入的方法一次计算：

 Arrays.parallelPrefix(ints,(x,y)->(x+y));
 System.out.println(Arrays.deepToString(ints));//[5, 6, 10, 13, 15]

2、Collections类

Collections常用方法概述：
本类所有方法都是静态的，本类方法都是针对集合的操作。

//部分Collections的静态方法（JDK1.8）
static <T> boolean addAll(Collection<? super T> c, T... elements) 
将所有指定的元素添加到指定的集合。  

static <T> Queue<T> asLifoQueue(Deque<T> deque) 
返回Deque作为先进先出（ Lifo ） Queue的视图 。

static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) 
使用二叉搜索算法搜索指定对象的指定列表。  

static <E> Collection<E> checkedCollection(Collection<E> c, 类<E> type) 
返回指定集合的动态类型安全视图。  

static <E> List<E> checkedList(List<E> list, 类<E> type) 
返回指定列表的动态类型安全视图。  

static <K,V> Map<K,V> checkedMap(Map<K,V> m, 类<K> keyType, 类<V> valueType) 
返回指定地图的动态类型安全视图。 

static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K,V> m,
 类<K> keyType, 类<V> valueType) 
返回指定可导航地图的动态类型安全视图。  

static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, 类<E> type) 
返回指定的可导航集的动态类型安全视图。 

static <E> Queue<E> checkedQueue(Queue<E> queue, 类<E> type) 
返回指定队列的动态类型安全视图。  

static <E> Set<E> checkedSet(Set<E> s, 类<E> type) 
返回指定集合的动态类型安全视图。  

static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m, 类<K> keyType, 类<V> valueType) 
返回指定排序映射的动态类型安全视图。 

static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, 类<E> type) 
返回指定排序集的动态类型安全视图。  

static <T> void copy(List<? super T> dest, List<? extends T> src) 
将所有元素从一个列表复制到另一个列表中。  

static boolean disjoint(Collection<?> c1, Collection<?> c2) 
如果两个指定的集合没有共同的元素，则返回 true 。

static <T> Enumeration<T> emptyEnumeration() 
返回没有元素的枚举。  

static <T> Iterator<T> emptyIterator() 
返回没有元素的迭代器。  

static <T> List<T> emptyList() 
返回空列表（immutable）。

static <T> ListIterator<T> emptyListIterator() 
返回没有元素的列表迭代器。  

static <K,V> Map<K,V> emptyMap() 
返回空的地图（不可变）。  

static <K,V> NavigableMap<K,V> emptyNavigableMap() 
返回空导航地图（不可变）。

static <E> NavigableSet<E> emptyNavigableSet() 
返回一个空导航集（immutable）。 

static <T> Set<T> emptySet() 
返回一个空集（immutable）。

static <K,V> SortedMap<K,V> emptySortedMap() 
返回空的排序映射（immutable）。

static <E> SortedSet<E> emptySortedSet() 
返回一个空的排序集（immutable）。 

static <T> Enumeration<T> enumeration(Collection<T> c) 
返回指定集合的枚举。  

static <T> void fill(List<? super T> list, T obj) 
用指定的元素代替指定列表的所有元素。

static int frequency(Collection<?> c, Object o) 
返回指定集合中与指定对象相等的元素数。 

static int indexOfSubList(List<?> source, List<?> target) 
返回指定源列表中指定目标列表的第一次出现的起始位置，如果没有此类事件，则返回-1。 

static int lastIndexOfSubList(List<?> source, List<?> target) 
返回指定源列表中指定目标列表的最后一次出现的起始位置，如果没有此类事件则返回-1。 

static <T> ArrayList<T> list(Enumeration<T> e) 
返回一个数组列表，其中包含由枚举返回的顺序由指定的枚举返回的元素。 

static <T extends Object & Comparable<? super T>>
T max(Collection<? extends T> coll) 
根据其元素的 自然顺序返回给定集合的最大元素。  

static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) 
根据指定的比较器引发的顺序返回给定集合的最大元素。 

static <T extends Object & Comparable<? super T>>
T min(Collection<? extends T> coll) 
根据其元素的 自然顺序返回给定集合的最小元素。  

static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) 
根据指定的比较器引发的顺序返回给定集合的最小元素。  

static <T> List<T> nCopies(int n, T o) 
返回由指定对象的 n副本组成的不可变列表。  

static <E> Set<E> newSetFromMap(Map<E,Boolean> map) 
返回由指定地图支持的集合。  

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 
将列表中一个指定值的所有出现替换为另一个。  

static void reverse(List<?> list) 
反转指定列表中元素的顺序。  

static <T> Comparator<T> reverseOrder() 
返回一个比较器，它对实现 Comparable接口的对象集合施加了 自然排序的相反。  

static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 
返回一个比较器，它强制指定比较器的反向排序。  

static void rotate(List<?> list, int distance) 
将指定列表中的元素旋转指定的距离。  

static void shuffle(List<?> list) 
使用默认的随机源随机排列指定的列表。

static void shuffle(List<?> list, Random rnd) 
使用指定的随机源随机排列指定的列表。  

static <T> Set<T> singleton(T o) 
返回一个只包含指定对象的不可变集。 

static <T> List<T> singletonList(T o) 
返回一个只包含指定对象的不可变列表。 

static <K,V> Map<K,V> singletonMap(K key, V value) 
返回一个不可变的地图，只将指定的键映射到指定的值。 

static <T extends Comparable<? super T>>
void sort(List<T> list) 
根据其元素的natural ordering对指定的列表进行排序。  

static <T> void sort(List<T> list, Comparator<? super T> c) 
根据指定的比较器引起的顺序对指定的列表进行排序。  

static void swap(List<?> list, int i, int j) 
交换指定列表中指定位置的元素。  

static <T> Collection<T> synchronizedCollection(Collection<T> c) 
返回由指定集合支持的同步（线程安全）集合。  

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

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

static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m) 
返回由指定的可导航地图支持的同步（线程安全）可导航地图。 

static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s) 
返回由指定的可导航集支持的同步（线程安全）可导航集。 

static <T> Set<T> synchronizedSet(Set<T> s) 
返回由指定集合支持的同步（线程安全）集。  

static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) 
返回由指定的排序映射支持的同步（线程安全）排序映射。

static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) 
返回由指定的排序集支持的同步（线程安全）排序集。

static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) 
返回指定集合的不可修改视图。  

static <T> List<T> unmodifiableList(List<? extends T> list) 
返回指定列表的不可修改视图。

static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m) 
返回指定地图的不可修改视图。  

static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K,? extends V> m) 
返回指定可导航地图的不可修改视图。

static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s) 
返回指定的可导航集合的不可修改的视图。

static <T> Set<T> unmodifiableSet(Set<? extends T> s) 
返回指定集合的不可修改视图。  

static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m) 
返回指定排序映射的不可修改视图。 

static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) 
返回指定排序集的不可修改视图。 

Collections的常用方法

排序（Sort）

使用sort方法可以根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的

double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.sort(list);
for (int i = 0; i < array.length; i++) {
System.out.println(li.get(i));
}
//结果：112,111,23,456,231

混排（Shuffling）

混排算法所做的正好与 sort 相反： 它打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List，这样的排列具有相同的可能性（假设随机源是公正的）。这个算法在实现一个碰运气的游戏中是非常有用的。例如，它可被用来混排代表一副牌的 Card 对象的一个 List .另外，在生成测试案例时，它也是十分有用的。

Collections.Shuffling(list)
double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.shuffle(list);
for (int i = 0; i < array.length; i++) {
System.out.println(li.get(i));
}
//结果：112,111,23,456,231

反转（Reverse）

使用Reverse方法可以根据元素的自然顺序 对指定列表按降序进行排序。

Collections.reverse(list)
double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections. reverse (list);
for (int i = 0; i < array.length; i++) {
System.out.println(li.get(i));
}
//结果：231,456,23,111,112

替换所有的元素（Fill）

使用指定元素替换指定列表中的所有元素。

String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j
li.add(new String(str[j]));
}
Collections.fill(li,"aaa");
for (int i = 0; i < li.size(); i++) {
System.out.println("list[" + i + "]=" + li.get(i));

}
//结果：aaa,aaa,aaa,aaa,aaa

拷贝（Copy）

用两个参数，一个目标 List 和一个源 List， 将源的元素拷贝到目标，并覆盖它的内容。目标 List 至少与源一样长。如果它更长，则在目标 List 中的剩余元素不受影响。

Collections.copy（list，li）： 后面一个参数是目标列表 ，前一个是源列表
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {1131,333};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j
li.add(new Double(arr[j]));
}
Collections.copy(list,li);
for (int i = 0; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//结果：1131,333,23,456,231

返回Collections中最小元素（min）

根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

Collections.min(list)
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.min(list);
for (int i = 0; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//结果：23

返回Collections中最大元素（max）

根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

Collections.max(list)
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.max(list);
for (int i = 0; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//结果：456

lastIndexOfSubList

返回指定源列表中最后一次出现指定目标列表的起始位置，即按从后到前的顺序返回子List在父List中的索引位置。

int count = Collections.lastIndexOfSubList(list,li);
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {111};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j
li.add(new Double(arr[j]));
}
Int locations = Collections. lastIndexOfSubList (list,li);
System.out.println(“===”+ locations);
//结果 3

IndexOfSubList

返回指定源列表中第一次出现指定目标列表的起始位置

int count = Collections.indexOfSubList(list,li);
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {111};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j
li.add(new Double(arr[j]));
}
Int locations = Collections.indexOfSubList(list,li);
System.out.println(“===”+ locations);
//结果 1

Rotate

根据指定的距离循环移动指定列表中的元素

Collections.rotate（list，-1）；

如果是负数，则正向移动，正数则方向移动
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.rotate(list,-1);
for (int i = 0; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//结果：111,23,456,231,112