1. PingCode智库首页
  2. 百科

JAVA如何去重排序

Edit1 • • 百科

JAVA如何去重排序

使用Java进行去重排序的核心方法包括：使用Set集合、使用Stream API、使用TreeSet、使用自定义比较器。 在这些方法中，使用Stream API 是一种非常高效且简洁的方式。Stream API提供了便捷的去重和排序操作，只需几行代码便可实现复杂的数据处理任务。下面将详细介绍使用Stream API进行去重排序的过程。

一、使用Set集合

Set集合是Java中最常用的去重工具，因为Set本身不允许存储重复元素。

1.1、HashSet去重

HashSet是最常用的Set实现类，它利用哈希表存储元素，具有很好的性能。

import java.util.HashSet;


import java.util.List;


import java.util.ArrayList;


import java.util.Set;


public class HashSetExample {


    public static void main(String[] args) {


        List<Integer> list = new ArrayList<>();


        list.add(1);


        list.add(2);


        list.add(2);


        list.add(3);


        Set<Integer> set = new HashSet<>(list);


        System.out.println(set);


    }


}

1.2、LinkedHashSet去重排序

LinkedHashSet保持插入顺序，因此在去重的同时也能保持元素的原始顺序。

import java.util.LinkedHashSet;


import java.util.List;


import java.util.ArrayList;


import java.util.Set;


public class LinkedHashSetExample {


    public static void main(String[] args) {


        List<Integer> list = new ArrayList<>();


        list.add(3);


        list.add(2);


        list.add(1);


        list.add(2);


        Set<Integer> set = new LinkedHashSet<>(list);


        System.out.println(set);


    }


}

二、使用Stream API

Stream API提供了简洁的语法来处理集合，包含去重、排序等操作。

2.1、去重和排序

使用Stream的distinct()方法可以去重，sorted()方法可以排序。

import java.util.Arrays;


import java.util.List;


import java.util.stream.Collectors;


public class StreamExample {


    public static void main(String[] args) {


        List<Integer> list = Arrays.asList(3, 2, 1, 2);


        List<Integer> sortedUniqueList = list.stream()


                                             .distinct()


                                             .sorted()


                                             .collect(Collectors.toList());


        System.out.println(sortedUniqueList);


    }


}

2.2、自定义排序

通过自定义Comparator，可以灵活地定义排序规则。

import java.util.Arrays;


import java.util.List;


import java.util.Comparator;


import java.util.stream.Collectors;


public class CustomSortExample {


    public static void main(String[] args) {


        List<Integer> list = Arrays.asList(3, 2, 1, 2);


        List<Integer> sortedUniqueList = list.stream()


                                             .distinct()


                                             .sorted(Comparator.reverseOrder())


                                             .collect(Collectors.toList());


        System.out.println(sortedUniqueList);


    }


}

三、使用TreeSet

TreeSet是一个有序的Set实现类，自动对元素进行排序并去重。

3.1、TreeSet去重排序

TreeSet默认使用元素的自然顺序进行排序。

import java.util.TreeSet;


import java.util.Set;


public class TreeSetExample {


    public static void main(String[] args) {


        Set<Integer> set = new TreeSet<>();


        set.add(3);


        set.add(2);


        set.add(1);


        set.add(2);


        System.out.println(set);


    }


}

3.2、自定义排序规则

TreeSet的构造函数可以接受一个Comparator对象，定义自定义排序规则。

import java.util.TreeSet;


import java.util.Comparator;


import java.util.Set;


public class CustomTreeSetExample {


    public static void main(String[] args) {


        Set<Integer> set = new TreeSet<>(Comparator.reverseOrder());


        set.add(3);


        set.add(2);


        set.add(1);


        set.add(2);


        System.out.println(set);


    }


}

四、使用自定义比较器

自定义比较器可以让去重排序的逻辑更加灵活，适应不同的业务需求。

4.1、自定义Comparator

通过实现Comparator接口，可以定义复杂的排序规则。

import java.util.Arrays;


import java.util.List;


import java.util.Comparator;


import java.util.stream.Collectors;


public class CustomComparatorExample {


    public static void main(String[] args) {


        List<String> list = Arrays.asList("apple", "banana", "pear", "banana");


        List<String> sortedUniqueList = list.stream()


                                            .distinct()


                                            .sorted(Comparator.comparingInt(String::length))


                                            .collect(Collectors.toList());


        System.out.println(sortedUniqueList);


    }


}

4.2、结合多个Comparator

通过组合多个Comparator，可以实现多重排序条件。

import java.util.Arrays;


import java.util.List;


import java.util.Comparator;


import java.util.stream.Collectors;


public class MultiComparatorExample {


    public static void main(String[] args) {


        List<String> list = Arrays.asList("apple", "banana", "pear", "banana");


        List<String> sortedUniqueList = list.stream()


                                            .distinct()


                                            .sorted(Comparator.comparingInt(String::length)


                                                              .thenComparing(Comparator.naturalOrder()))


                                            .collect(Collectors.toList());


        System.out.println(sortedUniqueList);


    }


}

五、性能优化

5.1、选择合适的数据结构

