简用 lambda 自己做笔记复习，处理list及数组

先声明一个 测试用实体

import lombok.Data;

@Data
public class CartDTO {

    /** 商品Id. */
    private String productId;

    /** 数量. */
    private Integer productQuantity;

    public CartDTO(String productId, Integer productQuantity) {
        this.productId = productId;
        this.productQuantity = productQuantity;
    }
 
    public CartDTO(String productId) {
        this.productId = productId;
    }   
}

声明一个 list

	List <CartDTO> ls =new LinkedList<CartDTO>();
	ls.add(new CartDTO("1",2));
	ls.add(new CartDTO("3",4));
	ls.add(new CartDTO("5",6));

filter
选出数量>3的，打印出来

	ls.stream().filter(e->e.getProductQuantity()>3).forEach(giveRaise);
	ls.forEach(System.out::println);

选出数量>3的，再加两个

	ls.stream().filter(e->e.getProductQuantity()>=3)
					.forEach(e->e.setProductQuantity(e.getProductQuantity()+2));

将条件声明为一个方法，再去重复操作

		//将对象+2
	Consumer<CartDTO> giveRaise = e->e.setProductQuantity(e.getProductQuantity()+2);  
		//通过filter过滤对象，再进行添加
	ls.stream().filter(e->e.getProductQuantity()>3).forEach(giveRaise);
		//打印
	ls.forEach(System.out::println);

表达式里面调用自己的方法

	ls.stream().filter(e->e.getProductQuantity()>3).map(e->test(e));
	ls.stream().map(e->test(e));

	static CartDTO test(CartDTO da){
		String productId = da.getProductId();
		productId.substring(0, 2);
		da.setProductId(productId);
		return da;
	}
	

List < Object > --> 自定义List<>
自定义的如果是对象，则先实现构造函数

List<CartDTO> collect2 = ls.stream().map(e -> new CartDTO(e.getProductId())).collect(Collectors.toList());

List < Object > --> Set< Object>

Set<CartDTO> collect = ls.stream().map(e->new CartDTO(e.getProductId(),
				e.getProductQuantity())).collect(Collectors.toSet());

获取List里面所有对象的id

List<String> ids= ls.stream().map(e->e.getProductId())
	.collect(Collectors.toList());

优雅的判断一个数组（二维数组）里面是否包含一个数值，并返回
min,max,average()…

	int [][] array ={{2,3,4,5},{2,4,45,4},{4,7,66,4}};
    public boolean Find(int target, int [][] array) {
    	int[] array2 = null;
    	for (int[] is : array) {
    	//	IntStream.of(is).filter(e->e==target).forEach(System.out :: print);    打印
    		array2 = IntStream.of(is).filter(e->e==target).toArray();
    		for (int i : array2) {
    			System.out.println(i);
			}
		}
    	if(null!=array2){
    		return true;
    	}else{
    		return false;
    	}
    }

	int[] nums = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
//	IntStream.of(nums).filter(predicate);
	int min = IntStream.of(nums).min().getAsInt();
	System.out.println(min);

取代匿名函数

   new Thread( new Runnable() {
		public void run() {
			CartDTO.test();	
		}
	}).start(); //CartDTO.enclosing_method()

    new Thread(()->CartDTO.test()).start();//CartDTO.enclosing_method()

	static void test(){
	System.out.println("CartDTO.enclosing_method()");
}

函数接口，还不知道代码里面怎么用

		// 提供数据接口
	    Supplier<Integer> supplier = () -> 10 + 1;
	    System.out.println("提供的数据是：" + supplier.get());

	    // 一元函数接口
	    UnaryOperator<Integer> unaryOperator = i -> i * 2;
	    System.out.println("计算结果为：" + unaryOperator.apply(10));
	    
	    // 二元函数接口
	    BinaryOperator<Integer> binaryOperator = (a, b) -> a * b;
	    System.out.println("计算结果为：" + binaryOperator.apply(10, 10));
	}

** -> 左边的是输入,右边的数输出 ，这个东西很屌，性能也不错，似乎bug不好找，好多程序员不会用，装逼需谨慎**