1.8新特性List

JAVA8新特性之List的各种用法（最大、最小、平均值、分组、求和、遍历、过滤、排序、去重、获取List中单个字段集合、List转map）

User实体类：

package com.mock.utils;

import java.math.BigDecimal;
import java.util.Date;

public class User {

    /**
     * ID
     */
    private Long id;
    /**
     * 用户名
     */
    private String name;
    /**
     * 年龄
     */
    private int age;
    /**
     * 工号
     */
    private String jobNumber;
    /**
     * 性别
     */
    private String sex;
    /**
     * 注册时间
     */
    private Date entryDate;
    /**
     * 成员组织
     */
    private BigDecimal familyMemberQuantity;

    private Long userId;

    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 int getAge() {
        return age;
    }

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

    public String getJobNumber() {
        return jobNumber;
    }

    public void setJobNumber(String jobNumber) {
        this.jobNumber = jobNumber;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getEntryDate() {
        return entryDate;
    }

    public void setEntryDate(Date entryDate) {
        this.entryDate = entryDate;
    }

    public BigDecimal getFamilyMemberQuantity() {
        return familyMemberQuantity;
    }

    public void setFamilyMemberQuantity(BigDecimal familyMemberQuantity) {
        this.familyMemberQuantity = familyMemberQuantity;
    }

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", age=" + age + ", jobNumber=" + jobNumber + ", sex=" + sex
                + ", entryDate=" + entryDate + ", familyMemberQuantity=" + familyMemberQuantity + ", userId=" + userId
                + "]";
    }
}

View Code

最大、最小、平均值、求和

  1 package com.mock.utils;
  2 
  3 import java.math.BigDecimal;
  4 import java.util.ArrayList;
  5 import java.util.Comparator;
  6 import java.util.Date;
  7 import java.util.List;
  8 import java.util.Random;
  9 
 10 import org.junit.Test;
 11 
 12 public class TestList {
 13     /**
 14      * 生产虚拟用户
 15      *
 16      * @return
 17      */
 18     public static List<User> produceUser() {
 19         List<User> UserList = new ArrayList<>();
 20         for (int i = 1; i <= 10; i++) {
 21             User User = new User();
 22             User.setId(Long.valueOf(i));
 23             User.setName("kobe" + i);
 24             User.setAge(15 + new Random().nextInt(5));
 25             User.setJobNumber("jobNumber" + i);
 26             if (i % 2 == 0) {
 27                 User.setSex("男");
 28             } else {
 29                 User.setSex("女");
 30             }
 31             User.setEntryDate(new Date());
 32             User.setFamilyMemberQuantity(new BigDecimal(i));
 33             UserList.add(User);
 34         }
 35         return UserList;
 36     }
 37 
 38     /**
 39      * 根据年龄字段求总和
 40      */
 41     @Test
 42     public void getSumByStream() {
 43         List<User> list = produceUser();
 44         int sum = list.stream().mapToInt(User::getAge).sum();
 45         System.out.println("共计:" + list.size() + "个用户,所有年龄总和为:" + sum);
 46         // 求最大年龄
 47         Integer integer = list.stream().map(User::getAge).max(Integer::compareTo).get();
 48         System.out.println(integer);
 49         // 得到最大年龄对象
 50         User user = list.stream().max(Comparator.comparingInt(User::getAge)).get();
 51         System.out.println(user);
 52         // 求平均年龄
 53         System.out.println(list.stream().mapToInt(User::getAge).average().getAsDouble());
 54         // 求最大年龄
 55         System.out.println(list.stream().mapToInt(User::getAge).max().getAsInt());
 56     }
 57 
 58     /**
 59      * 根据List求和
 60      */
 61     @Test
 62     public void getListSumByJava8() {
 63         List<Integer> listInt = new ArrayList<>();
 64         List<Double> listDoub = new ArrayList<>();
 65         for (int i = 0; i < 500; i++) {
 66             listInt.add(new Random().nextInt(1000));
 67             listDoub.add(new Random().nextDouble());
 68         }
 69         System.out.println("=======数值型Integer求和======");
 70         Integer integer = listInt.stream().reduce(Integer::sum).orElse(0);
 71         System.out.println(integer);
 72         System.out.println("=======数值型Double求和======");
 73         Double integer1 = listDoub.stream().reduce(Double::sum).orElse(0.00);
 74         System.out.println(integer1);
 75         // 取最大值
 76         System.out.println(listInt.stream().reduce(Integer::max).orElse(0));
 77         System.out.println(listInt.stream().mapToInt(Integer::valueOf).max().getAsInt());
 78         // 取最小值
 79         System.out.println(listInt.stream().reduce(Integer::min).orElse(0));
 80         // 取平均值
 81         System.out.println(listInt.stream().mapToInt(Integer::valueOf).average().getAsDouble());
 82     }
 83 
 84     /**
 85      * 求最大最小值,根据业务类型选择合适的类型值
 86      */
 87     @Test
 88     public void maxOrMinByJava8() {
 89         List<User> list = produceUser();
 90         // 根据mapTO**得到最大最小 ---写法一
 91         double asDouble = list.stream().mapToDouble(User::getAge).max().getAsDouble();
 92         System.out.println("将最大值转换为Double类型进行展示,最大为:" + asDouble);
 93         double asDouble1 = list.stream().mapToDouble(User::getAge).min().getAsDouble();
 94         System.out.println("将最小值转换为Double类型进行展示,最小为:" + asDouble1);
 95         int asInt = list.stream().mapToInt(User::getAge).max().getAsInt();
 96         System.out.println("将最大值转换为Int类型进行展示,最大为:" + asInt);
 97         // 根据map得到最大最小 ---写法二(推荐)
 98         Integer integer = list.stream().map(User::getAge).max(Integer::compareTo).get();
 99         System.out.println("将最大值转换为字段对应类型进行展示,最大为:" + integer);
100         Integer integer1 = list.stream().map(User::getAge).min(Integer::compareTo).get();
101         System.out.println("将最小值转换为字段对应类型进行展示,最小为:" + integer1);
102     }
103 
104     /**
105      * 求最大最小值,根据业务类型选择合适的类型值
106      */
107     @Test
108     public void avgByJava8() {
109         List<User> list = produceUser();
110         double avgAge = list.stream().mapToDouble(User::getAge).average().getAsDouble();
111         System.out.println("平均年龄为:" + avgAge);
112     }
113 
114 }

