collection.stream()用法详解

刺骨的言语ヽ痛彻心扉 2021-10-23 12:28 421阅读 0赞

stream()方法和collect()方法都是java8的新特性

List<String> widgetIds = widgets.stream().map(Widget::getWidgetId).collect(Collectors.toList());

解释下一这行代码：  
widgets：一个实体类的集合，类型为List  
Widget：实体类  
getWidgetId：实体类中的get方法，为获取Widget的id  
本来想要获得wiget的id集合，按照我的思路肯定是遍历widges，依次取得widgetIds,但是此行代码更加简洁，高效

stream()优点

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

List<String> list= Arrays.asList("a", "b", "c", "d");
    List<String> collect =list.stream().map(String::toUpperCase).collect(Collectors.toList());
    System.out.println(collect); //[A, B, C, D]
     
    List<Integer> num = Arrays.asList(1,2,3,4,5);
    List<Integer> collect1 = num.stream().map(n -> n * 2).collect(Collectors.toList());
    System.out.println(collect1); //[2, 4, 6, 8, 10]

# Lambda 之 Collection Stream #

Collection.stream() 测试实体类

class Demo {
        private Long id;
        private String name;   
    }

// 实例化并组成一个List

List<Demo> demos = Lists.newArrayList(new Demo(1L, "SF"), new Demo(2L, "AXE"));

##### 1.map + collect用法 #####

场景1：获取List列表的所有id No Lambda

public static List<Long> getIds(List<Demo> demos){
            List<Long> ids = Lists.newArrayList();
            for (Demo d : demos) {
                ids.add(d.getId());
            }
            return ids;
    }

Lambda’s show

List<Long> ids = demos.stream().map(Demo::getId).collect(toList());

最后toList() 可以有更多的实现,比如

Set<Long> ids = demos.stream().map(Demo::getId).collect(toSet());

场景2：list变成map  
有时候我们把list变成map,将多次List的O(n)遍历变成Map的O(1)查询，拿空间换时间  
No lambda

public static Map<Long, Demo> getIds(List<Demo> demos){
            Map<Long, Demo> map = Maps.newHashMap;
            for (Demo d : demos) {
                map.put(d.getId, d);
            }
            return map;
    }

Lambda‘s show

Map<Long, Demo> map = demos.stream().collect(toMap(Demo::getId, o -> o));

##### 2.filter #####

场景1：从List中找到name="SF"的Demo实例  
No lambda

public static Demo getSpecifyDemo(String name, List<Demo> demos){
        Demo target = null;
        for (Demo demo : demos) {
            if (name.equals(demo.getName())) {
                target = demo;
            }
        }
        return target;
    }

Lambda’s show–粗犷的老汉推车

String targetName = "SF";
    Demo target = demos.stream().filter(d -> targetName.equals(d.getName())).findFirst().orElse(null);

这种写法非常简单，但是调用链太长，一个lambda能够绕地球好几圈，最好写成以下格式，防止步子迈得太大。  
Lambda’s show–优雅传教士

Demo target = demos.stream()
                .filter(d -> targetName.equals.equals(d.getName()))
                .findFirst()
                .orElse(null);

find()的结果是Optional,Optional号称NPE终结者，于是对于find()的结果你可以随意使用终结者携带的任何武器，例如orElse(),ifPresent(),isPresent()…每个用起来都是那种哒哒哒冒蓝火的，更多姿势详见Optional的裸体源码。

##### 3.match #####

match()是filter()的缩写版本，返回结果只有boolean类型，返回是否匹配。  
场景1：当前list中某个元素是否符合某个条件 这个例子，给出另一个用法Demo::getId No lambda

List<String> condition = new ArrayList<>();
    condition.add("SF");
    
    public static boolean isExist(List<String> condition, List<Demo> demos){
        boolean flag = false;
        for (Demo demo : demos) {
            if (condition.contains(demo.getName())) {
                flag = true;
                break;
            }
        }
        return flag;
    }

Lambda’s show 使用filter

boolean flag = demos.stream()
                .map(Demo::getName)
                .filter(condition::contains)
                .findAny()
                .isPresent();

Lambda’s show 直接使用match

boolean flag = demos.stream()
                .map(Demo::getName)
                .anyMatch(condition::contains);