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 }
标签：java,List,1.8,System,特性,println,import,out 来源： https://www.cnblogs.com/lixiuming521125/p/16434077.html