【Java】對Java對象進行排序

如何對Java對象進行排序

對象排序

直接比較致使 ClassCastException

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.*;

/**
 * @author niushuai
 * @date 2019/9/18 10:17
 */
public class CompareDemo {

    public static void main(String[] args) {
        Student s1 = new Student("張三1", 13);
        Student s2 = new Student("張三2", 12);
        Student s3 = new Student("張三3", 11);

        arraysDemo(s1, s2, s3);
    }

    public static void arraysDemo(Student s1, Student s2, Student s3) {

        Student[] students = new Student[3];
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;

        Arrays.sort(students);

        System.out.println(Arrays.toString(students));
    }
}

@Data
@AllArgsConstructor
class Student {
    private String name;
    private int age;
}

 假如這樣的話會直接致使下圖狀況的出現。

 看異常信息能夠看到Student不能被轉換爲Comparable，標誌着咱們的Student類須要實現Comparable接口。那麼咱們就來試試實現Comparable接口的狀況

使用Comparable接口

 我在這裏按照年齡大小來排序，所以實現compareTo方法時按照age字段來比較值

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * @author niushuai
 * @date 2019/9/18 10:17
 */
public class CompareDemo {

    public static void main(String[] args) {
        Student s1 = new Student("張三1", 13);
        Student s2 = new Student("張三2", 12);
        Student s3 = new Student("張三3", 11);

        arraysDemo(s1, s2, s3);
        System.out.println("--------------------------------------------------------------------------------------------");
        listDemo(s1, s2, s3);
    }

    public static void listDemo(Student s1, Student s2, Student s3) {

        List<Student> students = new ArrayList<Student>();

        students.add(s1);
        students.add(s2);
        students.add(s3);

        System.out.println("排序前："+students);
        Collections.sort(students);
        System.out.println("排序後："+students);
    }

    public static void arraysDemo(Student s1, Student s2, Student s3) {

        Student[] students = new Student[3];
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;

        System.out.println("排序前："+Arrays.toString(students));
        Arrays.sort(students);
        System.out.println("排序後："+Arrays.toString(students));
    }
}


@Data
@AllArgsConstructor
class Student implements Comparable<Student> {
    private String name;
    private int age;

    @Override
    public int compareTo(Student o) {
        int result = 0;

        int targetAge = o.getAge();
        int thisAge = this.getAge();

        if (thisAge > targetAge) {
            result = 1;
        } else if (thisAge < targetAge) {
            result = -1;
        }

        return result;
    }
}

運行結果：

所以咱們能夠看到 這樣排序一切按照咱們預期的結果出現了。

對於List中存儲的對象注意事項

 針對List中存儲的對象如：

List<Student> students = new ArrayList<Student>();

Collections.sort(students);

 這樣的代碼存在着一個錯誤，Collections.sort()方法接收的參數必需要實現Comparable接口或者使用匿名內部類的形式 Collections.sort(students, new Comparable<Student>(){...});

使用匿名內部類

  同時咱們還有另一種方法來對未實現Comparable接口的對象來排序，那就是使用匿名內部類的方式。
 經過查看Arrays.sort()和Collections.sort()方法時，咱們會發現以下狀況:

Arrays.sort(Object[] a)
Arrays.sort(T[] a, Comparator<? super T> c)

Collections.sort(List<T> list)
Collections.sort(List<T> list, Comparator<? super T> c)

 因此咱們已經發現了，這兩個java提供的排序方法均可以使用匿名內部類的方式來實現該方式，那麼咱們下面來使用這種方式進行測試。

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.*;

/**
 * @author niushuai
 * @date 2019/9/18 10:25
 */
public class CompareDemo2 {

    public static void main(String[] args) {
        Student2 s1 = new Student2("張三1", 13);
        Student2 s2 = new Student2("張三2", 12);
        Student2 s3 = new Student2("張三3", 11);

        arraysDemo(s1, s2, s3);
        System.out.println("--------------------------------------------------------------------------------------------");
        listDemo(s1, s2, s3);
    }

    public static void listDemo(Student2 s1, Student2 s2, Student2 s3) {

        List<Student2> students = new ArrayList<Student2>();

        students.add(s1);
        students.add(s2);
        students.add(s3);

        System.out.println("排序前："+students);
        Collections.sort(students, new Comparator<Student2>() {
            @Override
            public int compare(Student2 o1, Student2 o2) {

                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println("排序後："+students);
    }

    public static void arraysDemo(Student2 s1, Student2 s2, Student2 s3) {

        Student2[] students = new Student2[3];
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;

        System.out.println("排序前："+Arrays.toString(students));
        Arrays.sort(students, new Comparator<Student2>() {
            @Override
            public int compare(Student2 o1, Student2 o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println("排序後："+Arrays.toString(students));
    }
}


@Data
@AllArgsConstructor
class Student2 {
    private String name;
    private int age;
}

運行結果：

咱們能夠看到 這兩種方式的結果同樣。所以 兩種方式，選用哪一種就全憑我的意願咯QvQ