Java中实现多重排序的几种方法小结_Java

引言

在编程中，我们经常需要对数据进行排序。java 提供了多种方式来实现排序，包括使用 collections.sort() 方法、arrays.sort() 方法以及 comparable 和 comparator 接口。当需要进行多重排序时，即根据多个字段进行排序，我们可以采用以下几种方法：

1. 使用 collections.sort() 与 comparator

collections.sort() 方法允许我们传入一个 comparator 实例来自定义排序逻辑。我们可以在 comparator 中实现多重排序逻辑。

import java.util.*;
 
public class multisortexample {
    public static void main(string[] args) {
        list<person> people = arrays.aslist(
                new person("john", 25),
                new person("alice", 30),
                new person("bob", 25),
                new person("alice", 22)
        );
 
        collections.sort(people, new comparator<person>() {
            @override
            public int compare(person p1, person p2) {
                int agecompare = integer.compare(p1.getage(), p2.getage());
                if (agecompare != 0) {
                    return agecompare;
                }
                return p1.getname().compareto(p2.getname());
            }
        });
 
        for (person person : people) {
            system.out.println(person.getname() + " " + person.getage());
        }
    }
 
    static class person {
        private string name;
        private int age;
 
        public person(string name, int age) {
            this.name = name;
            this.age = age;
        }
 
        public string getname() {
            return name;
        }
 
        public int getage() {
            return age;
        }
    }
}

2. 使用 comparator.comparing 和 thencomparing

java 8 引入了 comparator 接口的 comparing 和 thencomparing 方法，使得多重排序更加简洁。

import java.util.*;
 
public class multisortexample {
    public static void main(string[] args) {
        list<person> people = arrays.aslist(
                new person("john", 25),
                new person("alice", 30),
                new person("bob", 25),
                new person("alice", 22)
        );
 
        collections.sort(people, comparator.comparing(person::getage)
                .thencomparing(person::getname));
 
        for (person person : people) {
            system.out.println(person.getname() + " " + person.getage());
        }
    }
 
    static class person {
        private string name;
        private int age;
 
        public person(string name, int age) {
            this.name = name;
            this.age = age;
        }
 
        public string getname() {
            return name;
        }
 
        public int getage() {
            return age;
        }
    }
}

3. 使用 stream api 进行排序

java 8 的 stream api 提供了一种更现代的方式来处理集合，包括排序。

import java.util.*;
import java.util.stream.*;
 
public class multisortexample {
    public static void main(string[] args) {
        list<person> people = arrays.aslist(
                new person("john", 25),
                new person("alice", 30),
                new person("bob", 25),
                new person("alice", 22)
        );
 
        list<person> sortedpeople = people.stream()
                .sorted(comparator.comparing(person::getage)
                        .thencomparing(person::getname))
                .collect(collectors.tolist());
 
        sortedpeople.foreach(person -> system.out.println(person.getname() + " " + person.getage()));
    }
 
    static class person {
        private string name;
        private int age;
 
        public person(string name, int age) {
            this.name = name;
            this.age = age;
        }
 
        public string getname() {
            return name;
        }
 
        public int getage() {
            return age;
        }
    }
}

4. 使用 comparable 接口

如果你的类可以控制，可以实现 comparable 接口，并在 compareto 方法中实现多重排序逻辑。

import java.util.*;
 
public class multisortexample {
    public static void main(string[] args) {
        list<person> people = arrays.aslist(
                new person("john", 25),
                new person("alice", 30),
                new person("bob", 25),
                new person("alice", 22)
        );
 
        people.sort(null); // 默认排序
 
        for (person person : people) {
            system.out.println(person.getname() + " " + person.getage());
        }
    }
 
    static class person implements comparable<person> {
        private string name;
        private int age;
 
        public person(string name, int age) {
            this.name = name;
            this.age = age;
        }
 
        public string getname() {
            return name;
        }
 
        public int getage() {
            return age;
        }
 
        @override
        public int compareto(person other) {
            int agecompare = integer.compare(this.age, other.age);
            if (agecompare != 0) {
                return agecompare;
            }
            return this.name.compareto(other.name);
        }
    }
}