java.util.Collections是集合工具类,用来对集合进行操作
部分方法如下:
public static boolean addAll(Collection,T…elements); //往集合中添加一些元素
public static void shuffle(List<?> list) //打乱集合顺序
public static void sort(List list); //将集合中元素按照默认规则排序(默认是升序)
public static void sort(List List,Comparator<? super T>) //将集合中元素按照指定规则排序
1.addAll方法和shuffle方法
public static boolean addAll(Collection,T…elements); //往集合中添加一些元素
public static void shuffle(List<?> list) //打乱集合顺序
public class Demo01Collections {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
// list.add("a");
// list.add("b");
// list.add("c");
// list.add("d");
// list.add("e");
//public static <T> boolean addAll(Collection<T>,T...elements); //往集合中添加一些元素
Collections.addAll(list,"a","b","c","d","e");
System.out.println(list);
//public static void shuffle(List<?> list) //打乱集合顺序
Collections.shuffle(list);
System.out.println(list);
}
}
2.sort(List<T> list)方法
public static void sort(List list); //将集合中元素按照默认规则排序(默认是升序)
注意事项:
sort方法使用前提:
被排序的集合里边存储的元素,
必须实现Comparable接口,
重写接口中的方法CompareTo定义排序的规则
Comparable接口的排序规则:
自己(this) - 参数 ; 升序
参数 - 自己(this) ; 降序
Person.java
package demo15.Collections;
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;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//重写排序的规则
@Override
public int compareTo(Person o) {
//return 0;//认为元素时相同的
//自定义比较的规则,比较两个人的年龄(this,参数Person)
return this.getAge() - o.getAge(); //年龄升序排序
}
}
Demo
public class Demo02Collections {
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<>();
list01.add(1);
list01.add(3);
list01.add(2);
System.out.println(list01);
//public static <T> void sort(List<T> list); //将集合中元素按照默认规则排序
Collections.sort(list01);
System.out.println(list01);//默认是升序
//自定义类型的排序,需要重写Compare
ArrayList<Person> list02 = new ArrayList<>();
list02.add(new Person("Clearlove",18));
list02.add(new Person("Uzi",17));
list02.add(new Person("Meiko",19));
System.out.println(list02);
Collections.sort(list02);
System.out.println(list02);
}
}
可以看到,Person类实现了Comparable接口并重写了CompareTo方法!
只有这样,自定义类型的集合才能使用sort方法!
运行结果:
成功将Person对象按照年龄升序排序
3.sort(List<T> List,Comparator<? super T>)方法
public static void sort(List List,Comparator<? super T>) //将集合中元素按照指定规则排序
Comparator 和 Comparable的区别
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则CompareTo方法
Comparator:相当于找一个第三方的裁判,比较两个
Comparator的排序规则:
o1-o2; 升序
o2-o1; 降序
Student.java
package demo15.Collections;
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;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
Demo
public class Demo03Collections {
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<>();
list01.add(1);
list01.add(3);
list01.add(2);
System.out.println(list01);
Collections.sort(list01, new Comparator<Integer>(){
//重写比较的规则
@Override
public int compare(Integer o1,Integer o2) {
return o1-o2; //升序
}
});
System.out.println(list01);
//自定义类型排序
ArrayList<Student> list02 = new ArrayList<>();
list02.add(new Student("Faker",18));
list02.add(new Student("Clearlove",18));
list02.add(new Student("Uzi",17));
list02.add(new Student("Meiko",19));
System.out.println(list02);
Collections.sort(list02,new Comparator<Student>(){
//重写排序的规则
@Override
public int compare(Student o1,Student o2){
return o1.getAge() - o2.getAge();
}
});
System.out.println(list02);
Collections.sort(list02,new Comparator<Student>(){
//重写排序的规则
@Override
public int compare(Student o1,Student o2){
int result = o1.getAge() - o2.getAge();//升序
//如果两人年龄相同,则按照姓名首字母排序
if(result == 0){
result = o1.getName().charAt(0) - o2.getName().charAt(0);
}
return result;
}
});
System.out.println(list02);
}
}
这个sort方法需要传递两个参数,一个是需要排序的集合,另一个是Comparator对象,通过重写Comparator类的compare方法,来定义不同的比较规则。
我们可以看到,代码中为了实现Student对象的排序,先后使用匿名类和匿名对象重写了两次compare方法,
第一次重写,规则是:只按照年龄的大小升序排序!
第二次重写,规则是:按照年龄的大小升序排序,如果其中两者的年龄相等,则按照两者的姓名首字母大小排序!
运行结果: