java 排序

java 排序

1：简单排序 直接调用sort方法

Integer[] arry={6,5,2,3,4,1};
List<Integer> list=Arrays.asList(arry);
System.out.println("排序前"+list);
//第一种排序方法  默认升序
Collections.sort(list);
System.out.println("第一种升序排序："+list);
Collections.sort(list, Collections.reverseOrder());
System.out.println("第一种降序排序："+list);

执行结果：

排序前[6, 5, 2, 3, 4, 1]
第一种升序排序：[1, 2, 3, 4, 5, 6]
第一种降序排序：[6, 5, 4, 3, 2, 1]

2：list.sort排序

Integer[] arry={6,5,2,3,4,1};
List<Integer> list=Arrays.asList(arry);
System.out.println("排序前"+list);
list.sort(Integer::compare);
System.out.println("升序排序后"+list);
//lambda表达式写法
list.sort((a,b)-> a>b?-1:1);
//上面的lambda表达式等同于下面的写法
//	    list.sort(new Comparator<Integer>() {
//			@Override
//			public int compare(Integer o1, Integer o2) {
//				return o1>o2?-1:1;
//			}
//		});
System.out.println("降序排序后"+list);

执行结果：

排序前[6, 5, 2, 3, 4, 1]
升序排序后[1, 2, 3, 4, 5, 6]
降序排序后[6, 5, 4, 3, 2, 1]

3：对数组[ ]进行排序

Integer[] arry={6,5,2,3,4,1};
List<Integer> list=Arrays.asList(arry);
System.out.println("排序前"+list);
Arrays.sort(arry);
System.out.println("升序排序"+Arrays.asList(arry));
//Integer也可是其他的任意对象，比如对Person对象中的age字段排序
Arrays.sort(arry,(a,b)-> a>b?-1:1);
System.out.println("降序排序"+Arrays.asList(arry));

执行结果：

排序前[6, 5, 2, 3, 4, 1]
升序排序[1, 2, 3, 4, 5, 6]
降序排序[6, 5, 4, 3, 2, 1]

4：compare排序

Integer[] arry={6,5,2,3,4,1};
List<Integer> list=Arrays.asList(arry);
System.out.println("排序前"+list);
//普通写法  o1-o2为升序，o2-o1为降序
Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1-o2;
    }
});
System.out.println("升序排序："+list);
//lambda表达式写法
Collections.sort(list,(o1,o2)-> o2-o1);
System.out.println("降序排序："+list);

执行结果：

排序前[6, 5, 2, 3, 4, 1]
升序排序：[1, 2, 3, 4, 5, 6]
降序排序：[6, 5, 4, 3, 2, 1]

5：对 对象进行排序

public class test {
    public static void main(String[] args) {
        List<Student> list=new ArrayList<>();
        list.add(new Student(4,"张三"));
        list.add(new Student(1,"tom"));
        list.add(new Student(3,"tony"));
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        System.out.println("对象升序排序："+list);
        Collections.sort(list,((o1, o2) -> o2.getAge()-o1.getAge()));
        System.out.println("对象降序排序："+list);
//另一种写法
list.sort(Comparator.comparing(Student::getAge));
     System.out.println("升序："+list);
     list.sort(Comparator.comparing(Student::getAge).reversed());
     System.out.println("降序："+list);
    }
}
class Student{
    String name;
    int age;
    Student(int age,String name){
        this.age=age;
        this.name=name;
    }
    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 +
                '}';
    }
}

运行结果：

对象升序排序：[Student{name='tom', age=1}, Student{name='tony', age=3}, Student{name='张三', age=4}]
对象降序排序：[Student{name='张三', age=4}, Student{name='tony', age=3}, Student{name='tom', age=1}]

6：对对象进行排序

public class test {
    public static void main(String[] args) {
        List<Person> ps=new ArrayList<>();
        ps.add(new Person(11,"tom"));
        ps.add(new Person(11,"张三"));
        ps.add(new Person(12,"tom"));
        ps.add(new Person(11,"tom"));

        // 按照年龄从高到低排序
        // 方式一
        ps.sort((o1, o2)
                -> o1.getAge() == null ? 1 : (o2.getAge() == null ? -1 : o2.getAge().compareTo(o1.getAge())));
        System.out.println(ps);
        // 方式二
        ps.sort(Comparator.comparing(Person::getAge, (o1, o2)
                -> o1 == null ? 1 : (o2 == null ? -1 : o2.compareTo(o1))));
        System.out.println(ps);
        // 方式三 (age 字段不能为 null， null 会导致排序失败)
        ps.sort(Comparator.comparing(Person::getAge).reversed());
        System.out.println(ps);
        // 先按照年龄排序，再按照姓名从高到低排序
        ps.sort(Comparator.comparing(Person::getAge, (o1, o2)
                -> o1 == null ? 1 : (o2 == null ? -1 : o1.compareTo(o2))).thenComparing((o1, o2)
                -> o1.getName() == null ? 1 : (o2.getName() == null ? -1 : o2.getName().compareTo(o1.getName()))));
        System.out.println(ps);
    }
}
@Data
class Person{
    String name;
    Integer age;
    Person(Integer age,String name){
        this.name=name;
        this.age=age;
    }
}

执行结果

[Person(name=tom, age=12), Person(name=tom, age=11), Person(name=张三, age=11), Person(name=tom, age=11)]
[Person(name=tom, age=12), Person(name=tom, age=11), Person(name=张三, age=11), Person(name=tom, age=11)]
[Person(name=tom, age=12), Person(name=tom, age=11), Person(name=张三, age=11), Person(name=tom, age=11)]
[Person(name=张三, age=11), Person(name=tom, age=11), Person(name=tom, age=11), Person(name=tom, age=12)]

Comparator.compare(T o1,T o2)比较原理
先看一个示例

Integer[] arr={2,3,4,1};
List<Integer> list=Arrays.asList(arr);
Collections.sort(list, new Comparator<Integer>() {
   @Override
   public int compare(Integer o1, Integer o2) {
       System.out.println(o1+"|"+o2);
       return o1-o2>0?1:-1;
   }
});
System.out.println("排序后顺序为："+list);

结果如下：

3|2
4|3
1|4
1|3
1|2
排序后顺序为：[1, 2, 3, 4]

可以看到o1与o2并不是按照顺序取的。在前几个排序中，o1取的是后面的，o2取的是前面的数字, 所以o1>o2可以认为是后面大于前面，所以是升序。反之，o1<o2认为前面大于后面所以是降序。(具体原理需要研究源码)