filter作用：

Stream接口中的filter函数：

Stream<T> filter(Predicate<? super T> predicate);

stream().filter用法---（filter是用来过滤出符合设置条件的元素，获取过滤范围内的所有字段list）

filter入参格式：

一般格式：

/**
* 把属性当参数传递到方法中，由and,or,negate方法去处理过滤这个属性字段的值。
* 传参使用: o -> o.propertyName
*/

default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);

equal格式：

/**
* 判断对象是否为空。
* 传参使用: Objects::isNull
*/

static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }

用例：

1.filter过滤与foreach遍历结合使用

if(CollectionUtils.isNotEmpty(conditionDatas)){
    conditionDatas.stream().filter(x->x!=null).forEach(x->{
//  conditionDatas.stream().filter(Objects::nonNull).forEach(x->{
        Map<String, Object> Params = Maps.newHashMap();
        Params.put("sendTime", Calendar.getInstance().getTimeInMillis());
        Params.put("optType", status.getName());
        Params.put("result", "失败");
        pushService.push(x.getMessageId(), Params, SystemCode.getSysCode());
    });

       stream获取当前conditionDatas对象的流，filter对流进行非空过滤，结合lambda表达式，返回一个boolean类型返回值，只有返回为true的conditionDatas中的元素才会进入到forEach的循环中put，最终通过pushService组装。

2.filter过滤某字段contains包含常量及对象

list = list.stream().filter(x -> x.getContent().contains("2")
        || x.getTestContent().contains("4")
).collect(Collectors.toList());
filter过滤，看questionCodes中是否包含dto形参对象的getCode，包含的数据重新生成一个新的list
upDtos = upDtos.stream().filter(dto -> codes.contains(dto.getCode())).collect(Collectors.toList());

        stream获取当前conditionDatas对象的流，filter过滤Content字段包含2或4的流。

3.parallelStream的使用，区分Stream

Map<String, TempEntity> map = batteryList.parallelStream().filter(x->("P").equalsIgnoreCase(x.getBattery())).collect(
//List Stream 转换 Map时向collect()方法中传递Collector对象，对象由Collectors.toMap()方法返回，实例返回identity和时间
//时间采用三元运算，通过LocalDateTime.parse解析成df格式进行三元判断
      Collectors.toMap(Function.identity(), (c1, c2) -> LocalDateTime.parse(c1.getCreateTime(),df).isAfter(LocalDateTime.parse(c2.getCreateTime(),df))  ? c1 : c2));

        此处过滤BatterySpecies字段中等于P的流，此处用的是parallelStream而不是stream，二者都是过滤，二者的区别在于：

        1.并行；2.任务独立；3.竞态条件；4.调用顺序

4.空判断时可以无需vlaues（）和stream

//map.values().stream().forEach(battery->{
map.values().stream().filter(x->x.getTest1() != null).filter(x->x.getTest2() != null).forEach(battery->{
	RecordEntity entity = new RecordEntity();
	entity.setTest1(battery.getTest1());
	entity.setTest2(battery.getTest2());
	entityList.add(entity);
});

        此处表达的是如果stream()没有判断，那默认为真，可以不需要stream()；lanbda多字段重置时可采用->

5.filter过滤及排序

List<fenceEntity> inList = list.stream().filter(x->x.getFlag()==1).sorted(Comparator.comparing(fenceEntity::getTest1).reversed()).collect(Collectors.toList());
//根据FenceEntity::getTest1这个字段进行升序排列
List<FenceEntity> outList = list.stream().filter(x->x.getFlag()==0).sorted(Comparator.comparing(FenceEntity::getTest1)).collect(Collectors.toList());

        此处通过fileter过滤flag为1的list，然后通过sorted（Comparator.comparing(某个字段的集合).reversed()）进行降序排列
        sorted（Comparator.comparing(某个字段的集合)）进行升序排列  
ps：sorted（Comparator.comparing()）一起使用 ，sort和sorted功能一致，但sorted应用更广

6.filter及anyMatch配合过滤

List<PermissionVO> insertList = syncgetTest1.stream().filter(s -> insertSyncgetTest1.stream().anyMatch(e -> s.getCode().equals(e))).collect(Collectors.toList());

此处包含两个集合的过滤：
        取出原始数据code的syncgetTest1 ，以及只有code的list insertSyncgetTest1
        将两个集合转换成流，insertSyncgetTest1 的形参为e，syncgetTest1 的形参为s，syncgetTest1 里面的code任一存在于insertSyncgetTest1 ，则返回true

7.多条件过滤

List<Entity> testList = getTest1.stream().filter(s -> s.getTest1().equals("1") && s.getTest2().equals(1L) && s.getTest3.equals(s.getApplicationName()) ).collect(Collectors.toList());
或
List<Entity> testList = getTest1.stream().filter(s -> s.getTest1().equals("1")).filter(a->a.getTest2().equals(1L)).filter(b->b.getTest3.equals(s.getApplicationName()).collect(Collectors.toList());

8.equal条件入参的使用

list4.stream().filter(Objects::isNull).forEach(System.out::println);
list4.stream().filter(Objects::nonNull).forEach(System.out::println);

此处入参还包括equal，deepequal等方法，但使用较少，主要还是对象的非空判断

ps：

        stream必须后面加上所谓的terminal operation，类似于count()、forEach()、collect()等操作之后，才会消费并结束原始数据流。

public static <T> Collector<T, ?, List<T>> toList() {
         return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add, (left, right) -> { left.addAll(right); return left; }, CH_ID);
     }

        下一章节将会介绍stream的map用例内容