一.Lambda表达式

1.Predicate函数式接口

Predicate接口定义了一个test抽象方法，可以接受范型T,并返沪一个boolean。可以用于通过判断筛选数据的操作

  1. public class PredicateMain {
  2.     /*Predicate是函数式接口，test方法返回一个Boolean值*/
  3.     public static <T> List<T> filter(List<T> list, Predicate<T> p) {
  4.         List<T> results = new ArrayList<>();
  5.         for (T t : list) {
  6.             if (p.test(t)) {
  7.                 results.add(t);
  8.             }
  9.         }
  10.         return results;
  11.     }
  13.     public static void main(String[] args) {
  14.         List<String> stringList = Arrays.asList("", "aa", "bb");
  15.         /*实现函数式接口，并将具体业务逻辑注入*/
  16.         Predicate<String> noEmptyStringPredicate = (String s) -> !s.isEmpty();
  17.         List<String> noEmpty = filter(stringList, noEmptyStringPredicate);
  18.         System.out.println(noEmpty.toString());
  20.         Predicate<String> stringPredicate=(String s) ->s.length()==5;
  21.         System.out.println("result: "+stringPredicate.test("Hello"));
  22.     }
  23. }

2.Consumer函数式接口

Consumer接口定义了一个accept的抽象方法，可以接受范型T，并且不返回方法。可以用于一些计算逻辑

  1. public class ConsumerMain {
  3.     public static <T> void fotEach(List<T> list, Consumer<T> c) {
  4.         for (T t : list) {
  5.             c.accept(t);
  6.         }
  7.     }
  9.     public static void main(String[] args) {
  10.         List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6);
  11.         fotEach(integerList, (Integer i) -> System.out.println(i));
  13.         Consumer<String> stringConsumer = (String s) -> System.out.println(s + " World!");
  14.         stringConsumer.accept("Hello");
  15.     }
  16. }

3.Function函数式接口

Function接口定义了一个叫做apply方法，可以接受范型T，并且返回范型T。可以用于将对象属性组装成一个新的集合

  1. public class FunctionMain {
  2.     public static <T, R> List<R> map(List<T> list, Function<T, R> f) {
  3.         List<R> result = new ArrayList<>();
  4.         for (T s : list) {
  5.             result.add(f.apply(s));
  6.         }
  7.         return result;
  8.     }
  10.     public static void main(String[] args) {
  11.         List<String> stringList = Arrays.asList("aaaa", "bbb", "cc", "d");
  12.         List<Integer> integerList = map(stringList, (String s) -> s.length());
  13.         System.out.println(integerList);
  15.         Function<Integer, String> function = (Integer o) -> String.valueOf(o + 100);
  16.         System.out.println("result: " + function.apply(4));
  17.     }
  18. }

4.Supplier函数式接口

Function接口定义了一个叫做get方法，不接受参数，并且返回范型T，相当于对象创建工厂。

  1. public static void main(String[] args) {
  2.         Supplier<Apple> appleSupplier=()->new Apple(100);
  3.         System.out.println(appleSupplier.get());
  4.     }

5.BiFunction函数式接口

表示一个接受两个参数并返回范型T的函数。

  1.   public static void main(String[] args) {
  2.         BiFunction<String,Integer,Apple> appleBiFunction=Apple::new;
  3.         Apple apple=appleBiFunction.apply("red",160);
  4.         System.out.println(apple);
  5.     }

5.构造函数引用

  1.     public static void main(String[] args) {
  2.         Function<Integer, Apple> appleFunction = Apple::new;
  3.         /*等价于以下代码*/
  4. //       Function<Integer,Apple> appleFunction1=integer -> new Apple(integer);
  5.         Apple apple = appleFunction.apply(150);
  6.         System.out.println(apple);
  7.     }

6.谓词复合

  1. public class LambdaMain {
  3.     public static <T> List<T> filter(List<T> list, Predicate<T> p) {
  4.         List<T> results = new ArrayList<>();
  5.         for (T t : list) {
  6.             if (p.test(t)) {
  7.                 results.add(t);
  8.             }
  9.         }
  10.         return results;
  11.     }
  13.     public static void main(String[] args) {
  14.        List<Apple> appleList=Arrays.asList(new Apple("red",130),
  15.                new Apple("yellow",110),
  16.                new Apple("green",120),
  17.                new Apple("green",110));
  18.         Predicate<Apple> applePredicate=apple -> "red".equals(apple.getColor());
  19.         System.out.println(filter(appleList,applePredicate));
  20.         Predicate<Apple> noApplePredicate=applePredicate.negate();
  21.         System.out.println(filter(appleList,noApplePredicate));
  23.         Predicate<Apple> redAndHeavyApple=noApplePredicate.and(apple -> apple.getWeight()>110);
  24.         System.out.println(filter(appleList,redAndHeavyApple));
  26.     }
  27. }

7.函数复合

  1. public class Letter {
  3.     public static String addHeader(String text){
  4.         return "From Raoul,Mario and Alan:"+text;
  5.     }
  7.     public static String addFooter(String text){
  8.         return text+"Kind regards";
  9.     }
  11.     public static String checkSpelling(String text){
  12.         return text.replaceAll("labda","lambda");
  13.     }
  15.     public static void main(String[] args) {
  16.         Function<String,String> addHeader=Letter::addHeader;
  17.         Function<String,String> transformtionPipeline=addHeader.andThen(Letter::checkSpelling).andThen(Letter::addFooter);
  18.         Function<String,String> transformtionPipeline1=addHeader.andThen(Letter::addFooter);
  20.         System.out.println(transformtionPipeline.apply("11"));
  21.         System.out.println(transformtionPipeline1.apply("11"));
  22.     }
  23. }