Collections常用方法

Collections

• public class Collections
  extends Object

  此类仅由静态方法组合或返回集合。它包含对集合进行操作的多态算法，“包装器”，返回由指定集合支持的新集合，以及其他一些可能的和最终的。

  如果提供给它们的集合或类对象为null，则此类的方法都抛出一个NullPointerException 。

  该类中包含的多态算法的文档通常包括实现的简要说明 。 这些描述应被视为实施说明 ，而不是说明书的一部分 。 只要规范本身得到遵守，实现者就可以随意替代其他算法。 （例如，sort使用的算法不一定是一个mergeesort，但它必须是稳定的 。）

  如果集合不支持适当的突变原语，例如set方法，则该类中包含的“破坏性”算法，即修改其操作的集合的算法被指定为抛出UnsupportedOperationException 。 如果调用对集合没有影响，这些算法可能但不是必须抛出此异常。 例如，在已经排序的不可修改列表上调用sort方法可以抛出UnsupportedOperationException 。

  常用方法已标黑：

  • • static boolean	addAll(Collection c, T... elements) 将所有指定的元素添加到指定的集合。
      static Queue	asLifoQueue(Deque deque) 返回Deque作为先进先出（ Lifo ） Queue的视图 。
      static int	binarySearch(List> list, T key) 使用二叉搜索算法搜索指定对象的指定列表。
      static int	binarySearch(List list, T key, Comparator c) 使用二叉搜索算法搜索指定对象的指定列表。
      static Collection	checkedCollection(Collection c, 类 type) 返回指定集合的动态类型安全视图。
      static List	checkedList(List list, 类 type) 返回指定列表的动态类型安全视图。
      static Map	checkedMap(Map m, 类 keyType, 类 valueType) 返回指定地图的动态类型安全视图。
      static NavigableMap	checkedNavigableMap(NavigableMap m, 类 keyType, 类 valueType) 返回指定可导航地图的动态类型安全视图。
      static NavigableSet	checkedNavigableSet(NavigableSet s, 类 type) 返回指定的可导航集的动态类型安全视图。
      static Queue	checkedQueue(Queue queue, 类 type) 返回指定队列的动态类型安全视图。
      static Set	checkedSet(Set s, 类 type) 返回指定集合的动态类型安全视图。
      static SortedMap	checkedSortedMap(SortedMap m, 类 keyType, 类 valueType) 返回指定排序映射的动态类型安全视图。
      static SortedSet	checkedSortedSet(SortedSet s, 类 type) 返回指定排序集的动态类型安全视图。
      static void	copy(List dest, List src) 将所有元素从一个列表复制到另一个列表中。
      static boolean	disjoint(Collection c1, Collection c2) 如果两个指定的集合没有共同的元素，则返回 true 。
      static Enumeration	emptyEnumeration() 返回没有元素的枚举。
      static Iterator	emptyIterator() 返回没有元素的迭代器。
      static List	emptyList() 返回空列表（immutable）。
      static ListIterator	emptyListIterator() 返回没有元素的列表迭代器。
      static Map	emptyMap() 返回空的地图（不可变）。
      static NavigableMap	emptyNavigableMap() 返回空导航地图（不可变）。
      static NavigableSet	emptyNavigableSet() 返回一个空导航集（immutable）。
      static Set	emptySet() 返回一个空集（immutable）。
      static SortedMap	emptySortedMap() 返回空的排序映射（immutable）。
      static SortedSet	emptySortedSet() 返回一个空的排序集（immutable）。
      static Enumeration	enumeration(Collection c) 返回指定集合的枚举。
      static void	fill(List 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 ArrayList	list(Enumeration e) 返回一个数组列表，其中包含由枚举返回的顺序由指定的枚举返回的元素。
      static >T	max(Collection coll) 根据其元素的 自然顺序返回给定集合的最大元素。
      static T	max(Collection coll, Comparator comp) 根据指定的比较器引发的顺序返回给定集合的最大元素。
      static >T	min(Collection coll) 根据其元素的 自然顺序返回给定集合的最小元素。
      static T	min(Collection coll, Comparator comp) 根据指定的比较器引发的顺序返回给定集合的最小元素。
      static List	nCopies(int n, T o) 返回由指定对象的 n副本组成的不可变列表。
      static Set	newSetFromMap(Map map) 返回由指定地图支持的集合。
      static boolean	replaceAll(List list, T oldVal, T newVal) 将列表中一个指定值的所有出现替换为另一个。
      static void	reverse(List list) 反转指定列表中元素的顺序。
      static Comparator	reverseOrder() 返回一个比较器，它对实现 Comparable接口的对象集合施加了 自然排序的相反。
      static Comparator	reverseOrder(Comparator cmp) 返回一个比较器，它强制指定比较器的反向排序。
      static void	rotate(List list, int distance) 将指定列表中的元素旋转指定的距离。
      static void	shuffle(List list) 使用默认的随机源随机排列指定的列表。
      static void	shuffle(List list, Random rnd) 使用指定的随机源随机排列指定的列表。
      static Set	singleton(T o) 返回一个只包含指定对象的不可变集。
      static List	singletonList(T o) 返回一个只包含指定对象的不可变列表。
      static Map	singletonMap(K key, V value) 返回一个不可变的地图，只将指定的键映射到指定的值。
      static >void	sort(List list) 根据其元素的natural ordering对指定的列表进行排序。
      static void	sort(List list, Comparator c) 根据指定的比较器引起的顺序对指定的列表进行排序。
      static void	swap(List list, int i, int j) 交换指定列表中指定位置的元素。
      static Collection	synchronizedCollection(Collection c) 返回由指定集合支持的同步（线程安全）集合。
      static List	synchronizedList(List list) 返回由指定列表支持的同步（线程安全）列表。
      static Map	synchronizedMap(Map m) 返回由指定地图支持的同步（线程安全）映射。
      static NavigableMap	synchronizedNavigableMap(NavigableMap m) 返回由指定的可导航地图支持的同步（线程安全）可导航地图。
      static NavigableSet	synchronizedNavigableSet(NavigableSet s) 返回由指定的可导航集支持的同步（线程安全）可导航集。
      static Set	synchronizedSet(Set s) 返回由指定集合支持的同步（线程安全）集。
      static SortedMap	synchronizedSortedMap(SortedMap m) 返回由指定的排序映射支持的同步（线程安全）排序映射。
      static SortedSet	synchronizedSortedSet(SortedSet s) 返回由指定的排序集支持的同步（线程安全）排序集。
      static Collection	unmodifiableCollection(Collection c) 返回指定集合的不可修改视图。
      static List	unmodifiableList(List list) 返回指定列表的不可修改视图。
      static Map	unmodifiableMap(Map m) 返回指定地图的不可修改视图。
      static NavigableMap	unmodifiableNavigableMap(NavigableMap m) 返回指定可导航地图的不可修改视图。
      static NavigableSet	unmodifiableNavigableSet(NavigableSet s) 返回指定的可导航集合的不可修改的视图。
      static Set	unmodifiableSet(Set s) 返回指定集合的不可修改视图。
      static SortedMap	unmodifiableSortedMap(SortedMap m) 返回指定排序映射的不可修改视图。
      static SortedSet	unmodifiableSortedSet(SortedSet s) 返回指定排序集的不可修改视图。

sort(List list)

注意：sort(List list) 根据其元素的natural ordering对指定的列表进行排序。

使用前提，被排序的集合里存储的元素，必须实现Comparable,重写接口中的compareTo方法定义的定义规则。

/**
 * @program: intellij idea
 * @description:Comparable接口的排序规则：
 * 自己（this）— 参数：升序
 * @author: lixy
 * @create: 2020-05-03 22:51
 **/
public class Student implements Comparable<Student>{
    private String name;
    private Integer age;
​
    public Student() {
    }
​
    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public Integer getAge() {
        return age;
    }
​
    public void setAge(Integer age) {
        this.age = age;
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Student student = (Student) o;
        return Objects.equals(name, student.name) &&
                Objects.equals(age, student.age);
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
    //重写排序的规则
    @Override
    public int compareTo(Student o) {
        //比较两个人的年龄
        return this.getAge() - o.getAge();//升序
    }
}

ArrayList<Student> arrayList = new ArrayList<>();
Student lili = new Student("lili", 18);
Student bibi = new Student("bibi", 19);
Student caca = new Student("caca", 17);
Collections.addAll(arrayList,lili,bibi,caca);
System.out.println(arrayList);//结果：[Student{name='lili', age=18}, Student{name='bibi', age=19}, Student{name='caca', age=17}]
Collections.sort(arrayList);
System.out.println(arrayList);//结果：[Student{name='caca', age=17}, Student{name='lili', age=18}, Student{name='bibi', age=19}]

sort(List list, Comparator c)

ArrayList<Person> personArrayList = new ArrayList<>();
Person huhu = new Person("huhu", 23);
Person popo = new Person("popo", 20);
Person ruru = new Person("ruru", 26);
Collections.addAll(personArrayList,huhu,popo,ruru);
Collections.sort(personArrayList, new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getAge()-o2.getAge();
    }
});
System.out.println(personArrayList);//结果：[Person{name='popo', age=20}, Person{name='huhu', age=23}, Person{name='ruru', age=26}]