【JAVA】排序数组的N种方式

Java排序

int[]

Arrays.sort()

正序排列

public static void main(String[] args) {
        int[] arr = {-1, 0, 3, 5, 9, 1, 8, 22, 1};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

结果

逆序排列

需要修改数组的基本类型int，改为对象Integer

public static void main(String[] args) {
        Integer[] arr = {-1, 0, 3, 5, 9, 1, 8, 22, 1};
        Arrays.parallelSort(arr, Collections.reverseOrder());
        System.out.println(Arrays.toString(arr));
    }

结果

另一种写法：自定义Comparator

public static void main(String[] args) {
        Integer[] arr = {-1, 0, 3, 5, 9, 1, 8, 22, 1};
        Arrays.parallelSort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(Arrays.toString(arr));
    }

java8使用lambda

public static void main(String[] args) {
        Integer[] arr = {-1, 0, 3, 5, 9, 1, 8, 22, 1};
        Arrays.parallelSort(arr, (a, b) -> b - a);
        System.out.println(Arrays.toString(arr));
    }

区间排列

public static void main(String[] args) {
        int[] arr = {-1, 0, 3, 5, 9, 1, 8, 22, 1};
        Arrays.parallelSort(arr, 0, 5);
        System.out.println(Arrays.toString(arr));
    }

结果

Arrays.parallelSort(arr)

并行排序，适用于多线程，方法同上

自定义排序

以下为快排

static void quickSort(int[] arr, int l, int r) {
        if (l >= r) return;
        int left = l, right = r;
        int mid = arr[(l + r) / 2];
        while (left <= right) {
            while (arr[left] < mid) left++;
            while (arr[right] > mid) right--;
            if (left <= right) {
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
                left++;
                right--;
            }
        }
        quickSort(arr, l, right);
        quickSort(arr, left, r);
    }

    public static void main(String[] args) {
        int[] arr = {-1, 0, 3, 5, 9, 1, 8, 22, 1};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

List<对象>

sort()

正序

public static void main(String[] args) {
        List<Integer> arr = Arrays.asList(-1, 0, 3, 5, 9, 1, 8, 22, 1);
        arr.sort(Comparator.comparingInt(Integer::intValue));
        System.out.println(arr);
    }

结果

逆序

public static void main(String[] args) {
        List<Integer> arr = Arrays.asList(-1, 0, 3, 5, 9, 1, 8, 22, 1);
        arr.sort(Comparator.comparingInt(Integer::intValue).reversed());
        System.out.println(arr);
    }

结果

排序多个值

例如学生对象

static class Student {
        private String name;
        private Integer score;
        private Integer age;

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

        public Student() {
        }

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

        public String getName() {
            return name;
        }

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

        public Integer getScore() {
            return score;
        }

        public void setScore(Integer score) {
            this.score = score;
        }

        public Integer getAge() {
            return age;
        }

        public void setAge(Integer age) {
            this.age = age;
        }
    }

先按照age排序然后按照score排序

public static void main(String[] args) {
        List<Student> arr = new ArrayList<>() {{
            add(new Student("张三", 15, 30));
            add(new Student("李四", 10, 15));
            add(new Student("王老五", -10, 20));
        }};
        arr.sort(Comparator.comparingInt(Student::getAge).thenComparingInt(Student::getScore));
        System.out.println(arr);
    }

结果