【Java基础进阶笔记】- Day03 - 第五章 Collections
Java基础进阶笔记 - Day03 - 第五章 Collections
- Java基础进阶笔记 - Day03 - 第五章 Collections
-
- 5.1 常用功能
- 5.2 Comparator比较器
- 5.3 简述Comparable和Comparator两个接口的区别
- 5.4 练习
- 5.5 拓展
Java基础进阶笔记 - Day03 - 第五章 Collections
系统：Win10
JDK：1.8.0_121
IDE：IntelliJ IDEA 2017.3.7
5.1 常用功能
java.utils.Collections是集合工具类，用来对集合进行操作。常用方法如下：
- public static boolean addAll(Collection c, T…elements)：往集合中添加一些元素
- public static void shuffle(List list)：打乱集合顺序
- public static void sort(List list)：将集合元素按默认规则排序
- public static void sort(List list, Comparator)：将集合元素按指定规则排序
代码演示：
public class CollectionsDemo01 {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
ArrayList<String> list2 = new ArrayList<>();
// 原来的添加
list1.add("a");
list1.add("b");
list1.add("c");
list1.add("d");
list1.add("e");
System.out.println(list1);
// public static boolean addAll(Collection c, T...elements)：往集合中添加一些元素
Collections.addAll(list2, "a", "b", "c", "d", "e");
System.out.println("addAll添加元素：" + list2);
// public static void shuffle(List list)：打乱集合顺序
Collections.shuffle(list2);
System.out.println("shuffle打乱集合顺序：" + list2);
// public static void sort(List list)：将集合元素按默认规则排序
Collections.sort(list2);
System.out.println("sort排序后的集合：" + list2);
}
}
运行结果：
我们这里采用排序后可以发现，元素按照String的默认顺序排序（升序）了，如果说我们想倒序或者按别的排序方式进行排序该怎么办呢？
我们可以看到常用方法里还有一个：public static
5.2 Comparator比较器
我们在使用 public static void sort(List list) 这个方法排序String类型的时候，它的默认排序方式为什么是升序，这个默认规则是怎么定义出来的？
说到排序，简单的来说就是两个对象之间比较大小，那么在Java中提供了两种比较实现的方式，一种是采用 java.lang.Comparable 接口去实现，另一种是选择 java.util.Comparator 接口完成
我们采用的 public static void sort(List list) 这个方法完成的排序，其实要求了被排序的类型需要实现Comparable接口完成比较功能，在String类中的定义：
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
// 实现Comparable接口的compareTo方法
public int compareTo(String anotherString) {
int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
return len1 - len2;
}
}
String类实现了这个接口，并完成了比较规则的定义，但是这样就把这种规则写死了，那当我们想要字符串按照第一个字符降序排列，那么就要修改String的源代码，这是不可能的，那么这个时候我们就可以使用 public static void sort(List list, Comparator) 方法灵活实现了，这里就涉及到Comparator这个接口，位于java.util包下，排序是Comparator能实现的功能之一，该接口代表一个比较器，比较器具有可比性！顾名思义就是做排序的，确定两个对象谁排在前面，谁排在后面，比较的方法是：
- public int compare(String o1, String o2)：比较两个参数的顺序
两个对象的比较的结果有三种：大于、等于、小于
如果按照升序排序，则o1小于o2，返回（负数），相等返回0，o1大于o2返回（正数），如果要按照降序排序，则o1小于o2，返回（正数），相等返回0，o1大于o2返回（负数）
测试如下：
public class CollectionsDemo02 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
// 往集合中添加一些元素
Collections.addAll(list, "a", "b", "c", "d", "e", "f", "g");
// 【前面的减后面的】代表升序，【后面的减前面】的代表降序
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.charAt(0) - o2.charAt(0);
}
});
System.out.println("升序排序：" + list);
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.charAt(0) - o1.charAt(0);
}
});
System.out.println("降序排序：" + list);
}
}
运行结果：
5.3 简述Comparable和Comparator两个接口的区别
Comparable：强行对实现它的每个类的对象进行整体排序，这种排序被称为类的自然排序，类的compareTo方法被称为的它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（Array.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器
Comparator：强行对某个对象进行整体排序，可以将Comparator传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精准控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象Collection提供排序
5.4 练习
创建一个Person类，存储到ArrayList集合中，然后按年龄进行排序操作
Person初始类：
public class Person implements Comparable<Person> {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.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;
}
// 用于等会直接打印Person对象
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
// 实现比较方法，不然不能直接使用sort(List list)方法
@Override
public int compareTo(Person o) {
return this.getAge() - o.getAge(); // 升序
}
}
测试类：
public class CollectionsDemo03 {
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<>();
list.add(new Person("张三", 18));
list.add(new Person("李四", 19));
list.add(new Person("王二", 17));
list.add(new Person("麻子", 20));
// 按年龄进行升序排序
Collections.sort(list); // 要求该集合中元素类型类：必须实现比较器Comparable接口
// 增强for输出集合
for (Person person : list) {
System.out.println(person);
}
}
}
运行结果：
5.5 拓展
如果在排序的时候，想要独立的定义规则去使用，可使用 sort(List list, Comparator) 方法自定义排序规则
创建一个学生类，存储到ArrayList集合中完成指定排序操作，排序规则：
- 先按姓名升序
- 再按姓名长度升序（ab 排在 abc 前面）
- 最后按年龄升序
Student初始类：
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.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;
}
// 重写toString 方法，便于直接打印比较
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
测试类：
public class CollectionsDemo03 {
public static void main(String[] args) {
// 创建集合并添加数据
ArrayList<Student> list = new ArrayList<>();
list.add(new Student("ZhangSan", 18));
list.add(new Student("LiSi", 19));
list.add(new Student("ZhangSa", 20));
list.add(new Student("WangEr", 20));
list.add(new Student("ZhangSang", 19));
list.add(new Student("LiSi", 17));
// 按指定规则排序：按姓名升序，姓名长度升序，年龄升序
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
String name1 = o1.getName();
String name2 = o2.getName();
int length1 = o1.getName().length();
int length2 = o2.getName().length();
// 3.姓名相同，按年龄升序
if (o1.getName().equals(o2.getName())) {
return o1.getAge() - o2.getAge();
} else {
int minLength = length1 < length2 ? length1 : length2;
for (int i = 0; i < minLength;i++){
if (name1.charAt(i) != name2.charAt(i)) {
// 1.按姓名升序
return name1.charAt(i) - name2.charAt(i);
}
}
// 2.按姓名长度升序
return length1 - length2;
}
}
});
for (Student student : list) {
System.out.println(student);
}
}
}
运行结果：
