java常用的排序方法

可以使用java.util包下Arrays类里的静态方法sort

代码示例：

public class ArraysSort {
    public static void main(String[] args) {
        Integer[] a = {9, 8, 5, 13, 76, 34};
        Arrays.sort(a);
        for (Integer i : a) {
            System.out.println(i);
        }
    }
}

Arrays.sort()有很多重载方法，通过看源码或api文档可知，其中有一个sort方法传入的2参数分别是一个数组和一个Comparator泛型接口，这个接口就是实现逆序排序的关键了。由于参数都是实例的，而接口是不能直接实例的，所以我们可以写一个实现这个接口的类，然后重写比较大小的规则即可。

public class ArraysSort {
    public static void main(String[] args) {
        Integer[] a = {9, 8, 5, 13, 76, 34};
        Arrays.sort(a, new MyComparator());
        for (Integer i : a) {
            System.out.println(i);
        }
    }
}

class MyComparator implements Comparator{
    @Override
    public int compare(Integer o1, Integer o2) {
      // 从大到小是o2 - o1,从小到大是o1 - o2
      // 返回值是负数，会把数字往左移，等于0不变，正数右移
        return o2 - o1;
    }
}

public class ArraysSort {
    public static void main(String[] args) {
        Integer[] a = {9, 8, 5, 13, 76, 34};
        // 0是开始位置，2是结束位置+1（所以索引的范围是前闭后开）
        Arrays.sort(a, 0, 2);
        for (Integer i : a) {
            System.out.println(i);
        }
    }
}

可以使用java.util包下Collections类里的静态方法sort

public class ListSort {
    public static void main(String[] args) {
        List list1 = new ArrayList<>();
        list1.add(9);
        list1.add(4);
        list1.add(2 );
        list1.add(13);
        Collections.sort(list1);
        System.out.println(list1);
    }
}

方法1：实现Comparator接口

public class ListSort {
    public static void main(String[] args) {
        List list1 = new ArrayList<>();
        list1.add(9);
        list1.add(4);
        list1.add(2 );
        list1.add(13);
        Collections.sort(list1, new MyComparator());
        System.out.println(list1);
    }
}

class MyComparator implements Comparator{
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}

方法2：

使用Collections.reverse()方法可以反转List

先从小到大排序，然后反转List

public class ListSort {
    public static void main(String[] args) {
        List list1 = new ArrayList<>();
        list1.add(9);
        list1.add(4);
        list1.add(2 );
        list1.add(13);
        Collections.sort(list1);
        Collections.reverse(list1);
        System.out.println(list1);
    }
}

自定义对象需要实现Comparable接口并重写compareTo方法，Integer类也实现了Comparable接口，所以参考源码改改参数即可实现。学会这个技术对特殊的数据结构进行排序就非常方便了，比如对一个链表进行排序。

class Student implements Comparable {
  	// 定义了一个简单的pojo类，然后定义构造函数，get,set,toString方法，并重写compareTo方法
    private Integer id;
    private String name;

    public Student(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public Student() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + ''' +
                '}';
    }

    @Override
    public int compareTo(Student o) {
      	// 这里两个数比较也有三种情况，和上述的Comparator接口的方法差不多
        return (this.id < o.id) ? -1 : ((this.id == o.id) ? 0 : 1);
    }
}
public class ListSort {
    public static void main(String[] args) {
        List list1 = new ArrayList<>();
        list1.add(new Student(89, "李四"));
        list1.add(new Student(45, "张三"));
        list1.add(new Student(101, "王五"));
        Collections.sort(list1);
        System.out.println(list1);
    }
}

可以使用 Collections.shuffle方法，随机这个场景也是比较多的，比如扑克牌的发牌。就可以不用自己造轮子了。

public class ListSort {
    public static void main(String[] args) {
        List list1 = new ArrayList<>();
        list1.add(new Student(89, "李四"));
        list1.add(new Student(45, "张三"));
        list1.add(new Student(101, "王五"));
        Collections.shuffle(list1);
        System.out.println(list1);
    }
}