分组：

 1 package com.mock.utils;
 2 
 3 import java.math.BigDecimal;
 4 import java.util.ArrayList;
 5 import java.util.Date;
 6 import java.util.List;
 7 import java.util.Map;
 8 import java.util.Random;
 9 import java.util.Set;
10 import java.util.stream.Collectors;
11 
12 import org.junit.Test;
13 
14 public class TestList {
15     /**
16      * 生产虚拟用户
17      *
18      * @return
19      */
20     public static List<User> produceUser() {
21         List<User> UserList = new ArrayList<>();
22         for (int i = 1; i <= 10; i++) {
23             User User = new User();
24             User.setId(Long.valueOf(i));
25             User.setName("kobe" + i);
26             User.setAge(15 + new Random().nextInt(5));
27             User.setJobNumber("jobNumber" + i);
28             if (i % 2 == 0) {
29                 User.setSex("男");
30             } else {
31                 User.setSex("女");
32             }
33             User.setEntryDate(new Date());
34             User.setFamilyMemberQuantity(new BigDecimal(i));
35             UserList.add(User);
36         }
37         return UserList;
38     }
39 
40     /**
41      * 分组
42      */
43     @Test
44     public void groupByGender() {
45         List<User> list = produceUser();
46         // 根据性别进行分组
47         Map<String, List<User>> collect = list.stream().collect(Collectors.groupingBy(User::getSex));
48         Set<Map.Entry<String, List<User>>> entries = collect.entrySet();
49         entries.forEach(item -> {
50             // 性别 男 / 女
51             String gender = item.getKey();
52             // 男集合 / 女集合
53             List<User> UserList = item.getValue();
54             System.out.println(gender);
55             UserList.forEach(user -> System.out.println(user));
56         });
57     }
58 }

过滤

 1 package com.mock.utils;
 2 
 3 import java.math.BigDecimal;
 4 import java.util.ArrayList;
 5 import java.util.Date;
 6 import java.util.List;
 7 import java.util.Random;
 8 import java.util.stream.Collectors;
 9 
10 import org.junit.Test;
11 
12 public class TestList {
13     /**
14      * 生产虚拟用户
15      *
16      * @return
17      */
18     public static List<User> produceUser() {
19         List<User> UserList = new ArrayList<>();
20         for (int i = 1; i <= 10; i++) {
21             User User = new User();
22             User.setId(Long.valueOf(i));
23             User.setName("kobe" + i);
24             User.setAge(15 + new Random().nextInt(5));
25             User.setJobNumber("jobNumber" + i);
26             if (i % 2 == 0) {
27                 User.setSex("男");
28             } else {
29                 User.setSex("女");
30             }
31             User.setEntryDate(new Date());
32             User.setFamilyMemberQuantity(new BigDecimal(i));
33             UserList.add(User);
34         }
35         return UserList;
36     }
37 
38     /**
39      * 过滤对象
40      */
41     @Test
42     public void filterByJava8() {
43         List<User> list = produceUser();
44         System.out.println("原始数据为:");
45         System.out.println("==============过滤前的数据为===============");
46         list.forEach(System.out::println);
47         // 筛选出年龄大于13岁小于18岁的对象
48         List<User> collect = list.stream().filter(s -> s.getAge() > 13 && s.getAge() < 18).collect(Collectors.toList());
49         System.out.println("过滤结束后的数据为:");
50         collect.forEach(System.out::println);
51     }
52 }

