Lambda 和Stream实战例子收集

港控/mmm° 2021-11-04 12:08 224阅读 0赞

> Function<T, R> - 以T为输入，返回R作为输出  
> Predicate - 以T为输入，返回布尔值作为输出  
> Consumer - 将T作为输入，执行某些操作并且不返回任何内容  
> Supplier - 没有任何输入，返回T  
> IntConsumer -取两个T作为输入，返回一个T作为输出，对“减少”操作很有用

获取流的最常见方式可能来自集合：Stream stream = collection.stream（）;  
是Java 8 中引入的新特性，是对集合（Collection）对象功能的增强是关于算法和计算的，更像一个高级版本的迭代器（Iterator）

**能够用来做什么**：用于对集合对象进行各种便利、高效的聚合操作，或大批量数据操作。

以往**对于集合的聚合操作，需要使用Iterator遍历集合**，代码繁冗；对于过滤和计算得到的中间结果，需要额外的空间进行存储Java Stream API解决了以上问题，遍历逻辑可以精简为一行，使得代码更加简洁易读。Java Stream提供串行和并行两种模式进行汇聚操作，能够充分利用多核处理器的优势，更方便写出高性能的并发程序且不易出错

对List都做同样的操作，类似于遍历List，有个for循环

if (CollectionUtils.isNotEmpty(list)) {
                list.forEach(entity -> {
                    String jsonString = JSONObject.toJSONString(entity, SerializerFeature.WriteMapNullValue);
                    Map dataMap = JSONObject.parseObject(jsonString);
                    dataList.add(dataMap);
                });
                map.put(SysConstants.HttpConstants.COUNT, list.size());
                map.put("list", dataList);
            }

Lambda**没有办法打破循环**或从lambda中**返回包含该方法的结果的值。**

final String secret =“foo”;
    boolean containsSecret（Iterable <String> values）{
        values.forEach（s  - > {
            if（secret.equals（s））{
                ??? //想要结束循环并返回true，但不能
            }
        });
    }

**对一个字符串的List排序，忽略大小写。**

//对一个字符串的List排序，忽略大小写。
    List<String> list = Arrays.asList("a","e","c");
    list.sort((s1,s2) -> s1.compareToIgnoreCase(s2));
    System.out.println(list.toString());
    //等价
    list.sort(String::compareToIgnoreCase);

**new生成对象 默认构造器**

//new生成对象 默认构造器
    Supplier<Apple> s1 = Apple::new;
    Apple apple = s1.get();
    //等价
     Supplier<Apple> c1 = () -> new Apple();

Function<Integer,Apple> c2 = Apple::new;
    Apple apple1 = c2.apply(1);
    //等价
    Function<Integer, Apple> c2 = (weight) -> new Apple(weight);

打印购物清单

@Test
        public void printShoppingList(){
            shoppingList.forEach(System.out::println);
            //结果同上
            shoppingList.stream().forEach(System.out::println);
        }

统计购物清单总数与总价

long itemNum = shoppingList.stream().count();
            System.out.println("Sum of items in the shopping list: " + itemNum);
            long totalPrice = shoppingList.stream().collect(Collectors.summingLong((Item::getPrice)));
            /* long totalPrice = shoppingList.stream().mapToLong((Item::getPrice)).sum(); */
            System.out.println("Total price: " + totalPrice);

过滤价格小于1000的商品

shoppingList.stream().filter(p -> p.getPrice() >= 1000L).forEach(System.out::println);

按价格排序

/*升序*/
            shoppingList.stream().sorted(Comparator.comparingLong(Item::getPrice)).forEach(System.out::println);

所有商品价格减100 - Map

shoppingList.stream().map(p -> new Item(p.getItemName(),p.getPrice()-100)).forEach(System.out::println);
            /*再排序，发现价格已经是-100了的*/
            shoppingList.stream().sorted(Comparator.comparingLong(Item::getPrice)).forEach(System.out::println);

取出如上优惠之后金额超过1000元的商品中，价格最低的商品（最便宜的奢侈品）

Item cheapestluxury = shoppingList.stream()
                  .map(p -> new Item(p.getItemName(), p.getPrice() - 100))
                  .filter(p -> p.getPrice() > 1000)
                  .reduce((a, b) -> a.getPrice() < b.getPrice() ? a : b)
                  .get();
          System.out.println(cheapestluxury);

求一个集合中字符串长度小于5的数量。filter里面是过滤条件，true则留下，false则提出  
1.filter操作。即使原stream中满足条件的元素构成新的stream

List<String> list = Arrays.asList("java", "scala", "python", "shell", "ruby");
            int num = 0;
            for(String lan: list) {
                if(lan.length() < 5) {
                    num++;
                }
            }
    等价
    long num = list.parallelStream().filter(x -> x.length() < 5).count();

2.map操作。map算是最常用的一种操作了，遍历原stream中的元素，转换后构成新的stream：  
转成大写。

List<String> list = Arrays.asList(new String[]{"a", "b", "c"});
    //collect(Collectors.toList())下面将把字符串累积到ArrayList中list.stream().map(String::toUpperCase).collect(Collectors.toList()).forEach(x -> System.out.print(x + " "));

3.distinct操作。distinct也是常用的操作之一。  
找出重复的元素

Stream<String> distinctStream = Stream.of("bj","shanghai","tianjin","bj","shanghai").distinct();
    Stream<String> sortedStream = distinctStream.sorted(Comparator.comparing(String::length));
    sortedStream.forEach(x -> System.out.print(x + " "));

4.排序操作。

Stream<Integer> sortedReverseStreamV2 = Stream.of(1,3,7,4,5,8,6,2).sorted((Integer o1, Integer o2) -> o2 - o1);
    sortedReverseStreamV2.collect(Collectors.toList()).forEach(x -> System.out.print(x + " "));

1.reduction就是从stream中取出结果，是terminal operation，因此经过reduction后的stream不能再使用了。主要包含以下操作： findFirst()/findAny()/allMatch/anyMatch()/noneMatch等等

collect()方法可以对stream中的元素进行各种处理后，得到stream中元素的值。并且Collectors接口提供了很方便的创建Collector对象的工厂方法。

//流转成List<String> List<Integer>
            List<String> list1 =Stream.of("1", "3", "2").collect(Collectors.toList());
            List<Integer> list2 =  Stream.of(1,2,3).collect(Collectors.toList());
            //构建Set
            Set<String> s1 = Stream.of("1","2","3").collect(Collectors.toSet());
            s1.forEach(p -> System.out.println(p + " "));
            //将流构造成字符串，并用逗号分隔开
            String resultStr = Stream.of("hello", "world", "hello", "java").collect(Collectors.joining(","));
            System.out.println(resultStr);//hello,world,hello,java