精华内容
下载资源
问答
  • java8 list.stream().map().collect()用法

    千次阅读 2021-05-07 09:51:43
    最近在项目中看到如下代码: ... userIds = userList.stream().map(User::getId).collect(Collectors.toList()); 换成现在常用的写法就是: List<User> userList = userDao.selectByUserId(user.getId()); List

    最近在项目中看到如下代码:

    List<User> userList = userDao.selectByUserId(user.getId());
    List<Long> userIds = userList.stream().map(User::getId).collect(Collectors.toList());
    

    换成现在常用的写法就是:

    List<User> userList = userDao.selectByUserId(user.getId());
    List<Long> userIds = new ArrayList<>();
    for (User user : userList) {
          userIds.add(user.getId());
    }
    

    理解:根据数据库查询,把user表中的数据查询出来,放到userList 列表中,然后去筛选userList 列表中的Id,并把这些Id放到一个新的列表userIds中。

    展开全文
  • class Student{ private String name; private String sex; private String age;...) List name15 = students.stream().filter(v->v.getAge()>15).map(Student::getName).collect(Collectors.toList());
    class Student{
    
        private String name;
    
        private String sex;
    
        private String age;
    
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public String getAge() {
            return age;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    }
    package java8.stream;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.stream.Collectors;
    
    public class StreamMapCollect {
    
        public static void main(String[] args) {
            List<Student> students = new ArrayList();
            Student student1 = new Student();
            student1.setAge("18");
            student1.setName("小明");
            student1.setSex("男");
            Student student2 = new Student();
            student2.setAge("17");
            student2.setName("小红");
            student2.setSex("女");
            Student student3 = new Student();
            student3.setAge("15");
            student3.setName("小雨");
            student3.setSex("女");
            students.add(student1);
            students.add(student2);
            students.add(student3);
    
            //需求1:拿出所有的学生年龄组成集合
    
            //老办法
            List<String> oldStuAge = new ArrayList();
            for (Student stu : students){
                oldStuAge.add(stu.getAge());
            }
    
            //java8新办法 一行代码解决
            List<String> newStuAge = students.stream().map(Student::getAge).collect(Collectors.toList());
    
            System.out.println(newStuAge);
    
           //需求2 所有学生年龄加3
            List<String> ageAdd3 = newStuAge.stream().map(n -> String.valueOf(Integer.valueOf(n)+3)).collect(Collectors.toList());
    
            System.out.println(ageAdd3);
    
            //取出所有名称
            List<String> names = students.stream().map(Student::getName).collect(Collectors.toList());
    
            //返回map 已名称为键 v1v2是判断key重复用v2
            Map<String, Student> studentMap = students.stream().collect(Collectors.toMap(Student::getName,v->v, (v1,v2)->v2));
    
            //返回左右年龄小于大于15岁(不包含)的学生名称 (此处需要注意你的filter在stream之后的话v变量就是Student对象了,如果在map之后的话你的v变量就是getName出来的String的对象了需要注意下!)
            List<String> name15 = students.stream().filter(v->v.getAge()>15).map(Student::getName).collect(Collectors.toList());
    
    

    展开全文
  • List.StreamStream 中文称为 “流”,通过将集合转换为这么一种叫做 “流” 的元素序列,通过声明性方式,能够对集合中的每个元素进行一系列并行或串行的流水线操作。 函数式编程带来的好处尤为明显。这种代码更...

    List.Stream流

    Stream 中文称为 “流”,通过将集合转换为这么一种叫做 “流” 的元素序列,通过声明性方式,能够对集合中的每个元素进行一系列并行或串行的流水线操作。

    函数式编程带来的好处尤为明显。这种代码更多地表达了业务逻辑的意图,而不是它的实现机制。易读的代码也易于维护、更可靠、更不容易出错。

    面对一对多结构,查询主实体时需要附带主实体的子实体列表怎么写?查出主列表,循环差子列表

    List的Stream流操作可以简化我们的代码,减少程序运行的压力,应对上面的问题,以前的话是先查出对应的list数据,然后根据取到集合中id去查找对应的子实体中数据,接着在放入对应的集合中去,key值表示主实体的id,value值表示对应主实体id查到的结合数据,这样就会三次foreach循环组装数据,会很麻烦,当数据量大的时候,会增加程序运行的负荷,造成运行缓慢。所以,流式操作代替我们的这一堆操作,提高了代码的简易性,可维护性,可靠性,更不容易出错。

    stream()优点:

    无存储。stream不是一种数据结构,它只是某种数据源的一个视图,数据源可以是一个数组,Java容器或I/O channel等。
    为函数式编程而生。对stream的任何修改都不会修改背后的数据源,比如对stream执行过滤操作并不会删除被过滤的元素,而是会产生一个不包含被过滤元素的新stream。
    惰式执行。stream上的操作并不会立即执行,只有等到用户真正需要结果的时候才会执行。
    可消费性。stream只能被“消费”一次,一旦遍历过就会失效,就像容器的迭代器那样,想要再次遍历必须重新生成。
    Stream 就如同一个迭代器(Iterator),单向,不可往复,数据只能遍历一次,遍历过一次后即用尽了。

    流(stream)的操作类型分为两种:

    Intermediate:一个流可以后面跟随零个或多个 intermediate 操作。其目的主要是打开流,做出某种程度的数据映射/过滤,然后返回一个新的流,交给下一个操作使用。这类操作都是惰性化的(lazy),就是说,仅仅调用到这类方法,并没有真正开始流的遍历。

    Terminal:一个流只能有一个 terminal 操作,当这个操作执行后,流就被使用“光”了,无法再被操作。所以这必定是流的最后一个操作。Terminal 操作的执行,才会真正开始流的遍历,并且会生成一个结果,或者一个 side effect。

    流(stream)的使用详解:
    简单说,对 Stream 的使用就是实现一个 filter-map-reduce 过程,产生一个最终结果,或者导致一个副作用(side effect)

    在这里插入图片描述

    列子

    首先我们先创建一个 Person 泛型的 List

    List<Person> list = new ArrayList<>();
    list.add(new Person("jack", 20));
    list.add(new Person("mike", 25));
    list.add(new Person("tom", 30));
    

    Person 类包含年龄和姓名两个成员变量

    private String name;
    private int age;
    stream() / parallelStream()
    

    最常用到的方法,将集合转换为流
    List list = new ArrayList();
    // return Stream
    list.stream();
    而 parallelStream() 是并行流方法,能够让数据集执行并行操作

    filter(T -> boolean)

    保留 boolean 为 true 的元素
    保留年龄为 20 的 person 元素

    list = list.stream()
                .filter(person -> person.getAge() == 20)
                .collect(toList());
    

    打印输出 [Person{name=‘jack’, age=20}]
    collect(toList()) 可以把流转换为 List 类型

    distinct()

    去除重复元素,这个方法是通过类的 equals 方法来判断两个元素是否相等的
    如例子中的 Person 类,需要先定义好 equals 方法,不然类似[Person{name=‘jack’, age=20}, Person{name=‘jack’, age=20}] 这样的情况是不会处理的

    sorted() / sorted((T, T) -> int)

    如果流中的元素的类实现了 Comparable 接口,即有自己的排序规则,那么可以直接调用 sorted() 方法对元素进行排序,如 Stream
    反之, 需要调用 sorted((T, T) -> int) 实现 Comparator 接口
    根据年龄大小来比较:

    list = list.stream()
               .sorted((p1, p2) -> p1.getAge() - p2.getAge())
               .collect(toList());
    

    当然这个可以简化为

    list = list.stream()
               .sorted(Comparator.comparingInt(Person::getAge))
               .collect(toList());
    

    limit(long n)

    返回前 n 个元素

    list = list.stream()
                .limit(2)
                .collect(toList());
    

    打印输出 [Person{name=‘jack’, age=20}, Person{name=‘mike’, age=25}]

    skip(long n)

    去除前 n 个元素

    list = list.stream()
                .skip(2)
                .collect(toList());
    

    打印输出 [Person{name=‘tom’, age=30}]
    tips:

    用在 limit(n) 前面时,先去除前 m 个元素再返回剩余元素的前 n 个元素
    limit(n) 用在 skip(m) 前面时,先返回前 n 个元素再在剩余的 n 个元素中去除 m 个元素

    list = list.stream()
                .limit(2)
                .skip(1)
                .collect(toList());
    

    打印输出 [Person{name=‘mike’, age=25}]

    map(T -> R)

    将流中的每一个元素 T 映射为 R(类似类型转换)

    List<String> newlist = list.stream().map(Person::getName).collect(toList());
    

    newlist 里面的元素为 list 中每一个 Person 对象的 name 变量

    flatMap(T -> Stream)

    将流中的每一个元素 T 映射为一个流,再把每一个流连接成为一个流

    List<String> list = new ArrayList<>();
    list.add("aaa bbb ccc");
    list.add("ddd eee fff");
    list.add("ggg hhh iii");
    

    list = list.stream().map(s -> s.split(" “)).flatMap(Arrays::stream).collect(toList());
    上面例子中,我们的目的是把 List 中每个字符串元素以” "分割开,变成一个新的 List。
    首先 map 方法分割每个字符串元素,但此时流的类型为 Stream<String[ ]>,因为 split 方法返回的是 String[ ] 类型;所以我们需要使用 flatMap 方法,先使用Arrays::stream将每个 String[ ] 元素变成一个 Stream 流,然后 flatMap 会将每一个流连接成为一个流,最终返回我们需要的 Stream

    anyMatch(T -> boolean)

    流中是否有一个元素匹配给定的 T -> boolean 条件
    是否存在一个 person 对象的 age 等于 20:
    boolean b = list.stream().anyMatch(person -> person.getAge() == 20);
    allMatch(T -> boolean)
    流中是否所有元素都匹配给定的 T -> boolean 条件
    noneMatch(T -> boolean)
    流中是否没有元素匹配给定的 T -> boolean 条件

    findAny() 和 findFirst()

    findAny():找到其中一个元素 (使用 stream() 时找到的是第一个元素;使用 parallelStream() 并行时找到的是其中一个元素)
    findFirst():找到第一个元素

    值得注意的是,这两个方法返回的是一个 Optional 对象,它是一个容器类,能代表一个值存在或不存在,这个后面会讲到

    reduce((T, T) -> T) 和 reduce(T, (T, T) -> T)

    用于组合流中的元素,如求和,求积,求最大值等
    计算年龄总和:

    int sum = list.stream().map(Person::getAge).reduce(0, (a, b) -> a + b);
    

    与之相同:

    int sum = list.stream().map(Person::getAge).reduce(0, Integer::sum);
    

    其中,reduce 第一个参数 0 代表起始值为 0,lambda (a, b) -> a + b 即将两值相加产生一个新值
    同样地:

    计算年龄总乘积:

    int sum = list.stream().map(Person::getAge).reduce(1, (a, b) -> a * b);
    

    当然也可以

    Optional<Integer> sum = list.stream().map(Person::getAge).reduce(Integer::sum);
    

    即不接受任何起始值,但因为没有初始值,需要考虑结果可能不存在的情况,因此返回的是 Optional 类型

    count()
    返回流中元素个数,结果为 long 类型
    collect()
    收集方法,我们很常用的是 collect(toList()),当然还有 collect(toSet()) 等,参数是一个收集器接口,这个后面会另外讲
    forEach()
    返回结果为 void,很明显我们可以通过它来干什么了,比方说:

    16. unordered()

    还有这个比较不起眼的方法,返回一个等效的无序流,当然如果流本身就是无序的话,那可能就会直接返回其本身

    打印各个元素:

    list.stream().forEach(System.out::println);
    

    再比如说 MyBatis 里面访问数据库的 mapper 方法:

    向数据库插入新元素:

    list.stream().forEach(PersonMapper::insertPerson);
    

    参考:
    https://blog.csdn.net/weixin_43423579/article/details/104946841

    展开全文
  • xxxList.stream().filter(p -> ObjectUtils.isEmpty(p.getPhone())).forEach(System.out::println); 2.返回【名字里包含“白”】的集合 xxxList.stream().filter(p -> p.getName.contains("白")).collect(C

    List xxxList = XXXService.list(params);

    1.返回【手机号码不为空】的所有对象

    xxxList.stream().filter(p -> ObjectUtils.isEmpty(p.getPhone())).forEach(System.out::println);
    

    2.返回【名字里包含“白”】的集合

    xxxList.stream().filter(p -> p.getName.contains("白")).collect(Collectors.toList());
    

    3.返回【年龄大于18岁】的集合的第一个对象

    xxxList.stream().filter(p -> p.getAge() > 18).findFirst();
    

    4.返回【多重条件】的所有对象

    Predicate<Person> ageFilter = p -> p.getAge() < 18;
    Predicate<Person> sexFilter = p -> p.getSex().equals("male");
    //多条件过滤
    xxxList.stream().filter(ageFilter)
                 .filter(sexFilter)
                 .forEach(p -> System.out.println(p.toString()));
    //and or
    xxxList.stream().filter(ageFilter.and(sexFilter))
                 .forEach(p -> System.out.println(p.toString()));
    

    5.返回【去重】后的对象

    xxxList.stream().distinct().forEach(System.out::println);
    

    6.返回【前3个】【年龄大于18】的对象集合

    xxxList.stream().limit(3).filter(p -> p.getAge() > 18).collect(Collectors.toList());
    

    7.返回【跳过前3个】,取【第4个开始】的对象集合

    xxxList.stream().skip(3).collect(Collectors.toList());
    

    8.按照【年龄】升序排序的集合

    xxxList.stream().sorted(Comparator.comparing(xxxDTO::getAge)).collect(Collectors.toList());
    

    9.按照【年龄】降序排序的集合

    xxxList.stream().sorted(Comparator.comparing(xxxDTO::getAge).reversed()).collect(Collectors.toList());
    

    10.List<Integer>类型降序排序的集合

    xxxList.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
    

    11.某个值【最大最小】的对象

    xxxList.stream().max(Comparator.comparing(xxxDTO::getAge)).get();
    

    12.map对集合中的每个元素进行遍历,并且可以对其进行操作,转化为其他对象。如将集合中的每个对象的序号加1

    xxxList.stream().map(p -> p.setSort(p.getSort() + 1 ))
                 .forEach(p -> System.out.println(p.toString()));
    
    展开全文
  • 需要使用Stream,首先要使用.stream()或.parallelStream()将集合生成流,其中最常用的是它的filtermap方法,简单写了下,如下: import java.io.*; import java.util.stream.Collectors; import java.util.List; ...
  • 使用java8 api方法list.stream().map().collect(Collectors.toList()) userList User实体类对象集合 User 实体类 getId 实体类属性的get方法 List<int> ids= userList.stream().map(User::getId).collect...
  • 一般我们都会用stream().filterstream().map来处理。 这两个用的比较多,有些同学还会遇到用着用着就迷糊了: 到底什么时候用什么?这两个又有什么区别呢? 下面我们简单来上个代码。 1、先上个砧板上的肉肉...
  • list.stream().forEach

    千次阅读 2020-12-23 18:38:00
    System.out.println(list.stream().filter(People::getSex).collect(Collectors.toList())); //[People{id=1, name='Ligs', sex=true}, People{id=3, name='Jinzg', sex=true}, People{id=5, name='Hedx', sex=true...
  • 这些方法可以被分成两种:延迟方法返回值类型仍然是 Stream 接口自身类型的方法,因此支持链式调用。(除了终结方法外,其余方 法均为延迟方法。)终结方法返回值类型不再是 Stream 接口自身类型的方法,因此不再支持...
  • java小技巧:Stream().map().collect(Collectors.toLIst()) 获取对象list中某个特定字段组成的list: `UserInActivity(username=zhangsan, activityname=七彩四点半)` `UserInActivity(username=liuyan, activity...
  • list().stream().collect()

    2021-06-01 13:52:19
    list().stream().collect(Collectors.groupingby(Entity::getFild))的用法
  • Map seen = new ConcurrentHashMap<>(); return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null; } distinct()不对对象列表进行去重的直接实现。它是hashCode()和equals()工
  • Java-Stream Collectors.toMap() listmap 一、listmap List<UserInfoDetailVo> userList = new ArrayList<>(); //userInfo字段 id主键; nickname名称; className班级名称; age年龄; sex性别; money...
  • List unique = list.stream().distinct().collect(Collectors.toList()); 去除List中重复的对象 // Person 对象 public class Person { private String id; private String name; private String sex; &...
  • 技术就是力量,没有对比就没伤害当然如此庞大的数据,肯定不会全量查,采用懒加载或其他方法,这里只是给大家展示下.stream()函数的强大!!! 六万条数据构建树结构,采用传统构建树方法和.stream()函数构建的对比...
  • 项目中使用list.stream().limit(1000).collect(Collectors.toList()编译报错解决方案
  • public static void main(String[] args) {List list = Lists.newArrayList();list.add(new Student("测试", "男", 18));list.add(new Student("开发", "男", 20));list.add(new Student("运维", "女", 19));list....
  • list.stream 取差集

    2021-09-08 17:14:41
    //数据源中的数据 ... list = dbActService.getPage(mapSet, app, mapItemList, null, null, null, null, null); // for (int i = 0; i < list.size(); i++) { // log.info("{}={}",i,list.get(i)); /..
  • list stream().forEach

    2021-09-11 23:23:35
    遍历list的另一种写法 List<Integer> list= new ArrayList<>(); list.add(1); list.add(2);... list.add(3);... list.add(4);... list.add(5);... list.stream().forEach(item -> { System.out...
  • 这篇文章简单介绍一下其中一部分的使用.stream()stream()把一个源数据,可以是集合,数组,I/O channel, 产生器generator 等,转化成流.filter()filter()方法用于通过设置的条件过滤出元素.sorted()sorted()用于...
  • 本文主要说明在Java8及以上版本中,使用stream().filter()来过滤一个List对象,查找符合条件的对象集合。 //自己项目所用的地方 List<Long> storageIdList = compoundStorageDtoList.stream().filter(item -...
  • filter:4.sorted():5.并行(parallel)程序6.Collectors(): mylist.stream() .map(myfunction->{ return item; }).collect(Collectors.toList()); 说明: steam():把一个源数据,可以是集合,数组,I/O ...
  • Map排序 按key排序 Map map = map.entrySet() .stream() .sorted(Map.Entry.comparingByKey()) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (c1, c2) -> c1, LinkedHashMap::new));...
  • import java.util.Arrays;...import static java.util.stream.Collectors.toList; /** *过滤重量大于103的,然后获取color的List */ public class SimpleStream { public static void main(String[] args) {
  • authMenuQueryRespList =authMenuList.stream().map(item->{ AuthMenuQueryResp rep = new AuthMenuQueryResp(); rep.setName(item.getName()) ; rep.setDataHref(item.getDataHref()); rep.setcTimeFormat...
  • Java流库(java.util.stream)流提供了一种让我们可以在比集合更高的概念级别上指定计算的数据视图。通过使用流,我们可以说明想要完成什么任务,而不是说明如何去实现它。(这一点受益于lambda表达式)我们将操作的调度...
  • List=stringList.stream().map(Long::valueOf).collect(Collectors.toList()); Long转String List<>=longList.stream().map(String::valueOf).collect(Collectors.toList()); 字段取和 Integer memberCount = ...
  • list.stream().map() 取某个值List List<SchemePriceDTO> ftiPriceDtos = ftiResourcePriceDTOS.stream() .map(x -> x.getPrice()).collect(Collectors.toList()); 取某个对象List List<EventDetail&...
  • list.stream()方法

    2021-11-12 17:23:57
    List<ExerciseLevelIndicators> list = exerciseLevelIndicatorsRepository.getSpiderChartAndLineChart(name); //根据某个属性分组 ... collect = list.stream() .collect(Collectors.gro..

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,912
精华内容 17,964
关键字:

list.stream().filter().map