Collections类
java.utils.Collections是集合工具类，用来对集合进行操作。
Collections类的常用方法
这里介绍四个常用方法：
addAll(Collection<T> c, T ... elements)
shuffle(List<?> list)
sort(List<r> list)
sort(List<T> list, Comparator<? super T>)
public static <T> boolean adda1l(Collection<T> c, T ... elements)往集合中添加一些元素。 public static void shuff1e(List<?> 1ist)打乱顺序:打乱集合顺序。 public static <T> void sort(List<r> 1ist):将集合中元素按照默认规则排序。 public static <T> void sort(List<T> list, Comparator<? super T>):将集合中元素按照指定规则排序。
addAll(Collection<T> c, T ... elements)方法
参数说明：
Collection<T> c：是要被添加元素的集合
T ... elements：可变参数，是要给集合添加的元素
方法功能：
往集合中添加一些元素
例子：
import java.util.Collections;
import java.util.HashSet; public class DemoCollections {
public static void main(String[] args) {
// 创建一个HashSet集合
HashSet<String> hashSet = new HashSet<>(); // 调用Collections类的静态方法addAll，往集合hashSet中添加多个元素
Collections.addAll(hashSet, "a", "b", "c", "d", "e", "f", "g"); // 输出HashSet集合
System.out.println(hashSet);
}
}
输出结果：
[a, b, c, d, e, f, g]
shuffle(List<?> list)方法
参数说明：
List<?> list：表示传入的集合，即该方法传入的参数是一个集合
方法功能：
打乱集合的顺序。
例子：
import java.util.ArrayList;
import java.util.Collections; public class DemoCollectionsShuffle {
public static void main(String[] args) {
// 创建一个ArrayList集合
ArrayList<String> arrayList = new ArrayList<>(); // 往arrayList集合中添加元素
Collections.addAll(arrayList, "A", "B", "C", "D", "E", "F", "G");
System.out.println("没有打乱时的集合：" + arrayList); // 调用Collections类的静态方法shuffle，将集合arrayList里面的元素顺序打乱
Collections.shuffle(arrayList);
System.out.println("打乱以后的集合：" + arrayList);
}
}
输出结果：
没有打乱时的集合：[A, B, C, D, E, F, G]
打乱以后的集合：[D, B, C, E, A, G, F]
sort(List<r> list)方法
参数说明：
List<?> list：表示传入的集合，即该方法传入的参数是一个集合
方法功能：
对集合进行排序（默认为升序排序）
例子：
import java.util.ArrayList;
import java.util.Collections; public class Demo01CollectionsSort {
public static void main(String[] args) {
// 创建一个ArrayList集合
ArrayList<Integer> arrayList = new ArrayList<>(); // 往arrayList集合中添加元素
Collections.addAll(arrayList, 1, 2, 10, 9, 8);
System.out.println("没有排序时的集合：" + arrayList); // 调用sort()方法，将集合arrayList里面的元素进行排序
Collections.sort(arrayList);
System.out.println("排序后的集合：" + arrayList);
}
}
输出结果：
没有排序时的集合：[1, 2, 10, 9, 8]
排序后的集合：[1, 2, 8, 9, 10]
sort(List<T> list, Comparator<? super T>)方法
首先，说明一下，这个方法仅做了解即可，学习过程中通常都是默认使用sort(List<T> list)方法的。
参数说明：
List<?> list：表示传入的集合，即该方法传入的第一个参数是一个集合
Comparator<? super T>：这是一个排序规则，自定义（覆盖重写该接口的排序方法）
方法功能：
对集合进行排序（默认为升序排序）
例子：
// 随便创建一个Person类
public class Person {
private String name;
private int age; public Person() {
} public Person(String name, int age) {
this.name = name;
this.age = age;
} @Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
}
}
自己定义一个排序规则进行测试：
// 举例
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator; public class Demo02CollectionsSort { public static void main(String[] args) {
// 创建一个ArrayList集合
ArrayList<Person> arrayList = new ArrayList<>(); // 往arrayList集合中添加元素，集合存储的数据的类型是自定义类型(Person)
Collections.addAll(
arrayList,
new Person("LeeHua", 20),
new Person("WanTao", 18),
new Person("XiaMin", 22),
new Person("HonMao", 22)
);
System.out.println("没有排序时的集合：" + arrayList); // 自定义排序规则，对arrayList集合进行排序
Collections.sort(arrayList, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
// 年龄相等，按照名字排序
while (o1.getAge() - o2.getAge() == 0) {
if (o1.getName().length() > o2.getName().length()) {
for (int i = 0; i < o2.getName().length(); i++) {
if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
return o1.getName().charAt(i) - o2.getName().charAt(i);
}
}
return 1;
}
else if (o1.getName().length() < o2.getName().length()) {
for (int i = 0; i < o1.getName().length(); i++) {
if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
return o1.getName().charAt(i) - o2.getName().charAt(i);
}
}
return - 1;
}
else {
for (int i = 0; i < o2.getName().length(); i++) {
if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
return o1.getName().charAt(i) - o2.getName().charAt(i);
}
}
return 0;
}
}
// 年龄不相等，按照年龄排序
return o1.getAge() - o2.getAge();
}
});
System.out.println("排序以后的集合：" + arrayList);
}
}
输出结果：
没有排序时的集合：[Person{name='LeeHua', age=20}, Person{name='WanTao', age=18}, Person{name='XiaMin', age=22}, Person{name='HonMao', age=22}]
排序以后的集合：[Person{name='WanTao', age=18}, Person{name='LeeHua', age=20}, Person{name='HonMao', age=22}, Person{name='XiaMin', age=22}]
排序规则代码的理解：
new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
// 首先判断年龄是否相等
while (o1.getAge() - o2.getAge() == 0) {
// 如果this年龄 == object年龄，那么就按名字的字母(char code)比较
// 按照名字的每个字母来比较
if (o1.getName().length() > o2.getName().length()) {
// o1的名字长度 > o2的名字长度
for (int i = 0; i < o2.getName().length(); i++) {
if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
return o1.getName().charAt(i) - o2.getName().charAt(i);
}
}
// 假如o2的名字的所有字母，按顺序都与o1的名字对应位数的字母相等，字母长度大的排后，即o1排后
return 1;
}
// o1的名字长度 < o2的名字长度
else if (o1.getName().length() < o2.getName().length()) {
for (int i = 0; i < o1.getName().length(); i++) {
if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
return o1.getName().charAt(i) - o2.getName().charAt(i);
}
}
// 假如o1的名字的所有字母，按顺序都与o2的名字对应位数的字母相等，字母长度大的排后，即o2排后
return - 1;
}
// o1的名字长度 = o2的名字长度
else {
for (int i = 0; i < o2.getName().length(); i++) {
if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
return o1.getName().charAt(i) - o2.getName().charAt(i);
}
}
// 假如o1的名字的所有字母，按顺序都与o2的名字对应位数的字母相等，那么按照arrayList集合的添加顺序排序
return 0;
}
}
// 年龄不相等，按照年龄排序
return o1.getAge() - o2.getAge();
}
}