forEach() 集合循环
一般循环体
List<String> list = Arrays.asList("A", "B", "C", "D", "E", "F");
boolean flag = false;
for (String str : list) {
if(str.equals("C")){
flag = true;
}
}lambda表达式循环体
List<String> list = Arrays.asList("A", "B", "C", "D", "E", "F");
boolean flag = false;
list.forEach(str->{
if(str.equals("C")){
flag = true;
}
});
结果：会有语法错误
variable used in lambda expression should be final or effectively final
lambda表达式中使用的变量应该是final或final
原因我就不解释了，有需要可自行查
List<String> list = Arrays.asList("A", "B", "C", "D", "E", "F");
list.forEach(str->{
boolean flag = false;
if(str.equals("C")){
flag = true;
}
});
可改成这样的写法，如果业务逻辑需要变量必须放在循环体外面，那就建议用常规循环体filter() 设置过滤条件
List<String> strs = Arrays.asList("abc", "", "bc", "efg", "abcd",null, "jkl");
long count = strs .stream()
.filter(str-> str==null || str.isEmpty())//根据业务添加自己的过滤条件
.count();//统计数量
System.out.println("空字符串数量为: " + count);
//Collector作为collect方法的参数,Collector是一个接口，它是一个可变的汇聚操作，将输入元素累积到一个可变的结果容器中；它会在所有元素都处理完毕后，将累积的结果转换为一个最终的表示（这是一个可选操作）；它支持串行与并行两种方式执行。
List<String> filterList = strs.stream()
.filter(str -> str!=null && !str.isEmpty())//根据业务添加自己的过滤条件
.collect(Collectors.toList());//collect()是结果收集器
System.out.println("筛选后不为空的列表: " + filterList);
String mergedString = strs.stream()
.filter(str -> str!=null && !str.isEmpty())
.collect(Collectors.joining(", "));//将符合条件的结果集合，用逗号拼接成一个字符串
System.out.println("筛选后不为空的列表-合并字符串: " + mergedString);统计
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());
执行结果：
列表中最大的数 : 7
列表中最小的数 : 2
所有数之和 : 25
平均数 : 3.5714285714285716sorted() 排序
需要一个User实体类
public class User{
private Integer id;
private String name;
private String phone;
private Integer age;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public User(Integer id, String name, String phone, Integer age) {
this.id = id;
this.name = name;
this.phone = phone;
this.age = age;
}
}public static void main(String[] args) {
//数组排序
List<Integer> list = Arrays.asList(3, 2, 2, 4, 7, 3, 5);
List<Integer> sortList1 = list.stream().sorted().collect(Collectors.toList());
System.out.println("升序排序："+sortList1);//升序排序：[2, 2, 3, 3, 4, 5, 7]
List<Integer> sortList2 = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
System.out.println("降序排序："+sortList2);//降序排序：[7, 5, 4, 3, 3, 2, 2]
//对象根据单个字段排序
List<User> userList = Arrays.asList(
new User(1,"张三","15614456733",23),
new User(2,"李四","15877776733",43),
new User(3,"王五","15614457777",48),
new User(4,"赵六","15614457777",48)
);
List<User> sortList3 = userList.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());
//根据年龄升序排序：张三、李四、王五、赵六、
System.out.println("根据年龄升序排序：");
sortList3.forEach(sort->{
System.out.print(sort.getName()+"、");
});
List<User> sortList4 = userList.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());
//根据年龄降序排序1：王五、赵六、李四、张三、
System.out.println("\n根据年龄降序排序1：");
sortList4.forEach(sort->{
System.out.print(sort.getName()+"、");
});
List<User> sortList5 = userList.stream().sorted(Comparator.comparing(User::getAge,Comparator.reverseOrder())).collect(Collectors.toList());
//根据年龄降序排序2：王五、赵六、李四、张三、
System.out.println("\n根据年龄降序排序2：");
sortList5.forEach(sort->{
System.out.print(sort.getName()+"、");
});
//对象根据多个字段排序
List<User> sortList6 = userList.stream().sorted(Comparator.comparing(User::getAge,Comparator.reverseOrder()).thenComparing(User::getId,Comparator.reverseOrder())).collect(Collectors.toList());
//根据年龄降序排序，年龄相同的情况根据id降序排序：赵六、王五、李四、张三、
System.out.println("\n根据年龄降序排序，年龄相同的情况根据id降序排序1：");
sortList6.forEach(sort->{
System.out.print(sort.getName()+"、");
});
List<User> sortList7 = userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getId).reversed()).collect(Collectors.toList());
//根据年龄降序排序，年龄相同的情况根据id降序排序：张三、李四、赵六、王五、
//**注意**，此结果是错误
System.out.println("\n根据年龄降序排序，年龄相同的情况根据id降序排序2：");
sortList7.forEach(sort->{
System.out.print(sort.getName()+"、");
});
//通过以上例子我们可以发现,两种排序是完全不一样的，而且多个字段排序的时候，使用reversed()方法会出现问题，所以建议使用Comparator.reverseOrder()
//Comparator.comparing(类::属性一).reversed();//得到排序结果后再排序
//Comparator.comparing(类::属性一,Comparator.reverseOrder());//直接进行排序
}map()方法
map 方法用于映射每个元素到对应的结果：将对象转换为其他对象
需要引入的import：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public static void main(String[] args) {
List<String> list = Arrays.asList("a", "c", "e", "a", "f", "b", "d");
//将list集合去重后组成一个新的集合
List<String> mapList1 = list.stream().map(x -> x).distinct().collect(Collectors.toList());
System.out.println("list去重结果：" + mapList1);
//将list集合转成大写字母后组成新的集合
List<String> mapList2 = list.stream().map(String::toUpperCase).distinct().collect(Collectors.toList());
System.out.println("list转大写结果：" + mapList2);
//将list集合追加字符串后组成新的集合
List<String> mapList3 = list.stream().map(str -> str + "-").collect(Collectors.toList());
System.out.println("list元素追加字符串：" + mapList3);
List<User> userList = Arrays.asList(
new User(1, "张三", "15614456733", 23),
new User(2, "李四", "15877776733", 43),
new User(3, "王五", "15614457777", 48),
new User(4, "赵六", "15614457777", 48),
new User(5, "admin", "15614457777", 48)
);
//将userList集合中的姓名组成新的集合---2种写法
List<String> mapList4 = userList.stream().map(str -> str.getName()).collect(Collectors.toList());
System.out.println("userList集合姓名：" + mapList4);
List<String> mapList5 = userList.stream().map(User::getName).collect(Collectors.toList());
System.out.println("userList集合姓名：" + mapList5);
//将userList集合转成其他对象集合
List<Dept> deptList1 = userList.stream().map(user ->{
Dept dept = new Dept();
dept.setUserName(user.getName());
dept.setUserId(user.getId());
if(user.getId().equals(5)){
dept.setRemark("管理员");
}else{
dept.setRemark("员工");
}
return dept;
}).collect(Collectors.toList());
System.out.println("dept集合1：" + JSON.toJSON(deptList1));
//上面方法替代了传统的写法，简化了代码
List<Dept> deptList2 = new ArrayList<>();
for (User user : userList) {
Dept dept = new Dept();
dept.setUserName(user.getName());
dept.setUserId(user.getId());
if(user.getId().equals(5)){
dept.setRemark("管理员");
}else{
dept.setRemark("员工");
}
deptList2.add(dept);
}
System.out.println("dept集合2：" + JSON.toJSON(deptList2));
}
执行结果：
list去重结果：[a, c, e, f, b, d]
list转大写结果：[A, C, E, F, B, D]
list元素追加字符串：[a-, c-, e-, a-, f-, b-, d-]
userList集合姓名：[张三, 李四, 王五, 赵六, admin]
userList集合姓名：[张三, 李四, 王五, 赵六, admin]
dept集合1：[{"remark":"员工","userName":"张三","userId":1},{"remark":"员工","userName":"李四","userId":2},{"remark":"员工","userName":"王五","userId":3},{"remark":"员工","userName":"赵六","userId":4},{"remark":"管理员","userName":"admin","userId":5}]
dept集合2：[{"remark":"员工","userName":"张三","userId":1},{"remark":"员工","userName":"李四","userId":2},{"remark":"员工","userName":"王五","userId":3},{"remark":"员工","userName":"赵六","userId":4},{"remark":"管理员","userName":"admin","userId":5}]
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
