java8中的lambda表达式,看这篇绝对够

//1、单个参数

(String s)->s.length()

//2、单个对象

(Apple a)->a.getWeight()> 150

//3、多参数,多语句

( int a, int b)->{

     System.out.println(a);

     System.out.println(b);

}

//4、空参数,返回int值42

()-> 42

//5、多对象参数

(Applea1,Applea2)->a1.getWeight()测试数据pareTo(a2.getWeight())

List<Apple> c=filter(inventory,a-> "green" .equals(a.getColor()));

Comparator<Apple> c=(a1,a2)->a1.getWeight测试数据pareTo(a2.getWeight());

/**

  * java.util.Predicate 是一个只有test方法，返回布尔值的一个函数式接口，

  * 与其类似的还有用于比较，排序的Comparator接口，其只有一个返回整数的比较接口

  * @param list

  * @param p

  * @param <T>

  * @return

  */

public static <T> List<T> filter(List<T> list, Predicate<T> p){

     List<T> result= new ArrayList<>();

     for (T t : list) {

         if (p.test(t))

             result.add(t);

     }

     return result;

}

public static void main(String[] args) {

     //Predicate函数式接口示例

     List<Apple> appleList= new ArrayList<>();

     List<Apple> resulAppleList=filter(appleList,(Apple a)->a.getColor().equals( "red" ));

}

     /**

      * 常用2：Consume

      * consume接口定义了一个 名为accept的抽象方法，接收泛型 T 返回void

      * 可用来访问T类型的对象，并且执行某些操作。

      * 如下用其创建，一个foreach方法，可以实现对所有List的遍历。且对每个对象执行consume定义的操作。

      * 该foreach方法，java8之后成了List接口的default方法。

      * @param list

      * @param <T>

      */

     public static <T> void foreach(List<T> list, Consumer<T> consumer){

         for (T t : list) {

             consumer.accept(t);

         }

     }

  //Consume函数式接口示例,遍历列表执行某项操作

foreach(appleList,(Apple a)->{ if (a.getColor()== null );a.setColor( "garly" );});

appleList.forEach((Apple a)->{ if (a.getColor()== null );a.setColor( "garly" );});

/**

  * 常用2：Consume

  * consume接口定义了一个 名为accept的抽象方法，接收泛型 T 返回void

  * 可用来访问T类型的对象，并且执行某些操作。

  * 如下用其创建，一个foreach方法，可以实现对所有List的遍历。且对每个对象执行consume定义的操作。

  * 该foreach方法，java8之后成了List接口的default方法。

  * @param list

  * @param <T>

  */

public static <T> void foreach(List<T> list, Consumer<T> consumer){

     for (T t : list) {

         consumer.accept(t);

     }

}

     //Consume函数式接口示例,遍历列表执行某项操作

     foreach(appleList,(Apple a)->{ if (a.getColor()== null );a.setColor( "garly" );});

     appleList.forEach((Apple a)->{ if (a.getColor()== null );a.setColor( "garly" );});

List<Apple>apples=newArrayList<>();

apples.add(newApple( "red" , 11 ));

apples.add(newApple( "red" , 12 ));

apples.add(newApple( "green" , 13 ));

/**

*对排序lanmbda进行复复合-比较器链

*1、默认逆序方法：reversed()

*2、多级比较：thenComparing()

*example:对apples按照颜色排序后，进行逆序，如果颜色一样再按照重量递增

*/

Comparator<Apple>comparator=Comparator测试数据paring(Apple::getColor).reversed().thenComparing(Apple::getWeight);

apples.sort(comparator);

/**

*谓词复合且、或、非

*1、negate否定

*2、and且

*3、or或

*example：对不是红色的苹果进行过滤，且收集重量大于100的苹果

*/

Predicate<Apple>redApplePredicate=a->a.getColor().equals( "red" );

Predicate<Apple>notRedApple=redApplePredicate.negate();

List<Apple>notRedAppleList=apples.stream().filter(notRedApple.and(apple->apple.getWeight()> 100 )).collect(Collectors.toList());

/**

*函数复合

*1、andThen将前一lambda执行结果，作为后一表达式的参数

*2、compose将后一表达式的结果作为前一表达式的参数

*example；complexReult=g(f(x))例如g(f(1))step1:1+1=2step2:(1+1)*2+""

*/

Function<Integer,Integer>f=x->x+ 1 ;

Function<Integer,String>g=x->x* 2 + "" ;

Function<Integer,String>complexResult1=f.andThen(g);