java 编程技巧- stream && lambda

作为一名即将成为高级开发的工程师，这连个都不会，是不是。。。。。。。。。

讲一下 流式计算 和 函数式接口  

 List<Demo> demoList = new ArrayList<>();
 demoList.add(demor);
 demoList.add(demo2);

 // lamdba
 demoList.forEach(Demo -> {System.out.println(Demo.getLeader());} );

 // 这里的forEach(） 方法里参数是一个函数接口(Consumer<? super T> action)，
 //java.util.function他们存在于这个包里面


 //函数型函数式接口的使用，他的使用是实现他的apply() 该方法 传入一个值返回一个值，
Function<String, String> function =  new Function<String, String>() {
     @Override
     public String apply(String s) {
         return s;
     }
 };

 // 他的简写方式，lambda
 Function<String, String> function1 =  (s) -> {return  s;};
 // 更简写
 Function<String, String> function2 =  s -> s;
 //所以 出现了这样的编码 demoList.forEach(Demo -> {System.out.println(Demo.getLeader());} );


 // 断定型接口  传参数 返回bool
 Predicate<String> predicate = new Predicate<String>() {
     @Override
     public boolean test(String s) {
         return false;
     }
 };

 // 简写
 Predicate<String> predicate1 = (str) -> {return str.isEmpty();};
 Predicate<String> predicate2 = str ->  str.isEmpty();

 //消费型接口 consumer   只传参数没有返回值
 Consumer consumer = new Consumer() {
     @Override
     public void accept(Object o) {
         System.out.println(o);
     }
 };

 Consumer consumer1 = (str) -> {System.out.println(str);};

 // 供给型接口  不穿参数返回值
 Supplier supplier = new Supplier() {
     @Override
     public Object get() {
         return 1023;
     }
 };

 Supplier supplierS = () ->{return 1024;};

   List<Demo> list1 = demoList.stream().filter(demo -> "宋江".equals(demo.getLeader())).distinct().collect(Collectors.toList());

        // limit 返回前n个元素的流，当集合的长度小于n时，则返回所有集合。
        List<Demo> list2 = demoList.stream().filter(demo -> "宋江".equals(demo.getLeader())).limit(2).collect(Collectors.toList());

        // sorted
//        List<Demo> list1 = demoList.stream().filter(demo -> "宋江".equals(demo.getLeader())).sorted((s1,s2) -> s2.getage()- s1.getage()).collect(Collectors.toList());

        // skip  跳过n 个对象输出
        //        List<Demo> list1 = demoList.stream().filter(demo -> "宋江".equals(demo.getLeader())).skip(2).collect(Collectors.toList());


        // allMatch  判断每个值是否都是他们都头都是宋江
                Boolean b = demoList.stream().allMatch(demo -> "宋江".equals(demo.getLeader()));
                // anyMatch  判断每个值是否有一个是宋江
        Boolean c = demoList.stream().anyMatch(demo -> "宋江".equals(demo.getLeader()));
        // noneMatch  判断是否不存在 领导是宋江的
        Boolean d = demoList.stream().noneMatch(demo -> "宋江".equals(demo.getLeader()));

        // findFirst 返回领导是宋江的 一个值
        Optional<Demo> demoFirst = demoList.stream().filter(demo -> "宋江".equals(demo.getLeader())).findFirst();
        demoFirst.get().getLeader();

        // findany 返回领导是宋江的 返回任意一个
        Optional<Demo> demoFirst1 = demoList.stream().filter(demo -> "宋江".equals(demo.getLeader())).findAny();
        demoFirst1.get().getLeader();

        // reduce  累加
        List<Integer> numList = Arrays.asList(1,2,3,4,5);
        int result = numList.stream().reduce((fa,f) -> fa + f).get();
        System.out.println(list);
    }