Java 对象排序详解

怼烎@ 2022-05-26 06:56 162阅读 0赞

很难想象有Java开发人员不曾使用过Collection框架。在Collection框架中，主要使用的类是来自List接口中的ArrayList，以及来自Set接口的HashSet、TreeSet，我们经常处理这些Collections的排序。

在本文中，我将主要关注排序Collection的ArrayList、HashSet、TreeSet，以及最后但并非最不重要的数组。

![sort-usage][]

让我们看看如何对给定的整数集合（5,10,0，-1）进行排序：

## 数据（整数）存储在ArrayList中 ##

private void sortNumbersInArrayList() {
            List<Integer> integers = new ArrayList<>();
            integers.add(5);
            integers.add(10);
            integers.add(0);
            integers.add(-1);
            System.out.println("Original list: " +integers);
            Collections.sort(integers);
            System.out.println("Sorted list: "+integers);
            Collections.sort(integers, Collections.reverseOrder());
            System.out.println("Reversed List: " +integers);
    }

输出：

Original list: [5, 10, 0, -1]
    Sorted list: [-1, 0, 5, 10]
    Reversed List: [10, 5, 0, -1]

## 数据（整数）存储在HashSet中 ##

private void sortNumbersInHashSet() {
            Set<Integer> integers = new HashSet<>();
            integers.add(5);
            integers.add(10);
            integers.add(0);
            integers.add(-1);
            System.out.println("Original set: " +integers);
           // Collections.sort(integers); This throws error since sort method accepts list not collection
            List list = new ArrayList(integers);
            Collections.sort(list);
            System.out.println("Sorted set: "+list);
            Collections.sort(list, Collections.reverseOrder());
            System.out.println("Reversed set: " +list);
     }

输出：

Original set: [0, -1, 5, 10]
    Sorted set: [-1, 0, 5, 10]
    Reversed set: [10, 5, 0, -1]

在这个例子中（数据（整数）存储在HashSet中），我们看到HashSet被转换为ArrayList进行排序。在不转换为ArrayList的情况下，可以通过使用TreeSet来实现排序。TreeSet是Set的另一个实现，并且在使用默认构造函数创建Set时，使用自然排序进行排序。

## 数据（整数）存储在TreeSet中 ##

private void sortNumbersInTreeSet() {
            Set<Integer> integers = new TreeSet<>();
            integers.add(5);
            integers.add(10);
            integers.add(0);
            integers.add(-1);
            System.out.println("Original set: " + integers);
            System.out.println("Sorted set: "+ integers);
            Set<Integer> reversedIntegers = new TreeSet(Collections.reverseOrder());
            reversedIntegers.add(5);
            reversedIntegers.add(10);
            reversedIntegers.add(0);
            reversedIntegers.add(-1);
            System.out.println("Reversed set: " + reversedIntegers);
     }

输出：

Original set: [-1, 0, 5, 10]
    Sorted set: [-1, 0, 5, 10]
    Reversed set: [10, 5, 0, -1]

在这种情况下，“Original set:”和“Sorted set:”两者相同，因为我们已经使用了按排序顺序存储数据的TreeSet，所以在插入后不用排序。

到目前为止，一切都如期工作，排序似乎是一件轻而易举的事。现在让我们尝试在各个Collection中存储自定义对象（比如Student），并查看排序是如何工作的。

## 数据（Student对象）存储在ArrayList中 ##

private void sortStudentInArrayList() {
            List<Student> students = new ArrayList<>();
            Student student1 = createStudent("Biplab", 3);
            students.add(student1);
            Student student2 = createStudent("John", 1);
            students.add(student2);
            Student student3 =  createStudent("Pal", 5);
            students.add(student3);
            Student student4 = createStudent("Biplab", 2);
            students.add(student4);
            System.out.println("Original students list: " + students);
            Collections.sort(students);// Error here
            System.out.println("Sorted students list: " + students);
            Collections.sort(students, Collections.reverseOrder());
            System.out.println("Reversed students list: " + students);
    }
    private Student createStudent(String name, int no) {
            Student student = new Student();
            student.setName(name);
            student.setNo(no);
            return student;
    }
    public class Student {
        String name;
        int no;
        public String getName() {
            return name;
        }
        public int getNo() {
            return no;
        }
        public void setName(String name) {
            this.name = name;
        }
        public void setNo(int no) {
            this.no = no;
        }
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", no=" + no +
                    '}';
        }
    }

这会抛出编译时错误，并显示以下错误消息：

sort(java.util.List<T>)
    in Collections cannot be applied
    to (java.util.List<com.example.demo.dto.Student>)
    reason: no instance(s) of type variable(s) T exist so that Student 
    conforms to Comparable<? Super T>

