List 的排序、筛选、去重、统计。

已于 2023-02-04 22:02:55 修改
阅读量816 收藏 1
点赞数
分类专栏： Java 文章标签： list java jvm
于 2023-02-01 11:11:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/muyuchenzi/article/details/128828880
版权

List 的三种排序方式

数据准备

准备一个List，这里有四个变量，id,name,age,birthday；因为私有变量，所以需要添加一个访问的方法

public class UserBean {
    private long id;
    private String name;
    private Integer age;
    private String birthday;
    public UserBean(long id,String name,Integer age,String birthday){
        this.id=id;
        this.name=name;
        this.age=age;
        this.birthday=birthday;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    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;
    }

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User{"+
                "name="+this.name+","+
                "id="+this.id+","+
                "age="+this.age+","+
                "birthday="+this.birthday+
                "}";

    }
}

Comparator

这里使用了其实是重写了Collections的sort中的compare方法,如果o1.attributeValue>o2.attributeValue那么返回1，表示需要调整顺序，如果<的话就是不调整，所以这样下来就是一个升序的排序，反之就是降序了，固定的模式记着就可以了

public class OrderList {
    public static List initUserBean() {
        List<UserBean> userBeanList = new ArrayList<>();
        userBeanList.add(new UserBean(1001, "alpha", 10, "2000/1/23"));
        userBeanList.add(new UserBean(1002, "beta", 30, "1990/3/23"));
        userBeanList.add(new UserBean(3003, "gamma", 23, "1993/1/12"));
        userBeanList.add(new UserBean(4001, "delta", 43, "1973/7/30"));
        userBeanList.add(new UserBean(9001, "epsilon", 9, "2001/11/28"));
        userBeanList.add(new UserBean(522, "zeta", 19, "1999/4/7"));
        for (UserBean userBean : userBeanList) {
            System.out.println(userBean.getName());
        }
        return userBeanList;
    }

    public static void sortUserByComparator(List<UserBean> users) {
        System.out.println("排序前的顺序");
        for (UserBean user : users) {
            System.out.println(user.toString());
        }
        System.out.println("排序后");
//      NOTE 使用Collections 的工具类；
        Collections.sort(users, new Comparator<UserBean>() {
            @Override
            public int compare(UserBean o1, UserBean o2) {
                if (o1.getAge() > o2.getAge()) {
                    return 1;
                } else if (o1.getAge() < o2.getAge()) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });
        for (UserBean user : users) {
            System.out.println(user.toString());
        }
    }
  
    public static void main(String[] args) {
        List<UserBean> userBeans = initUserBean();
        sortUserByComparator(users);     
    }
}

stream

java 8以后加入的，使用这个更加方便，推荐

public class OrderList {
    public static List initUserBean() {
        List<UserBean> userBeanList = new ArrayList<>();
        userBeanList.add(new UserBean(1001, "alpha", 10, "2000/1/23"));
        userBeanList.add(new UserBean(1002, "beta", 30, "1990/3/23"));
        userBeanList.add(new UserBean(3003, "gamma", 23, "1993/1/12"));
        userBeanList.add(new UserBean(4001, "delta", 43, "1973/7/30"));
        userBeanList.add(new UserBean(9001, "epsilon", 9, "2001/11/28"));
        userBeanList.add(new UserBean(522, "zeta", 19, "1999/4/7"));
        for (UserBean userBean : userBeanList) {
            System.out.println(userBean.getName());
        }
        return userBeanList;
    }

  
    public static void sortUserByStream(List<UserBean> users) {
        System.out.println("排序前");
        for (UserBean user : users) {
            System.out.println(user.toString());
        }
        System.out.println("正序后");
        List<UserBean> newUsersAlpha = users.stream()
                .sorted(Comparator.comparing(UserBean -> UserBean.getAge()))
                .collect(Collectors.toList());
        System.out.println("倒序后");
        List<UserBean> newUserBeta = users.stream()
                .sorted(Comparator.comparing(UserBean::getAge).reversed())
                .collect(Collectors.toList());
        for (UserBean user : newUserBeta) {
            System.out.println(user.toString());
        }
    }



    public static void main(String[] args) {
        List<UserBean> userBeans = initUserBean();
        sortUserByStream(userBeans);
    }
}

Comparable

这里是用类调用了Comparable的接口来实现的，首先就是在类中重写了Comparable的compareTo( )的方法，
然后在调用的时候直接使用Collections.sort(object)来进行调用

类的实现如下：

public class User implements Comparable<User> {
    private long id;
    private String name;
    private Integer age;
    private String birthday;

