Java8 Lambda 流式编程

package com.sitech.crmpd.service;

import com.google.common.collect.Lists;
import com.sitech.crmpd.annotation.SystemHttpLog;
import com.sitech.crmpd.domain.CustViewDataDTO;
import com.sitech.crmpd.exception.HoException;
import com.sitech.crmpd.exception.HoStatus;
import com.sitech.crmpd.mapper.ContactTaskInfoMapper;
import com.sitech.crmpd.mapper.HuaxiaoOrderMapper;
import com.sitech.crmtpd.mapper.ContactOrderMapper;
import com.sitech.crmtpd.market.domain.ContactOrder;
import com.sitech.crmtpd.market.domain.ContactOrderExample;
import lombok.extern.slf4j.Slf4j;

import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Stream;

/**
 * @oauth: qiangSW
 * @date: 2019/11/20 13:48
 * @description: com.sitech.crmpd.service
 * @doc:
 */
@Slf4j
@Service
public class ViewTaskService {

    @Autowired
    private HuaxiaoOrderMapper huaxiaoOrderMapper;
    @Autowired
    private ContactOrderMapper orderMapper;
    @Autowired
    private ContactTaskInfoMapper contactTaskInfoMapper;

    /**
     * 
     *
     * @param custId
     * @param viewItemCat
     * @return
     */
    public CustViewDataDTO custViewData(String custId, String viewItemCat) {
        List<Map> user = huaxiaoOrderMapper.selectHoldByCustId(custId);
        CustViewDataDTO custViewDataDTO = new CustViewDataDTO();
        List<CustViewDataDTO.ContactTaskList> contactTaskLists = Lists.newArrayList();
        custViewDataDTO.setViewItemCat(viewItemCat);
        custViewDataDTO.setProCode("8140000");
        return Optional.ofNullable(user)
                .filter(a -> CollectionUtils.isNotEmpty(a) && !a.get(0).isEmpty())
                .map(b -> {
                    String idNo = b.get(0).get("ID_NO").toString();
                    ContactOrderExample orderExample = new ContactOrderExample();
                    orderExample.createCriteria().andTargetObjNbrEqualTo(idNo);
                    List<ContactOrder> contactOrderList = orderMapper.selectByExample(orderExample);
                    return Optional.ofNullable(contactOrderList)
                            .filter(list -> CollectionUtils.isNotEmpty(list))
                            .map(c -> {
                                return cust(c.get(0), val -> {
                                    List<Map<String, Object>> list = Lists.newArrayList();
                                    list.addAll(contactTaskInfoMapper.taskDetail(val.getTargetObjNbr()));
                                    list.stream()
                                            .filter(map -> null != map && !map.isEmpty())
                                            .forEach(taskList -> {
                                                CustViewDataDTO.ContactTaskList createTask = custViewDataDTO.new ContactTaskList();
                                                createTask.setPushType(String.valueOf(taskList.get("PUSHTYPE")));
                                                createTask.setContactDate(String.valueOf(taskList.get("CONTACTDATE")));
                                                createTask.setContactTaskTitle(String.valueOf(taskList.get("CONTACTTASKTITLE")));
                                                createTask.setContactScript(String.valueOf(taskList.get("CONTACTSCRIPT")));
                                                createTask.setContactChlId(String.valueOf(taskList.get("CONTACTCHLID")));
                                                createTask.setCustId(custId);
                                                createTask.setCustName(String.valueOf(user.get(0).get("USER_NAME")));
                                                contactTaskLists.add(createTask);
                                            });
                                    custViewDataDTO.setContactTaskList(contactTaskLists);
                                    return custViewDataDTO;
                                });
                            }).orElseGet(() -> {
                                CustViewDataDTO.ContactTaskList createTask = custViewDataDTO.new ContactTaskList();
                                contactTaskLists.add(createTask);
                                custViewDataDTO.setContactTaskList(contactTaskLists);
                                return custViewDataDTO;
                            });
                }).orElseGet(() -> {
                    CustViewDataDTO.ContactTaskList createTask = custViewDataDTO.new ContactTaskList();
                    contactTaskLists.add(createTask);
                    custViewDataDTO.setContactTaskList(contactTaskLists);
                    return custViewDataDTO;
                });


    }

    public CustViewDataDTO cust(ContactOrder order, Function<ContactOrder, CustViewDataDTO> function) {

        CustViewDataDTO apply = function.apply(order);
        return apply;
    }
}

2 自定义收集器 

package com.test;

import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;


/**
 * @param Collection<T>  要收集的元素的泛型
 * @param   List<T> 累加器容器类型
 * @param  List<T> 收集返回的结果
 */
public class CollectorListToList<T> implements Collector<Collection<T>, List<T>, List<T>> {

    /**
     *  创建接收容器
     * @return
     */
    @Override
    public Supplier<List<T>> supplier() {
        return ArrayList::new;
    }

    /**
     * 将流中的元素放入可变方法容器
     * @return
     */
    @Override
    public BiConsumer<List<T>, Collection<T>> accumulator() {
        return List::addAll;
    }

    /**
     * 组合结果:流被拆分多个部分,需要将多个结果合并
     * @return
     */
    @Override
    public BinaryOperator<List<T>> combiner() {
        return (list1,list2)->{
             list1.addAll(list2);
            return list1;
        };
    }
    /**
     * 最后调用,在遍历完流后将结果容器A转换结果R
     * @return
     */
    @Override
    public Function<List<T>, List<T>> finisher() {
        return Function.identity();
    }
    /**
     *  返回一个描述收集器特征不可以变集合,用于告诉收集器可以进行那些优化,比如并行
     *  1 CONCURRENT
     *   意味着结果容器支持多线程并发操作accumulator()方法向容器中放入元素。
     *   如果收集器没有被同时标记为无序的`UNORDERED`，则该特征只在数据源为无序（如set）时才有效
     *  2 UNORDERED
     *    规约操作不保证集合中元素的顺序.如结果容器为Set的场景下
     *  3 IDENTITY_FINISH
     *  表明`完成方法finisher`是一个恒等式，可以被忽略,累加器的结果combiner A 将会作为最终的结果R
     *  这也要求，直接将A转换成R是安全的
     * @return
     */
    @Override
    public Set<Characteristics> characteristics() {
        return Collections.unmodifiableSet(EnumSet.of(Characteristics.IDENTITY_FINISH));
    }
}