不同的数据结构有不同的时间复杂度，选择合适的数据结构可以显著提高性能。

import java.util.HashSet;


import java.util.TreeSet;


import java.util.Set;


public class PerformanceExample {


    public static void main(String[] args) {


        // HashSet性能较好，但不保证顺序


        Set<Integer> hashSet = new HashSet<>();


        hashSet.add(3);


        hashSet.add(2);


        hashSet.add(1);


        hashSet.add(2);


        System.out.println(hashSet);


        // TreeSet性能稍差，但保证排序


        Set<Integer> treeSet = new TreeSet<>();


        treeSet.add(3);


        treeSet.add(2);


        treeSet.add(1);


        treeSet.add(2);


        System.out.println(treeSet);


    }


}

5.2、并行流处理

对于大型数据集，使用并行流可以显著提高处理速度。

import java.util.Arrays;


import java.util.List;


import java.util.stream.Collectors;


public class ParallelStreamExample {


    public static void main(String[] args) {


        List<Integer> list = Arrays.asList(3, 2, 1, 2);


        List<Integer> sortedUniqueList = list.parallelStream()


                                             .distinct()


                                             .sorted()


                                             .collect(Collectors.toList());


        System.out.println(sortedUniqueList);


    }


}

六、实战案例

6.1、去重排序用户列表

假设有一个用户列表，需要去重并按年龄排序。

import java.util.Arrays;


import java.util.List;


import java.util.Comparator;


import java.util.stream.Collectors;


class User {


    String name;


    int age;


    User(String name, int age) {


        this.name = name;


        this.age = age;


    }


    public String toString() {


        return name + " (" + age + ")";


    }


}


public class UserExample {


    public static void main(String[] args) {


        List<User> users = Arrays.asList(


            new User("Alice", 30),


            new User("Bob", 25),


            new User("Alice", 30),


            new User("Charlie", 35)


        );


        List<User> uniqueSortedUsers = users.stream()


                                            .distinct()


                                            .sorted(Comparator.comparingInt(user -> user.age))


                                            .collect(Collectors.toList());


        System.out.println(uniqueSortedUsers);


    }


}

6.2、去重排序订单列表

假设有一个订单列表，需要去重并按订单金额排序。

import java.util.Arrays;


import java.util.List;


import java.util.Comparator;


import java.util.stream.Collectors;


class Order {


    String orderId;


    double amount;


    Order(String orderId, double amount) {


        this.orderId = orderId;


        this.amount = amount;


    }


    public String toString() {


        return orderId + " ($" + amount + ")";


    }


}


public class OrderExample {


    public static void main(String[] args) {


        List<Order> orders = Arrays.asList(


            new Order("O1", 100.0),


            new Order("O2", 200.0),


            new Order("O1", 100.0),


            new Order("O3", 150.0)


        );


        List<Order> uniqueSortedOrders = orders.stream()


                                               .distinct()


                                               .sorted(Comparator.comparingDouble(order -> order.amount))


                                               .collect(Collectors.toList());


        System.out.println(uniqueSortedOrders);


    }


}

七、常见问题及解决方案

7.1、重复元素无法去重

如果重复元素无法去重，检查equals()和hashCode()方法是否正确实现。

import java.util.Objects;


class User {


    String name;


    int age;


    User(String name, int age) {


        this.name = name;


        this.age = age;


    }


    @Override


    public boolean equals(Object o) {


        if (this == o) return true;


        if (o == null || getClass() != o.getClass()) return false;


        User user = (User) o;


        return age == user.age && Objects.equals(name, user.name);


    }


    @Override


    public int hashCode() {


        return Objects.hash(name, age);


    }


    public String toString() {


        return name + " (" + age + ")";


    }


}

7.2、排序结果不正确

如果排序结果不正确，检查Comparator的实现是否符合预期。

import java.util.Comparator;


Comparator<User> ageComparator = Comparator.comparingInt(user -> user.age);

八、总结

Java提供了多种去重排序的方法，每种方法都有其适用场景。使用Stream API 是一种非常高效且简洁的方式，尤其适用于中小型数据集。在处理大型数据集时，可以考虑使用并行流以提高性能。此外，选择合适的数据结构和自定义Comparator可以使去重排序操作更加灵活和高效。通过本文的介绍，读者应该能够根据具体需求选择合适的方法进行去重排序，并在实际开发中灵活应用。

相关问答FAQs：

Q: 如何使用JAVA进行去重排序操作？
A: 在JAVA中，可以使用Set数据结构来进行去重操作，然后将其转换为List进行排序。

Q: JAVA中如何实现去重和排序的同时操作？
A: 可以使用TreeSet数据结构来实现去重和排序的同时操作。TreeSet会自动对元素进行排序，并且不允许重复元素存在。

Q: 是否有其他方法可以实现JAVA中的去重排序操作？
A: 是的，除了使用Set和TreeSet之外，还可以使用Stream API来进行去重和排序操作。可以使用distinct()方法进行去重，然后使用sorted()方法进行排序。

原创文章，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/279387

赞 (0)
Edit1Edit1
上一篇 2024年8月15日 上午8:54
下一篇 2024年8月15日 上午8:54
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部