2021-01-23

Arrays:数组的工具类，提供了对数组操作的工具方法。

Collections：是COllection集合对象的工具类，提供了操作集合对象的工具方法。

其中Arrays和Collections中所有的方法都是静态的，不需要创建对象，直接使用类名调用。

Collections的常用方法：

1.  void sort(List<T> list)（无比较类参数）：

方法源代码：

public static <T extends Comparable<? super T>> void sort(List<T> list) {
    list.sort(null);
}


当list集合中存放的是基本数据类型时，该方法根据list中的元素的自然顺序将list列表按升序排序。这个排序是稳定的：即相等的元素不会由于排序而重新排序。指定的列表必须是可修改的，但不必调整大小。

示例代码：

ArrayList<Double> arrayList  = new ArrayList<Double>(){};
arrayList.add(0.1);
arrayList.add(3.1);
arrayList.add(2.1);

Collections.sort(arrayList);
for ( Double i : arrayList){
    System.out.println(i);
}

当list集合中存放的是对象时，需要根据对象的某个或某些值排序时，要在所有对象的类中实现Comparable< >接口，重写接口中的compareTo()方法。此外，列表中的所有元素都必须相互可比（即，e1.compareTo（e2）不得为列表中的任何元素e1和e2抛出ClassCastException，即两个类型间转换不兼容引发的异常）。如果不重写compareTo（）方法去调用sort方法，对象不会进行排序。

Collections.sort()源码方法中只调用了List接口中的sort方法，找到这个方法源码：

default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    Arrays.sort(a, (Comparator) c);
    ListIterator<E> i = this.listIterator();
    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}

该方法的参数应该是一个比较器类的对象，可以根据自己的需求在比较器类里写自己的排序算法。Collections.sort()方法中调用List.sort方法给这个参数设置了null。

Object[] a = this.toArray(); ： 先把list中的值传给一个Object类型的数组a。

Arrays.sort(a, (Comparator) c);  ： 调用Arrays的sort方法对数组a按照比较器类里的排序算法进行排序，这里比较器类的对象设置了null，所以默认按照自然顺序升序排序.

ListIterator<E> i = this.listIterator(); : 创建一个List迭代器。

for (Object e : a) { i.next();

        i.set((E) e); }：通过for循环将已排好序数组a中的值传给list。

void sort(List<T> list, Comparator<? super T> c)（有比较类参数）

方法源代码：

public static <T> void sort(List<T> list, Comparator<? super T> c) {
    list.sort(c);
}

根据该方法源码的参考文档来看，根据指定的比较器c中的排序方法对该列表进行排序。使用指定的比较器，此列表中的所有元素必须可以相互比较（即，c.compare（e1，e2）不得为列表中的任何元素e1和e2抛出ClassCastException。如果指定的比较器为null，则此列表中的所有元素都必须实现Comparable接口，并且应使用元素的自然顺序排序。

而定义一个比较器类需要实现Comparator接口，重写接口中的compare方法。

2.min（）方法

public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)

方法源代码：

public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) {
    Iterator<? extends T> i = coll.iterator();
    T candidate = i.next();

    while (i.hasNext()) {
        T next = i.next();
        if (next.compareTo(candidate) < 0)
            candidate = next;
    }
    return candidate;
}

该方法根据其元素的自然顺序返回给定集合的最小元素。 集合中的所有元素必须实现Comparable接口。 此外，集合中的所有元素必须相互可比较。

3.max（）方法

方法源代码：

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) {
    Iterator<? extends T> i = coll.iterator();
    T candidate = i.next();

    while (i.hasNext()) {
        T next = i.next();
        if (next.compareTo(candidate) > 0)
            candidate = next;
    }
    return candidate;
}

该方法根据其元素的自然顺序返回给定集合的最大元素。 集合中的所有元素必须实现Comparable接口。 此外，集合中的所有元素必须相互可比较。

4.binarySearch（）方法

public static <T>  int binarySearch(List<? extends Comparable<? super T>> list, T key)

使用二分查找算法在指定列表中搜索指定对象。 在使用此方法之前，必须根据列表元素的自然顺序将其按升序排序， 如果未排序，则结果不确定。 如果列表有多个和指定对象相同的值，则不能保证将找到哪个元素。

5.reverse（）方法

public static void reverse(List<?> list) 

反转指定列表中元素的顺序。

6.shuffle（）方法

public static void shuffle(List<?> list)

随机排序列表中的元素。

7.swap（）方法

public static void swap(List<?> list, int i, int j) {
    final List l = list;
    l.set(i, l.set(j, l.get(i)));
}

在指定列表中的指定位置交换元素，如果指定的位置相等，则调用此方法将使列表保持不变。

8.fill（）方法

public static <T> void fill(List<? super T> list, T obj)

将指定列表的所有元素替换为指定元素。

9.copy（）方法

public static <T> void copy(List<? super T> dest, List<? extends T> src)

将所有元素从src列表复制到dest列表中。 操作后，dest列表中每个复制元素的索引将与src列表中其索引相同。 dest列表必须至少与src列表一样长。 如果更长，则dest列表中的其余元素不受影响。

10.roteta（）方法

public static void rotate(List<?> list, int distance)

将指定列表中的元素旋转指定距离。distance为正值，元素向前旋转，distance为负值向后旋转。

例如，假设列表包括[t，a，n，k，s]。 调用Collections.rotate（list，1）（或Collections.rotate（list，-4））后，列表将包含[s，t，a，n，k]。

11.replaceAll（）方法

public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)

将列表中所有出现的一个指定值oldVal替换为newVal。

Arrays的常用方法：

1.sort（）方法

public static void sort(int[] a) 

将指定的数组按升序排序。

public static void sort(int[] a, int fromIndex, int toIndex)

将指定范围的数组按升序排序。，范围从fromIndex到同Index。

2.binarySearch（）方法

public static int binarySearch(int[] a, int key)

使用二分搜索算法在指定的int数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序。 如果未排序，则结果不确定。 如果数组包含具有指定值的多个元素，则不能保证将找到哪个元素。

3.equals（）方法

public static boolean equals(int[] a, int[] a2)

如果两个指定的int数组彼此相等，则返回true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对均相等，则认为两个数组相等。 另外，如果两个数组引用均为空，则它们被视为相等。

4.fill（）方法

public static void fill(int[] a, int val)

将指定的int值val分配给指定的int数组的每个元素。

5.copyOf（）方法

public static int[] copyOf(int[] original, int newLength)

将数组从头到newlength的部分复制给新数组，如果newlength大于原数组的长度，则多出来的部分在新数组中用0填充

6.asList（）方法

public static <T> List<T> asList(T... a)

将数组转为ArrayList集合。