对象数组排序及对象集合排序

对象数组排序及对象集合排序

---

方式一、 排序对象类实现comparable接口的compareTo方法

• 1.对象类

class Person implements Comparable<Person>{
    private String name;
    private Integer age;
    @Override
    public int compareTo(Person o) {
        return this.age-o.age;
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

• 2.Main方法

public static void main(String[] args) {

        List<Person> list=new ArrayList<>();
        list.add(new Person("小强-A",80));
        list.add(new Person("小强-B",20));
        list.add(new Person("小强-C",30));
        Collections.sort(list);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).toString());
        }
}        

compareTo方法实际上是一个比较大小的方法，只要是排序，我们必须用到比较，若果是简单的整数数组排序，我们只需要用 > 、 < 等进行比较，但是对于对象来说，Collections集合工具类在进行排序时，每次比较，都是调用的我们实现的compareTo方法，this表示当前对象，o表示要进行比较的传入对象，返回是一个int类型的整数

• 返回值>0：表示当前对象比传入对象大（年龄）
• 返回值=0：表示当前对象和传入对象一样大（年龄）
• 返回值<0：表示当前对象比传入对象小（年龄）

排序结果：

Person{name='小强-B', age=20}
Person{name='小强-C', age=30}
Person{name='小强-A', age=80}

Process finished with exit code 0

---

方式二、利用comparator接口自定义排序

使用方式一我们必须在Person类上面进行修改，这显然不是最好的办法。如果要求Person类不允许改动，这个可以采用补救式方法，排序对象外部自定义一个比较器（Comparator接口的实现类),我们直接使用匿名内部类的方式。

class Person {
    private String name;
    private Integer age;
    

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

Main

public static void main(String[] args) {

        List<Person> list=new ArrayList<>();
        list.add(new Person("小强-A",80));
        list.add(new Person("小强-B",20));
        list.add(new Person("小强-C",30));
        //使用Collections：
        Collections.sort(list, new Comparator<Person>() {

            @Override
            public int compare(Person o1, Person o2) {
                //升序排序，降序反写
                return o1.getAge()-o2.getAge();
            }

        });
        //另外一种方式，直接使用list：
        /* list.sort(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });*/
        //输出
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).toString());
        }
}        

输出：

Person{name='小强-B', age=20}
Person{name='小强-C', age=30}
Person{name='小强-A', age=80}

Process finished with exit code 0

---

方式三、lambda表达式

此时的Person类我们不用进行任何改写，和方式二的一样即可。

main方法：

public static void main(String[] args) {
     List<Person> list=new ArrayList<>();
        list.add(new Person("小强-A",80));
        list.add(new Person("小强-B",20));
        list.add(new Person("小强-C",30));
    //排序：
    Collections.sort(list, (o1, o2) -> o1.getAge() - o2.getAge());
    //或者使用下面代码
    //list.sort((o1, o2) -> o1.getAge()-o2.getAge());
    //输出
    for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).toString());
        }

}

---

方式四、使用方法引用进一步简化

此时的Person类我们不用进行任何改写，和方式二的一样即可。使用Comparator.comparingInt()方法，后面还可以接上.reversed()进行逆向操作

main方法：

public static void main(String[] args) {
     List<Person> list=new ArrayList<>();
        list.add(new Person("小强-A",80));
        list.add(new Person("小强-B",20));
        list.add(new Person("小强-C",30));
    //排序：
    Collections.sort(list, Comparator.comparingInt(Person::getAge));
    //或者使用下面代码
    //list.sort(Comparator.comparingInt(Person::getAge));
    //输出
    for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).toString());
        }

}

---

方式五、使用Stream流

此时的Person类我们不用进行任何改写，和方式二的一样即可。

main方法：

public static void main(String[] args) {
     List<Person> list=new ArrayList<>();
        list.add(new Person("小强-A",80));
        list.add(new Person("小强-B",20));
        list.add(new Person("小强-C",30));
    //正向排序
    List<Person> persons = list.stream().
                sorted((Comparator.comparingInt(Person::getAge)))
                .collect(Collectors.toList());
    //反向排序
    List<Person> persons = list.stream().
                sorted((Comparator.comparingInt(Person::getAge).reversed()))
                .collect(Collectors.toList());
    //输出
     for (int i = 0; i < persons.size(); i++) {
            System.out.println(persons.get(i).toString());
        }

}

注：返回一个有序的List集合

总的来说，如果没有强制要求不允许改变对象类继承关系，推荐使用方式一。

---

END ~~