Collections常用方法

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)返回作为先进先出（）。

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)根据指定的⽐较器引发的顺序返回给定集合的最⼤元素。

min(Collection coll)根据其元素的⾃然顺序返回给定集合的最⼩元素。

static >T min(Collection coll)根据其元素的⾃然顺序返回给定集合的最⼩元素。

static boolean addAll(Collection c, T... elements)将所有指定的元素添加到指定的集合。

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
返回⼀个⽐较器，它对实现Comparable接⼝的对象集合施加了⾃然排序的相反。

Comparator reverseOrder()
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)根据其元素的对指定的列表进⾏排序。

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)根据其元素的对指定的列表进⾏排序。

使⽤前提，被排序的集合⾥存储的元素，必须实现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) {
= name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String 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, ) &&
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}]。