    public User(long id, String name, Integer age, String birthday) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    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;
    }

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "name=" + this.name + "," +
                "id=" + this.id + "," +
                "age=" + this.age + "," +
                "birthday=" + this.birthday +
                "}";

    }

    @Override
    public int compareTo(User o) {
        if(this.age>o.getAge()){
            return 1;
        } else if (this.age<o.getAge()) {
            return -1;
        }else {
            return 0;
        }
    }
}

使用场景

public class OrderList {
    public static List intiUser() {
        /** 这里使用userBeanList 来替代本来的userList，不想改了*/
        ArrayList<User> userBeanList = new ArrayList<>();
        userBeanList.add(new User(1001, "alpha", 10, "2000/1/23"));
        userBeanList.add(new User(1002, "beta", 30, "1990/3/23"));
        userBeanList.add(new User(3003, "gamma", 23, "1993/1/12"));
        userBeanList.add(new User(4001, "delta", 43, "1973/7/30"));
        userBeanList.add(new User(9001, "epsilon", 9, "2001/11/28"));
        userBeanList.add(new User(522, "zeta", 19, "1999/4/7"));
        for (User userBean : userBeanList) {
            System.out.println(userBean.getName());
        }
        return userBeanList;
    }
    public static void sortUserByComparable(ArrayList<User> userList) {
        System.out.println("排序前");
        for (User user : userList) {
            System.out.println(user);
        }
        System.out.println("排序后");
        List<User> sortedUserList = (List<User>) userList.clone();
        Collections.sort(sortedUserList);//**这里就是直接调用就可以了，如果倒序的话需要到类中修改**
        for (User user : sortedUserList) {
            System.out.println(user);
        }
    }
    public static void main(String[] args) {
        List<User> users = intiUser();
        sortUserByComparable((ArrayList<User>) users);

    }
}

List的三种筛选方式

java8以后的stream

其实就是使用stream的filter

		List<UserBean> userBeanFilterResult = userBeanList.stream()
                .filter(UserBean -> UserBean.getAge() > 18)
                .collect(Collectors.toList());
        /** 为了防止很多对象有null的情况，那么在userBean.getAge() 会有空指针，
         * 所以在前面加一个filter处理逻辑，*/
        List<UserBean> finalUserBeanFilterResult=userBeanList.stream()
                .filter(userBean -> Objects.nonNull(userBean))
//                .filter(Objects::nonNull)
                .filter(userBean -> userBean.getAge()>18)
                .collect(Collectors.toList());
        for(UserBean ele:userBeanFilterResult){
            System.out.println(ele);
        }

最基础的for循环

for and foreach

        List<UserBean> userBeansFilterResult=new ArrayList<>();
        for (UserBean element:userBeanList){
            if(element.getAge()>18){
                userBeansFilterResult.add(element);
            }
        }
        for (UserBean ele:userBeansFilterResult){
            System.out.println(ele);
        }
        /**
         * 第二种for循环*/
        List<UserBean> userBeansFilterResultBeta=new ArrayList<>();
        userBeanList.forEach(element->{
            if(element.getAge()>18){
                userBeansFilterResultBeta.add(element);
            }
        });
        for (UserBean ele:userBeansFilterResultBeta){
            System.out.println(ele);
        }

使用迭代器

这里就是for循环更底层的一种方式

 List<UserBean> userBeansFilterResult=new ArrayList<>();
        Iterator<UserBean>iterator=userBeanList.iterator();
        while (iterator.hasNext()){
            UserBean element=iterator.next();
            if(element.getAge()>18){
                userBeansFilterResult.add(element);
            }
        }
        for (UserBean element : userBeansFilterResult) {
            System.out.println(element);
        }

List的去重

利用HashMap来进行去重

这里不知道为啥不直接用HashSet去重，其实使用HashSet 可能更方便。。。

    public static List<UserBean> handleSameElementHashMap(List<UserBean> userBeansList) {
        if (userBeansList == null || userBeansList.size() == 0) {
            return userBeansList;
        }
        List<UserBean> list = new ArrayList<>();
        Map<String, UserBean> userBeanMap = new HashMap<>();
        userBeansList.forEach(userBean -> userBeanMap.put(userBean.getName(), userBean));
        userBeanMap.forEach((s, userBean) -> list.add(userBean));
        return list;
    }
//调用
    public static void alphaUniqueUserBean(){
        /**第一种方法就是使用哈希来进行，利用hash的唯一性来进行去重
         * 这里保存的是后面的，也就是使用覆盖的类型*/
        List<UserBean>userBeanList=initUserBeanList();
        List<UserBean>uniqueUserBeanList=UniqueueList.handleSameElementHashMap(userBeanList);
        uniqueUserBeanList.forEach(System.out::println);
    }

使用HashSet来进行去重