为了解决这个问题，要么Student类需要实现Comparable，要么需要在调用Collections.sort时传递Comparator对象。在整型情况下，排序方法没有错误，因为Integer类实现了Comparable。让我们看看，实现Comparable或传递Comparator如何解决这个问题，以及排序方法如何实现Collection排序。

### 使用Comparable排序 ###

package com.example.demo.dto;
    public class Student implements Comparable{
        String name;
        int no;
        public String getName() {
            return name;
        }
        public int getNo() {
            return no;
        }
        public void setName(String name) {
            this.name = name;
        }
        public void setNo(int no) {
            this.no = no;
        }
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", no=" + no +
                    '}';
        }
        @Override
        public int compareTo(Object o) {
             return this.getName().compareTo(((Student) o).getName());
        }
    }

输出：

Original students list: [Student{name='Biplab', no=3}, Student{name='John', no=1}, Student{name='Pal', no=5}, Student{name='Biplab', no=2}]
    Sorted students list: [Student{name='Biplab', no=3}, Student{name='Biplab', no=2}, Student{name='John', no=1}, Student{name='Pal', no=5}]
    Reversed students list: [Student{name='Pal', no=5}, Student{name='John', no=1}, Student{name='Biplab', no=3}, Student{name='Biplab', no=2}]

在所有示例中，为了颠倒顺序，我们使用“Collections.sort(students, Collections.reverseOrder()”，相反的，它可以通过改变compareTo(..)方法的实现而达成目标，且compareTo(…) 的实现看起来像这样 ：

@Override
      public int compareTo(Object o) {
         return (((Student) o).getName()).compareTo(this.getName());
      }

输出：

Original students list: [Student{name='Biplab', no=3}, Student{name='John', no=1}, Student{name='Pal', no=5}, Student{name='Biplab', no=2}]
    Sorted students list: [Student{name='Pal', no=5}, Student{name='John', no=1}, Student{name='Biplab', no=3}, Student{name='Biplab', no=2}]
    Reversed students list: [Student{name='Biplab', no=3}, Student{name='Biplab', no=2}, Student{name='John', no=1}, Student{name='Pal', no=5}]

如果我们观察输出结果，我们可以看到“Sorted students list:”以颠倒的顺序（按学生name）输出学生信息。

到目前为止，对学生的排序是根据学生的“name”而非“no”来完成的。如果我们想按“no”排序，我们只需要更改Student类的compareTo(Object o)实现，如下所示：

@Override
     public int compareTo(Object o) {
        return  (this.getNo() < ((Student) o).getNo() ? -1 : (this.getNo() == ((Student) o).getNo() ? 0 : 1));
    }

输出：

Original students list: [Student{name='Biplab', no=3}, Student{name='John', no=1}, Student{name='Pal', no=5}, Student{name='Biplab', no=2}]
    Sorted students list: [Student{name='John', no=1}, Student{name='Biplab', no=2}, Student{name='Biplab', no=3}, Student{name='Pal', no=5}]
    Reversed students list: [Student{name='Pal', no=5}, Student{name='Biplab', no=3}, Student{name='Biplab', no=2}, Student{name='John', no=1}]

在上面的输出中，我们可以看到“no”2和3的两名学生具有相同的名字“Biplab”。

现在假设我们首先需要按“name”对这些学生进行排序，如果超过1名学生具有相同姓名的话，则这些学生需要按“no”排序。为了实现这一点，我们需要改变compareTo(…)方法的实现，如下所示：

@Override
      public int compareTo(Object o) {
        int result = this.getName().compareTo(((Student) o).getName());
            if(result == 0) {
                result = (this.getNo() < ((Student) o).getNo() ? -1 : (this.getNo() == ((Student) o).getNo() ? 0 : 1));
            }
            return  result;
     }

输出：

Original students list: [Student{name='Biplab', no=3}, Student{name='John', no=1}, Student{name='Pal', no=5}, Student{name='Biplab', no=2}]
    Sorted students list: [Student{name='Biplab', no=2}, Student{name='Biplab', no=3}, Student{name='John', no=1}, Student{name='Pal', no=5}]
    Reversed students list: [Student{name='Pal', no=5}, Student{name='John', no=1}, Student{name='Biplab', no=3}, Student{name='Biplab', no=2}]

### 使用Comparator排序 ###

为了按照“name”对Students进行排序，我们将添加一个Comparator并将其传递给排序方法：

public class Sorting {
     private void sortStudentInArrayList() {
            List<Student> students = new ArrayList<>();
            Student student1 = createStudent("Biplab", 3);
            students.add(student1);
            Student student2 = createStudent("John", 1);
            students.add(student2);
            Student student3 =  createStudent("Pal", 5);
            students.add(student3);
            Student student4 = createStudent("Biplab", 2);
            students.add(student4);
            System.out.println("Original students list: " + students);
            Collections.sort(integers, new NameComparator());
            System.out.println("Sorted students list: " + students);
     }
    }
    public class Student {
        String name;
        int no;
        public String getName() {
            return name;
        }
        public int getNo() {
            return no;
        }
        public void setName(String name) {
            this.name = name;
        }
        public void setNo(int no) {
            this.no = no;
        }
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", no=" + no +
                    '}';
        }
    }
    class NameComparator implements Comparator<Student> {
        @Override
        public int compare(Student o1, Student o2) {
            return o1.getName().compareTo(o2.getName());
        }
    }