排序：

 1 package com.mock.utils;
 2 
 3 import java.math.BigDecimal;
 4 import java.util.ArrayList;
 5 import java.util.Comparator;
 6 import java.util.Date;
 7 import java.util.List;
 8 import java.util.Random;
 9 
10 import org.junit.Test;
11 
12 public class TestList {
13     /**
14      * 生产虚拟用户
15      *
16      * @return
17      */
18     public static List<User> produceUser() {
19         List<User> UserList = new ArrayList<>();
20         for (int i = 1; i <= 10; i++) {
21             User User = new User();
22             User.setId(Long.valueOf(i));
23             User.setName("kobe" + i);
24             User.setAge(15 + new Random().nextInt(5));
25             User.setJobNumber("jobNumber" + i);
26             if (i % 2 == 0) {
27                 User.setSex("男");
28             } else {
29                 User.setSex("女");
30             }
31             User.setEntryDate(new Date());
32             User.setFamilyMemberQuantity(new BigDecimal(i));
33             UserList.add(User);
34         }
35         return UserList;
36     }
37 
38     /**
39      * 排序(单字段/多字段排序)
40      */
41     @Test
42     public void sortByJava8() {
43         List<User> list = produceUser();
44         System.out.println("============未排序的数据=============");
45         list.forEach(System.out::println);
46         try {
47             // 单字段排序，根据名字排序
48             System.out.println("============单字段排序，根据年龄排序 从小到大=============");
49             list.sort(Comparator.comparing(User::getAge));
50             list.forEach(System.out::println);
51             System.out.println("============单字段排序，根据年龄排序 从大到小=============");
52             list.sort(Comparator.comparing(User::getAge).reversed());
53             list.forEach(System.out::println);
54             // 多字段排序,根据年龄再根据-->名字排序
55             System.out.println("============多字段排序,根据年龄再根据-->名字排序 年龄从小到大=============");
56             list.sort(Comparator.comparing(User::getAge, (o1, o2) -> o1 - o2).thenComparing(User::getName));
57             list.forEach(System.out::println);
58             System.out.println("============多字段排序,根据年龄再根据-->名字排序 年龄从大到小=============");
59             list.sort(Comparator.comparing(User::getAge, (o1, o2) -> o2 - o1).thenComparing(User::getName));
60             list.forEach(System.out::println);
61         } catch (Exception e) {
62             e.printStackTrace();
63         }
64     }
65 }

去重：

 1   /**
 2      * 去重
 3      */
 4     @Test
 5     public void distinctByJava8() {
 6         List<String> numList = new ArrayList<>();
 7         numList.add("kevin");
 8         numList.add("kevin");
 9         numList.add("kevin1");
10         numList.add("kevin2");
11         numList.add("kevin1");
12         numList.add("kevin2");
13         System.out.println("===========未去重的数据============");
14         System.out.println(numList.toString());
15         System.out.println("===========去重后的数据============");
16         List<String> collect = numList.stream().distinct().collect(Collectors.toList());
17         System.out.println(collect.toString());
18     }

得到两个集合的交集：

 1  @Test
 2     public void listBingByJava8() {
 3         System.out.println("==========交集: 集合A {1,2,3} 和集合B {2,3,4} 的交集为 {2,3}。即{1,2,3}∩{2,3,4}={2,3}==========");
 4         List<String> list1 = new ArrayList<>();
 5         list1.add("aaa");
 6         list1.add("bbb");
 7         list1.add("ccc");
 8         list1.add("aaa1");
 9         System.out.println("list1:");
10         list1.forEach(System.out::println);
11         List<String> list2 = new ArrayList<>();
12         list2.add("ddd");
13         list2.add("aaa");
14         list2.add("eee");
15         list2.add("ccc");
16         list2.add("fff");
17         list2.add("aaa1");
18         list2.add("aaa2");
19         System.out.println("list2:");
20         list2.forEach(System.out::println);
21         // 合并List
22         List<String> collect = list1.stream().filter(s -> list2.contains(s)).collect(Collectors.toList());
23         System.out.println("============交集元数据===========");
24         System.out.println(collect);
25         // 获得元素出现频率的 Map，键为元素，值为元素出现的次数
26         System.out.println("============List1中添加List2===========");
27         list1.addAll(list2);
28         list1.forEach(System.out::println);
29         List<String> collect1 = list1.stream().collect(Collectors.toMap(a -> a, a -> 1, (a, b) -> a + b))
30                 // Set<Entry>转换为Stream<Entry>
31                 .entrySet().stream()
32                 // 过滤出元素出现次数大于 0 的 entry
33                 .filter(entry -> entry.getValue() > 1)
34                 // 获得 entry 的键（重复元素）对应的 Stream
35                 .map(entry -> entry.getKey())
36                 // 转化为 List并去重
37                 .distinct().collect(Collectors.toList());
38         System.out.println("========合并后得到处理得到重复的数据========");
39         System.out.println(collect1);
40     }

