Java使用Lambda表达式查找list集合中是否包含某值问题
更新时间：2023年06月01日 15:45:25 作者：张蛋腚
Java使用Lambda表达式查找list集合中是否包含某值的问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
使用Lambda表达式查找list集合中是否包含某值
for (String className : allClassName) {
if (!classDetailList.stream().filter(o -> ToolUtil.equals(o.getClassName(), className)).findFirst().isPresent()) {
classDetailList.add(new AftersaleStatisticDTO().setClassName(className));
} }lambda表达式对List的常见操作记录
List转Map
@Data
class Person {
private String uuid;
private String name;
private String gender;
private int age;
public Person(String name, String gender, int age) {
this.uuid = UUID.randomUUID().toString();
this.name = name;
this.gender = gender;
this.age = age;
}
}List<Person> persons = new ArrayList<>();
persons.add(new Person("张三", "男", 27));
persons.add(new Person("李四", "男", 14));
persons.add(new Person("王五", "女", 17));
persons.add(new Person("赵六", "女", 34));分组
Map<Boolean, List<Person>> personsByAge = persons.stream() .collect(Collectors.partitioningBy(p -> p.getAge() > 18)); System.out.println(JSON.toJSONString(personsByAge));
Map<String, List<Person>> personByGender = persons.stream() .collect(Collectors.groupingBy(Person::getGender)); System.out.println(JSON.toJSONString(personByGender));
自定义Map
Map<String, String> uuidNameMap = persons.stream() .collect(Collectors.toMap(Person::getUuid, Person::getName)); System.out.println(JSON.toJSONString(uuidNameMap));
实际情况有可能同一个key会对应多个value，就有可能抛Duplicate key异常。这时可以传入第三个参数决定重复时如何选择，比如我们想构造<name, uuid>的映射，但是考虑可能有重名的可能，就可以这么做：
Map<String, String> nameUuidMap = persons.stream() .collect(Collectors.toMap(Person::getName, Person::getUuid, (p1, p2) -> p1)); System.out.println(JSON.toJSONString(nameUuidMap));
这里(p1, p2) -> p1表示如果重复则取前者。
常用循环
常规循环
public class CollectionEach {
public static void main(String[] args) {
// 创建一个集合
Collection objs = new HashSet();
objs.add("C语言中文网Java教程");
objs.add("C语言中文网C语言教程");
objs.add("C语言中文网C++教程");
// 调用forEach()方法遍历集合
objs.forEach(obj -> System.out.println("迭代集合元素：" + obj));
}
}单属性提取集合
List<BuyProduction> productions List<Long> list = productions.stream().map(BuyProduction::getProductionId).collect(Collectors.toList());
排序
求最大值或最小值
class Stu{
private String str;
public Stu(String str) {
this.str = str;
}
public void setStr(String str) {
this.str = str;
}
public String getStr() {
return str;
}
}
public static void main(String[] args) {
List<Stu> dateList = new ArrayList<>();
dateList.add(new Stu("2022-02-15"));
dateList.add(new Stu("2021-12-25"));
dateList.add(new Stu("2024-02-15"));
dateList.add(new Stu("2023-02-15"));
Stu minStu = dateList.stream().min(Comparator.comparing(Stu::getStr)).get();
Stu maxStu = dateList.stream().max(Comparator.comparing(Stu::getStr)).get();
System.out.println("maxStu = " + maxStu.getStr());
System.out.println("minStu = " + minStu.getStr());
}import java.util.*;
public class Demo{
public static void main(String[] args){
ArrayList<Integer> my_arr = new ArrayList<Integer>();
my_arr.add(190);
my_arr.add(267);
my_arr.add(12);
my_arr.add(0);
System.out.println("排序之前，数组列表中的元素是 : " + my_arr);
Collections.sort(my_arr, (o1, o2) -> (o1 > o2) ? -1 : (o1 < o2) ? 1 : 0);
System.out.println("排序后，数组列表中的元素是 : " + my_arr);
}
}树形结构排序
import java.util.*;
public class Demo{
public static void main(String[] args){
TreeMap<Integer, String> my_treemap = new TreeMap<Integer, String>((o1, o2) -> (o1 > o2) ? -1 : (o1 < o2) ? 1 : 0);
my_treemap.put(56, "Joe");
my_treemap.put(43, "Bill");
my_treemap.put(21, "Charolette");
my_treemap.put(33, "Jonas");
System.out.println("treemap包含以下元素: " + my_treemap);
}
}其他排序
public class Demo01 {
public static void main(String[] args) {
// 定义字符串数组
String[] strArr = { "abc", "cd", "abce", "a" };
// 传统方法
// 匿名内部类
Arrays.sort(strArr, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return Integer.compare(s2.length(), s1.length());
}
});
// 输出排序结果
for (String s : strArr) {
System.out.println(s);
}
System.out.println("---------------------");
// Lambda表达式
Arrays.sort(strArr, (s1, s2) -> Integer.compare(s2.length(), s1.length()));
// 输出
for (String s : strArr) {
System.out.println(s);
}遍历
常规遍历
for (Hero h : heros) {
if (h.hp > 100 && h.damage < 50)
System.out.println(h.name);
}聚合遍历
heros .stream() .filter(h -> h.hp > 100 && h.damage < 50) .forEach(h -> System.out.println(h.name));
对元素进行筛选：
- filter 匹配
- distinct 去除重复(根据equals判断)
- sorted 自然排序
- sorted(Comparator) 指定排序
- limit 保留
- skip 忽略
转换为其他形式的流：
- mapToDouble 转换为double的流
- map 转换为任意类型的流
public class Hero implements Comparable<Hero>{
public String name;
public float hp;
public int damage;
public Hero(){
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getHp() {
return hp;
}
public void setHp(float hp) {
this.hp = hp;
}
public int getDamage() {
return damage;
}
public void setDamage(int damage) {
this.damage = damage;
}
public Hero(String name) {
this.name =name;
}
//初始化name,hp,damage的构造方法
public Hero(String name,float hp, int damage) {
this.name =name;
this.hp = hp;
this.damage = damage;
}
@Override
public int compareTo(Hero anotherHero) {
if(damage<anotherHero.damage)
return 1;
else
return -1;
}
@Override
public String toString() {
return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "]rn";
}
}
package lambda;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import charactor.Hero;
public class TestAggregate {
public static void main(String[] args) {
Random r = new Random();
List<Hero> heros = new ArrayList<Hero>();
for (int i = 0; i < 5; i++) {
heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
}
//制造一个重复数据
heros.add(heros.get(0));
System.out.println("初始化集合后的数据 (最后一个数据重复)：");
System.out.println(heros);
System.out.println("满足条件hp>100&&damage<50的数据");
heros
.stream()
.filter(h->h.hp>100&&h.damage<50)
.forEach(h->System.out.print(h));
System.out.println("去除重复的数据，去除标准是看equals");
heros
.stream()
.distinct()
.forEach(h->System.out.print(h));
System.out.println("按照血量排序");
heros
.stream()
.sorted((h1,h2)->h1.hp>=h2.hp?1:-1)
.forEach(h->System.out.print(h));
System.out.println("保留3个");
heros
.stream()
.limit(3)
.forEach(h->System.out.print(h));
System.out.println("忽略前3个");
heros
.stream()
.skip(3)
.forEach(h->System.out.print(h));
System.out.println("转换为double的Stream");
heros
.stream()
.mapToDouble(Hero::getHp)
.forEach(h->System.out.println(h));
System.out.println("转换任意类型的Stream");
heros
.stream()
.map((h)-> h.name + " - " + h.hp + " - " + h.damage)
.forEach(h->System.out.println(h));
}
}结束操作
forEach()遍历每个元素toArray()转换为数组min(Comparator)取最小的元素max(Comparator)取最大的元素count()总数findFirst()第一个元素
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import org.omg.Messaging.SYNC_WITH_TRANSPORT;
import charactor.Hero;
public class TestAggregate {
public static void main(String[] args) {
Random r = new Random();
List<Hero> heros = new ArrayList<Hero>();
for (int i = 0; i < 5; i++) {
heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
}
System.out.println("遍历集合中的每个数据");
heros
.stream()
.forEach(h->System.out.print(h));
System.out.println("返回一个数组");
Object[] hs= heros
.stream()
.toArray();
System.out.println(Arrays.toString(hs));
System.out.println("返回伤害最低的那个英雄");
Hero minDamageHero =
heros
.stream()
.min((h1,h2)->h1.damage-h2.damage)
.get();
System.out.print(minDamageHero);
System.out.println("返回伤害最高的那个英雄");
Hero mxnDamageHero =
heros
.stream()
.max((h1,h2)->h1.damage-h2.damage)
.get();
System.out.print(mxnDamageHero);
System.out.println("流中数据的总数");
long count = heros
.stream()
.count();
System.out.println(count);
System.out.println("第一个英雄");
Hero firstHero =
heros
.stream()
.findFirst()
.get();
System.out.println(firstHero);
}
}去重
//按学生姓名去重 //可能会改变原有list的顺序 List<Student> list = studentList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Student::getName))), ArrayList::new)); //直接去重 List<String> l = new ArryList(); List<String> list = l.stream().distinct().collect(Collectors.toList());
过滤
//按学生姓名过滤 List<Student> list = studentList.stream().filter(item -> "张三".equals(item.getName())).collect(Collectors.toList());
抽取
//按学生姓名抽取形成新对象Person
List<Person> personList = studentList.stream().map(s->{
Person person = new Person();
person .setName(s.getName());
return person ;
}).collect(Collectors.toList());
//按学生id抽取形成map集合
Map<Long, Person> personMap = studentList.stream().collect(Collectors.toMap(s -> s.getId(), s -> s));
//按学生id抽取形成map集合，取第一个
Map<Long, Person> personMap = studentList.stream().collect(Collectors.toMap(s -> s.getId(), s -> s,(first,last)->first));
//按学生id抽取形成set集合
Set<Long> idSet = studentList.stream().map(s-> s.getId()).collect(Collectors.toSet());计数
Map<String, Long> map = students.stream().collect(Collectors.groupingBy(Student::getName, Collectors.counting()));
最值
//最小 Integer min = studentList.stream().map(Student::getAge).min(Student::compareTo).get(); //最大 Integer max = studentList.stream().map(Student::getAge).max(Student::compareTo).get(); // 最大对象 User max = userList.stream().max(Comparator.comparing(Student::getAge)).get(); // 最小对象 User min = userList.stream().min(Comparator.comparing(Student::getAge)).get();
匹配
//查找list中是否都是张三
boolean result = studentList.stream().allMatch((s) -> s.getName().equals("张三"));
//查找list中是否有一个是张三
boolean result = studentList.stream().anyMatch((s) -> s.getName().equals("张三"));
//判断list中没有张三
boolean result = studentList.stream().noneMatch((s) -> s.getName().equals("张三"));总结
以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。
相关文章
这篇文章主要介绍了浅谈Spring与SpringMVC父子容器的关系与初始化，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2020-08-08
这篇文章主要介绍了Java之Rsync并发迁移数据并校验详解,本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下2021-08-08
实际项目开发中,如果涉及到多张表操作时,为了保证业务数据的一致性,大家一般都会采用事务机制,好多小伙伴可能只是简单了解一下,遇到事务失效的情况,便会无从下手,下面这篇文章主要给大家介绍了关于Spring事务失效场景的相关资料,需要的朋友可以参考下2022-07-07
这篇文章主要介绍了java实现视频转码,涉及到工具类用到的参数，本文通过实例代码给大家介绍的非常详细，需要的朋友可以参考下2022-01-01
这篇文章主要介绍了Spring Boot调用 Shell 脚本实现看门狗功能,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下2020-06-06
这篇文章主要为大家详细介绍了DragChartPanel可拖拽曲线的应用，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2019-12-12
SpringBoot中Mybatis注解一对多和多对多查询实现示例
这篇文章主要介绍了SpringBoot中Mybatis注解一对多和多对多查询的实现示例，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-03-03
这篇文章主要将通过源码带大家深入了解一下Spring中@Profile注解的原理与使用，文中的示例代码讲解详细，感兴趣的小伙伴可以跟随小编一起学习一下2023-04-04
IntelliJ IDEA 2020.1.2激活工具下载及破解方法免费可用至2089年(强烈推荐)
这篇文章主要介绍了IntelliJ IDEA 2020.1.2激活工具下载及破解方法免费可用至2089年(强烈推荐),本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下2020-09-09
这篇文章主要介绍了+= 和 ++ 操作符区别简单介绍的相关资料,非常不错，具有参考借鉴价值，需要的朋友可以参考下2016-09-09
最新评论