输出：

同样，如果我们想按照“no”对Students排序，那么可以再添加一个Comparator（NoComparator.java），并将其传递给排序方法，然后数据将按“no”排序。

现在，如果我们想通过“name”然后“no”对学生进行排序，那么可以在compare(…)内结合两种逻辑来实现。

class NameNoComparator implements Comparator<Student> {
        @Override
        public int compare(Student o1, Student o2) {
            int result = o1.getName().compareTo(o2.getName());
            if(result == 0) {
                result =  o1.getNo() <  o2.getNo() ? -1 : o1.getNo() == o2.getNo() ? 0 : 1;
            }
           return result;
        }
    }

输出：

## 数据（Students对象）存储在Set中 ##

在Set的这个情况下，我们需要将HashSet转换为ArrayList，或使用TreeSet对数据进行排序。此外，我们知道要使Set工作，equals(…)和hashCode()方法需要被覆盖。下面是基于“no”字段覆盖equals和hashcode的例子，且这些是IDE自动生成的代码。与Comparable或Comparator相关的其他代码与ArrayList相同。

@Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return no == student.no;
        }
        @Override
        public int hashCode() {
            return Objects.hash(no);
        }

## 数据（Students对象）存储在数组中 ##

为了对数组排序，我们需要做与排序ArrayList相同的事情（要么执行Comparable要么传递Comparable给sort方法）。在这种情况下，sort方法是“Arrays.sort(Object\[\] a )”而非“Collections.sort(..)”。

private void sortStudentInArray() {
           Student [] students = new Student[4];
            Student student1 = createStudent("Biplab", 3);
            students[0] = student1;
            Student student2 = createStudent("John", 1);
            students[1] = student2;
            Student student3 =  createStudent("Pal", 5);
            students[2] = student3;
            Student student4 = createStudent("Biplab", 2);
            students[3] = student4;
            System.out.print("Original students list: ");
            for (Student student: students) {
                System.out.print( student + " ,");
            }
            Arrays.sort(students);
            System.out.print("\nSorted students list: ");
            for (Student student: students) {
                System.out.print( student +" ,");
            }
            Arrays.sort(students, Collections.reverseOrder());
            System.out.print("\nReversed students list: " );
            for (Student student: students) {
                System.out.print( student +" ,");
            }
       }
    //Student class
    // All properties goes here
      @Override
       public int compareTo(Object o) {
           int result =this.getName().compareTo(((Student)o).getName());
           if(result ==0) {
               result =  (this.getNo() < ((Student) o).getNo() ? -1 : (this.getNo() == ((Student) o).getNo() ? 0 : 1));
           }
           return  result;
       }

输出：

Original students list: Student{name='Biplab', no=3} ,Student{name='John', no=1} ,Student{name='Pal', no=5} ,Student{name='Biplab', no=2} ,
    Sorted students list: Student{name='Biplab', no=2} ,Student{name='Biplab', no=3} ,Student{name='John', no=1} ,Student{name='Pal', no=5} ,
    Reversed students list: Student{name='Pal', no=5} ,Student{name='John', no=1} ,Student{name='Biplab', no=3} ,Student{name='Biplab', no=2} ,

## 结论 ##

我们经常对Comparable/Comparator的使用以及何时使用哪个感到困惑。下面是我总结的Comparable/Comparator的使用场景。

Comparator：

*  当我们想排序一个无法修改的类的实例时。例如来自jar的类的实例。
 *  根据用例需要排序不同的字段时，例如，一个用例需要通过“name”排序，还有个想要根据“no”排序，或者有的用例需要通过“name和no”来排序。

Comparable：

应该在定义类时知道排序的顺序时使用，并且不会有其他任何需要使用Collection /数组来根据其他字段排序的情况。

注意：我没有介绍Set / List的细节。我假设读者已经了解了这些内容。此外，没有提供使用Set / array进行排序的详细示例，因为实现与ArrayList非常相似，而ArrayList我已经详细给出了示例。

最后，感谢阅读。

[sort-usage]: http://static.codeceo.com/images/2018/03/sort-usage.jpg