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().compareTo(a2.getWeight())

List<Apple> c=filter(inventory,a->"green".equals(a.getColor()));
Comparator<Apple> c=(a1,a2)->a1.getWeight.compareTo(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.comparing(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);