List转map:

 1 package com.mock.utils;
 2 
 3 import java.math.BigDecimal;
 4 import java.util.ArrayList;
 5 import java.util.Date;
 6 import java.util.List;
 7 import java.util.Map;
 8 import java.util.Optional;
 9 import java.util.Random;
10 import java.util.stream.Collectors;
11 
12 import org.junit.Test;
13 
14 public class TestList {
15     /**
16      * 生产虚拟用户
17      *
18      * @return
19      */
20     public static List<User> produceUser() {
21         List<User> UserList = new ArrayList<>();
22         for (int i = 1; i <= 10; i++) {
23             User User = new User();
24             User.setId(Long.valueOf(i));
25             User.setName("kobe" + i);
26             User.setAge(15 + new Random().nextInt(5));
27             User.setJobNumber("jobNumber" + i);
28             if (i % 2 == 0) {
29                 User.setSex("男");
30             } else {
31                 User.setSex("女");
32             }
33             User.setEntryDate(new Date());
34             User.setFamilyMemberQuantity(new BigDecimal(i));
35             UserList.add(User);
36         }
37         return UserList;
38     }
39 
40     /**
41      * List -> Map <br>
42      * 需要注意的是： toMap 如果集合对象有重复的key，会报错Duplicate key .... user1,user2的id都为1。 <br>
43      * 可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
44      */
45     @Test
46     public void mapToListByJava8() {
47         List<User> list = produceUser();
48         Map<Long, User> map = list.stream().collect(Collectors.toMap(User::getId, a -> a, (k1, k2) -> k1));
49         for (Map.Entry<Long, User> entry : map.entrySet()) {
50             Long key = entry.getKey();
51             System.out.println("map中的key是:" + key);
52             System.out.println("map中的value是:" + entry.getValue().toString());
53         }
54 
55         // 根据ID和年龄获得map
56         Map<Long, Integer> collect = list.stream().collect(
57                 Collectors.toMap(User::getId, item -> Optional.ofNullable(item.getAge()).orElse(0), (k1, k2) -> k1));
58         System.out.println(collect.toString());
59     }
60 
61 }

获取List中单个字段集合

 1 package com.mock.utils;
 2 
 3 import java.math.BigDecimal;
 4 import java.util.ArrayList;
 5 import java.util.Date;
 6 import java.util.List;
 7 import java.util.Random;
 8 import java.util.stream.Collectors;
 9 
10 import org.junit.Test;
11 
12 public class TestList {
13     /**
14      * 生产虚拟用户
15      *
16      * @return
17      */
18     public static List<User> produceUser() {
19         List<User> UserList = new ArrayList<>();
20         for (int i = 1; i <= 10; i++) {
21             User User = new User();
22             User.setId(Long.valueOf(i));
23             User.setName("kobe" + i);
24             User.setAge(15 + new Random().nextInt(5));
25             User.setJobNumber("jobNumber" + i);
26             if (i % 2 == 0) {
27                 User.setSex("男");
28             } else {
29                 User.setSex("女");
30             }
31             User.setEntryDate(new Date());
32             User.setFamilyMemberQuantity(new BigDecimal(i));
33             UserList.add(User);
34         }
35         return UserList;
36     }
37 
38     /**
39      * 获取单个字段集合
40      */
41     @Test
42     public void getSingleField() {
43         List<User> list = produceUser();
44         List<String> nameList = list.stream().map(User::getName).collect(Collectors.toList());
45         nameList.forEach(System.out::println);
46         List<Integer> ageList = list.stream().map(User::getAge).collect(Collectors.toList());
47         ageList.forEach(System.out::println);
48     }
49 
50 }

相关阅读:
[转]VS2010几款超赞的扩展辅助工具总结
 从客户端中检测到有潜在危险的Request.Form 值
 面试系列28 分布式服务接口的幂等性如何设计
 面试系列26 如何基于dubbo进行服务治理、服务降级、失败重试以及超时重试
 面试系列25 dubbo的spi思想是什么
 面试系列24 dubbo负载均衡策略和集群容错策略
 面试系列23
面试系列22 dubbo的工作原理
 面试系列21 为什么要进行系统拆分
 面试系列20 生产环境中的redis是怎么部署的
原文地址：https://www.cnblogs.com/lixiuming521125/p/16434077.html