标签：合并   临时   block   转换   复杂   lang   大量   lock   原来   

说明

Java中的集合流操作需要java 8的特性支持。需要对Lambda表达式有所了解

主要作用：

1. 快速筛查集合元素
2. 统一对集合元素处理

说白了就是原来的要大量循环的操作可以使用流操作快速完成

假设条件

之后的代码演示将于以下的假设条件来模拟表示

存在Message类

public class Message{
    String value;
    int code;
}

存在ShortMessage类

public class ShortMessage{
    String value;
}

Tools类中存在方法

public static ShortMessage convert(Message msg){
    return new ShortMessage(msg.getValue);
}

存在一个数组，里面存在大量已经实例化的Message对象

List<Message> messageList;

省略get、set及构造函数无营养代码

filter操作

作用：快速筛查，过滤元素留下符合要求的元素生成一个新的流

假设存在

//快速筛查出value属性包含‘bug’的message对象
messageList = messageList.parallelStream()//转为并行流，多线程
    .filter(msg -> msg.getValue().contains("bug"))//筛查
    .collect(Collectors.toList());//流转回list

msg 相当于循环messageList中的每一个Message实例对象的临时引用

filter返回的还是一个stream，所以是可以一直链式调用操作的，比如一直.filter.filter过滤

filter操作接受的是一个Predicate逻辑表达式，既结果是一个布尔结果，为true的保留

map操作

作用：统一处理

map操作理解起来有点复杂，请看以下例子

假设我们需要将messageList里面的所有实例转为ShortMessage对象

一般处理

List<ShortMessage> shorts = new ArrayList<>();
for(Message msg:messageList){
    shorts.add(Tools.convert(msg));
}

流map处理方式

List<ShortMessage> shots = messageList.parallelStream()
    .map(Tools::convert)
    .collect(Collectors.toList());

所以说，map操作可以了解为需要对一个流中的元素统一处理时的操作，会将流中的每一个元素循环调用方法作为参数传递进去

注意map中的方法多次执行返回也是一个流，而这个流的存储的元素的类型是会变化的，具体看调用方法的返回类型

map返回的流也是可以继续链式调用的

当然也可以这样，相信下面的代码不需要我解释

List<ShortMessage> shorts = messageList.parallelStream()
    .filter(msg -> msg.getValue().contains("bug"))
    .map(Tools::convert)
    .collect(Collectors.toList());

假设我们需要将所有的Message对象的code加100

记住，流操作里面的只要是个Lambda表达式就可以

messageList = messageList.parallelStream()
    .map(msg -> msg.setCode(msg.getCode()+100))
    .collect(Collectors.toList());

flatMap操作

这个说明一下，以免以后忘记

map操作可以看到可以了解为一对一映射操作，每输入一个元素，则按map中的方法规则处理转换为另外一个元素，但有的时候是一对多操作的；

如果从字面意思上理解，就是map的扁平化操作一般用在复合数组上面,flatMap会将流中的每一个元素再转为流操作

List<List<Message>> list;
//如果
list.parallelStream().flatMap(child -> child.stream());
//那么A表示list中的子集合的流，-> 后面必须产生一个新的流，最终；flatMap会产生一个合并出来的大的流

简单例子说明

假设存在

public class data{
    int x;
    int y;
}

修改Message类

public class Message{
    String value;
    int code;
    Data[] datas;
    
    /**
    *[]数组和List是两回事，这里这个方法只是演示如果data是List类型情况下
    */
    public List<Data> getDataArray(){
        return Arrays.asList(data.clone());
    }
}

测试数据

		Message m1 = new Message("message 1", new Data[]{new Data(3, 2), new Data(3, 2), new Data(3, 2)});
        Message m2 = new Message("message 2",new Data[]{new Data(4, 2), new Data(6, 2), new Data(3, 2)});
        Message m3 = new Message("message 3",new Data[]{new Data(5, 2), new Data(4, 2), new Data(4, 2)});
        Message m4 = new Message("message 4",new Data[]{new Data(6, 2), new Data(3, 2), new Data(3, 2)});
        Message m5 = new Message("message 5",new Data[]{new Data(7, 2), new Data(2, 2), new Data(7, 2)});
        Message m6 = new Message("message 6",new Data[]{new Data(8, 2), new Data(45, 2), new Data(3, 2)});

        List<Message> messageList = Arrays.asList(m1, m2, m3, m4, m5, m6);

现在就是说，有一个messageList保存多个Message对象，每个Message对象操作一个Data类型数组

一、找出所有x值为3的Data对象

List<Data> collect = messageList.parallelStream()
    .map(Message::getDatas)//把data取出来，创建一个全是data[]的流
    .flatMap(Arrays::stream)//转为流，注意会合并,创建一个全是data的流
    .filter(data -> data.getX() == 3)//筛查
    .collect(Collectors.toList());

换种写法,如果是list操作会更简单

        List<Data> collect1 = messageList.parallelStream().flatMap(msg -> msg.getDataArray().stream()).filter(data -> data.getX() > 3).collect(Collectors.toList());

二、获取所有的X的值

        List<Integer> integerList = messageList.parallelStream().flatMap(ss -> ss.getDataArray().stream()).map(Data::getX).collect(Collectors.toList());

剩下的就不一一举例了，可以发现flatMap其实可以理解为合并处理

Java集合的流Stream操作（快速筛查，统一处理）

标签：合并   临时   block   转换   复杂   lang   大量   lock   原来   

原文地址：https://www.cnblogs.com/liangshu/p/13904965.html