java.utils.Collections 是集合工具类,用来对集合进行操作。
常用方法:
public static <T> boolean addAll(Collection<T> c, T... elements) 往集合中添加一些元素
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,23,1421,1412,412,547);
System.out.println(list); //输出:[23,1421,1412,412,547]
public static void shuffle(List<?> list) 打乱集合元素顺序
ArrayList<Integer> list = new ArrayList<>();
ArrayList<Integer> list1 = new ArrayList<>();
Collections.addAll(list,23,1421,1412,412,547);
Collections.shuffle(list);
System.out.println(list); //输出:[1412, 23, 1421, 412, 547]
注意:Collections.shuffle()方法每次输出的结果都是不一样的
public static <T> void sort(List<T> list) 将集合中元素按照默认规则排序。
ArrayList<Integer> list = new ArrayList<>();
ArrayList<Integer> list1 = new ArrayList<>();
Collections.addAll(list,23,1421,1412,412,547);
Collections.sort(list);
System.out.println(list); //输出:[23, 412, 547, 1412, 1421]
注意:其他数据类型使用Collections.sort()方法时,java内部有对各种数据类型进行排序(Integer是按升序进行排序)
Comparator自定义比较器:
public static <T> void sort(List<T> list,Comparator<? super T> c) 使用自定义比较器对集合中元素进行排序
1.新建一个自定义的类实现Comparator<T>,且重写Comparator<T> 的抽象方法public int compare(T o1,T o2)
public class MyComparator implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1; //return 的值可以根据自己需求随意修改
}
}
2.调用Collections.sort(List<T> list,Comparator<? super T> c) .方法!
<? super T> 表示的是只能接受此类和他的父类类型的数据
第一个参数List<T> list :传入要自定义排序的集合名
第二个参数Comparator<? super T> c :传入刚刚创建好的自定义类对象,注意是对象!
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,23,1421,1412,412,547);
Collections.sort(list, new MyComparator()); //传入匿名对象new MyComparator()
System.out.println(list); //输出:[1421, 1412, 547, 412, 23]
这样就完成了Integer集合的降序排序
比较器根据return后面两个参数相减的正负值来判断前后数值大小,然后判断是否更换位置
所以我们可以改变return后面两个参数的位置来实现升序或者降序排序
同样该方法也可以用来完成字符串长度排序等等
Camparable自定义比较器:
public static <T> void sort(List<T> list,Comparator<? super T> c) 使用自定义比较器对集合中元素进行排序
1.创建一个自定义类实现Comparable<T>,并且重写compareTo()方法
返回值写的就是根据自定义类的成员变量顺序进行排序的依据
两个元素之间是否更换位置根据return返回数值的正负
public class Student implements Comparable<Student>{
private String name;
private int age;
@Override
public int compareTo(Student o) { //重写的compareTo()方法
return this.age - o.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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
2.主方法中,使用public static <T> void sort(List<T> list)
将存有自定义对象的List集合当作参数传入方法体
输出便是按照成员变量age作的排序
Student s1 = new Student("1号学生", 22);
Student s2 = new Student("2号学生", 33);
Student s3 = new Student("3号学生", 18);
Student s4 = new Student("4号学生", 15);
Student s5 = new Student("5号学生", 26);
ArrayList<Student> list = new ArrayList<>();
Collections.addAll(list,s1,s2,s3,s4,s5);
Collections.sort(list); //使用Collections.sort()对自定义对象进行排序
System.out.println(list);
//最后输出:
//[Student{name='4号学生', age=15},
//Student{name='3号学生', age=18},
//Student{name='1号学生', age=22},
//Student{name='5号学生', age=26},
//Student{name='2号学生', age=33}]
注意:
实现Comparable<T>接口的自定义比较器方法,只能用来比较自定义数据类型
基本数据类型的包装类要用这种方法作比较的话
必须到官方定义好的源码中实现Comparable<T>接口,和重写compareTo()方法
这样做显然不可取
对基本数据类型的包装类进行排序时候只能自定义比较器实现Comparator<T>
比较自定义对象时不仅可以使用Comparator<T>方法 也可以使用Comparable<T>方法