这里不知道为啥非要加一个optional来进行，虽然是我自己写的，但是真的不知道ide为啥要给个这个提示。

    public static List<UserBean> handleSameElementByHashSet(List<UserBean>userBeanList){
        if(null==userBeanList||userBeanList.size()==0){
            return userBeanList;
        }
        Set<String> hashSet=new HashSet<>();
        userBeanList.forEach(userBean -> hashSet.add(userBean.getName()));
        System.out.println(hashSet);
//        List<UserBean> filteredUserBeanList=userBeanList.stream()
//                .filter(userBean -> hashSet.contains(userBean.getName()))
//                .collect(Collectors.toList());
//        System.out.println(filteredUserBeanList);
        List<Optional<UserBean>> filteredUserBenList=new ArrayList<>();
//        System.out.println(testUserBean);
        hashSet.forEach(element->filteredUserBenList.add(userBeanList.stream().filter(ele->ele.getName().equals(element)).findFirst()));
        System.out.println(filteredUserBenList);
        return userBeanList;
    }
    public static void deltaUniqueUserBean(){
        /**这里使用HashSet来进行处理
         * */
        List<UserBean>userBeanList=initUserBeanList();
        UniqueueList.handleSameElementByHashSet(userBeanList);
    }

利用TreeSet()来进行去重

    public static List<UserBean> handleSameElementByTreeSet(List<UserBean> userBeanList) {
        if (userBeanList.size() > 0 && userBeanList != null) {
            Set<UserBean> set = new TreeSet<>(new Comparator<UserBean>() {
                @Override
                public int compare(UserBean o1, UserBean o2) {
                    return o1.getName().compareTo(o2.getName());
                }
            });
            set.addAll(userBeanList);
            return new ArrayList<UserBean>(set);
        }
        return userBeanList;
    }
    
    public static void betaUniqueUserBean(){
        /** 第二种是使用treeSet来
         * 后面这两个都是使用保存第一个的方式*/
        List<UserBean>userBeanList=initUserBeanList();
        List<UserBean>uniqueUserBeanList=UniqueueList.handleSameElementByTreeSet(userBeanList);
        uniqueUserBeanList.forEach(System.out::println);
    }

第三种是使用stream来进行处理–有点难懂

    public static void gammaUniqueUserBean(){
        /**使用stream来进行解决*/
        List<UserBean>userBeanList=initUserBeanList();
        List<UserBean>uniqueUserBeanList=UniqueueList.handleSameElementByStream(userBeanList);
        uniqueUserBeanList.forEach(System.out::println);
    }
    public static List<UserBean> handleSameElementByStream(List<UserBean> userBeanList) {
        if (null == userBeanList || userBeanList.size() == 0) {
            return userBeanList;
        }
        List<UserBean> list = userBeanList.stream()
                .collect(Collectors.collectingAndThen(
                        Collectors.toCollection(
                                () -> new TreeSet<>(Comparator.comparing(UserBean::getName)))
                        , ArrayList::new));

        return list;
    }

对象的分组

根据对象的某一个属性对对象进行分组

    public static void listGroupedByStream(List<UserBean>userBeanList){
        Map<String,List<UserBean>> result= (Map<String, List<UserBean>>) userBeanList.stream()
                .filter(Objects::nonNull)
                .collect(Collectors.groupingBy(UserBean::getGrade));
        for(Map.Entry<String ,List<UserBean>> element:result.entrySet()){
            System.out.println(element);
        }
//        System.out.println(result);
    }
求均值
        Double aveResult;
        aveResult=userBeanList.stream().filter(Objects::nonNull)
                .mapToDouble(UserBean::getChineseScore).average()
                .orElseThrow(IllegalArgumentException::new);
        System.out.println(aveResult);
    }
muyuchenzi
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LINQ_TO_SQL_高级查询介绍
12-20
var q = db.Customers.OrderBy(c => c.City).ThenBy(c => c.ContactName).ToList(); ``` 需要注意的是，多个`OrderBy`操作的级联顺序是逆序的。如果需要降序，可以使用`OrderByDescending`和`ThenByDescending`。 ...
Python实现去除列表中重复元素的方法总结【7种方法】
09-19
定义一个布尔函数，通过`map`将该函数应用于列表，根据返回值筛选出不重复的元素。这种方法利用了字典来记录出现次数。 ```python def flagFunc(a): global count_dict if a in count_dict: count_dict[a] +=...
【Basic Code】对List进行筛选的几种方法
暂七师师长常乃超
10-20 4415
前提：        在项目中MVVM模式在前台View是直接和ViewModel当中的对象进行绑定，所以后台逻辑更多的将需要的数据以List的形式传递给ViewModel，期间大量的对List的筛选操作，做如下总结。  一、单值作为筛选条件，筛选集合：        1.where限定 var item = Mysql.From().Where(a => a.propert
统计List中不同元素的数量
Vamkit
05-12 1208
统计List中不同元素的数量，返回结果为元素：数量的Map。
list中通过Java 8 新特性查找重复的值
最新发布
一起记录GIS学习
04-11 646
【代码】list中通过Java 8 新特性查找重复的值。
c# 对List数据筛选
m0_55829199的博客
04-21 4447
主要用于两个list集合进行对比，老数据与新数据对比，两个集合存在同样的数据，但是新list集合存在的数据是老list不存在的，因此把新list中的数据剔除出来放入一个新的集合，对比数据的不同主要用集合中对象的属性进行对比，找出差集放入新的集合 ...
两个list如何根据一个list中的属性去过滤掉另一个list中不包含这部分的属性，java8流实现
qq_50523945的博客
12-14 3147
你可以使用Java 8的流来实现这个功能。假设你有两个包含对象的List，每个对象有一个属性，你想根据一个List中的属性值来过滤掉另一个List中不包含这个属性值的对象。下面是一种使用流的方式来实现这个功能在上面的例子中，我们有两个List：list1包含了MyClass对象，每个对象有一个属性property；list2包含了一些属性值。我们使用流来筛选list1中的对象，只保留那些property值在list2中存在的对象，最后将筛选后的结果收集到filteredList中。AB。
vue实现将一个数组内的相同数据进行合并
10-16
今天小编就为大家分享一篇vue实现将一个数组内的相同数据进行合并，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
java8使用Stream API方法总结
08-26
1. filter()：对 Stream 进行过滤，筛选出符合条件的元素 ```java Stream<String> stream = list.stream().filter((s) -> s.length() > 5); ``` 2. map()：对 Stream 进行映射，将每个元素转换为另一个对象 ```java ...
Python数据分析常用方法手册.pdf
10-30
- `isin()`函数：筛选指定列中值存在于给定列表中的行，如`df[df['column'].isin(list)]`。 - `query()`函数：基于表达式筛选数据，需要`numexpr`库支持，如`df.query('column == value')`。 - `str.contains()`...
JAVA8 List的去重、过滤、映射(map)、分组、统计(sum、max、min、avg)、分页
热门推荐
ACGkaka的博客
03-20 1万+
目录 1.实现List对象集合的简单去重（distinct()） 2.实现List集合的根据属性（name）去重 3.实现List对象集合的简单过滤（过滤为 null 的对象） 4.实现List对象集合中获取其中某一属性（weight）的List集合 5.实现List对象集合中根据对象（Apple）的某一属性（color）进行分组 6.实现List对象集合中求和、最大、最小、平均的统计...
java8 List 对象，根据属性筛选数据
橙子的博客
12-16 3985
java8 List 对象，根据属性筛选数据
Java8集合List 对数字排序、筛选、求和、求最大值、平均值
悟能的师兄的专栏
05-22 1万+
List过滤指定元素排序 其实很简单，可是CSDN或者其他网站上的作者都喜欢装逼，对Double、或者Integer的处理基本都是无。
如何实现集合的排序及取出重复元素 （小白都可以看懂的去重）
weixin_45924908的博客
12-22 366
在面试中遇到一道这样面试题，怎样将集合排序，并去掉重复元素？排序后一时想不到，查阅资料后写下代码，下面代码值演示如何去重。 方案一： // 通过最外层和最内层比较，去除重复元素 @Test public void test() { ArrayList<Object> list = new ArrayList<>(); list.add("1"); list....
【python】列表元素统计
贾继康的博客
12-05 6761
文章目录【python】列表元素统计一、原始数据长的样子二、方法一：使用标准 Python库三、方法二：使用pandas 【python】列表元素统计 一、原始数据长的样子 目标： 对list中的数据进行统计（其实就是对相同元素的数据进行一个统计） 方法： 方法一： 使用标准 Python库 方法二： 使用 pandas 二、方法一：使用标准 Python库 def get_counts(sequence): counts = {} for x in sequence:
List<T>的排序和筛选
weixin_30325793的博客
01-25 213
http://www.cnblogs.com/supperwu/archive/2012/06/13/2548122.html #region 筛选方法 （目前方法3最实用，其他方法待调查） List<m_Cutlerys_deatail&g...
list重复数据筛选
09-12
要筛选list中的重复数据，可以使用以下方法： 首先，创建一个空的List来存放重复的...可以使用Java 8的新特性，例如使用Stream API和Lambda表达式来实现对list的排序和去重，具体的方法可以参考Java 8的文档和教程 。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值