lambda表达式的使用

学习笔记：lambda表达式

---

一、Lambda基本使用

1、无参数 无返回值

@Test
    public void test1() {
        //原生写法:Runnable接口匿名内部类
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("原生");
            }
        };
        r1.run(); //原生
        //Lambda写法
        Runnable r2 = () -> {
            System.out.println("lambda");
        };
        r2.run();//lambda
    }

2、一个参数 无返回值

 @Test
    public void test2() {
        //原来写法
        Consumer<String> c1 = new Consumer<>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        c1.accept("原来写法");//原来写法
        //lambda
        Consumer<String> c2 = (s) -> {
            System.out.println(s);
        };
        c2.accept("lambda");//lambda
    }

3、类型推断 省略类型

@Test
    public void test4() {

        Consumer<String> c1 = (String s) -> {
            System.out.println(s);
        };
        c1.accept("没有省略数据类型");

        Consumer<String> c2 = (s) -> {
            System.out.println(s);
        };
        c2.accept("省略数据类型");
    }

4、一个参数 省略小括号

@Test
    public void test5() {
        Consumer<String> c = s -> {
            System.out.println(s);
        };
        c.accept("省略小括号");
    }

5、两个或两个以上参数 多条执行语句 可以有返回值

@Test
    public void test6(){
        //原来匿名内部类写法
        Comparator<Integer> c1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        System.out.println(c1.compare(12,34));//第一个参数大于第二个参数则返回1，小于返回-1，相等返回0
        //lambda写法
        Comparator<Integer> c2 = (o1,o2)->{
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(c2.compare(34, 34));
    }

6、一条执行语句 方法体内return和大括号可省略

@Test
    public void test7(){
        Comparator<Integer> c1 = (o1,o2)-> o1.compareTo(o2);
        System.out.println(c1.compare(99, 1));
    }

二、函数式接口

  接口中只有一个抽象方法被称为函数式接口

/**
 * 常见的函数式接口,可通过lambda表达式直接创建该实现对象
 *
 *              接口名             抽象方法
 * 消费型接口：Consumer<T>        void accept(T t)
 * 供给型接口：Supplier<T>        T get()
 * 函数型接口：Function<T,R>      R apply(T t)
 * 断定型接口：Predicate<T>       boolean test(T t)
 */

Consumer：

    @Test
    public void test1() {
        Consumer<Integer> c = x -> System.out.println(x);
        c.accept(100);
    }

Supplier：

    /**
     * @param size 产生size个数
     * @param supplier
     * @return
     */
    public static List addNum(int size, Supplier<Integer> supplier) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < size; i++) { 
            list.add(supplier.get());  //调用get()产生一个随机数，并添加到list集合中
        }
        return list;
    }
    
    @Test
    public void test2() {
        //原来的匿名内部类写法
        List<Integer> list = addNum(5, new Supplier<Integer>() {
            @Override
            public Integer get() {  //调用get()即随机产生一个0到100的整数
//                Math.random()  产生[0,1)之间的随机数
//                Math.random()*100  产生[0,100)之间的随机数
//                (int)Math.random()*100  产生[0,100)之间的随机整数
                return (int) (Math.random() * 100);
            }
        });

        //lambda写法(无参数，方法体只有一句返回值语句，省略了return和大括号)
        List<Integer> list1 = addNum(5, () -> (int) (Math.random() * 100));

        //遍历输出list1
        list1.forEach(t -> System.out.println(t)); //lambda的输出语句
        System.out.println("~~~~~~~~~~~~~~~~~~");
        list1.forEach(System.out::println);  //方法引用输出语句
    }

Function:

    public String handler(String s, Function<String, String> function) {
        return function.apply(s);
    }

    @Test
    public void test3() {
        //原来写法
        String s1 = handler("ABCD", new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.toLowerCase();
            }
        });
        System.out.println(s1); //abcd
        //lambda写法
        String s2 = handler("abcd", s -> s.toUpperCase());
        System.out.println(s2);//ABCD
    }

Predicate:

    /**
     * @param list      传进来的list集合
     * @param predicate 根据规则过滤掉集合中的整数值
     * @return 返回满足条件的list
     */
    public List<Integer> filterInteger(List<Integer> list, Predicate<Integer> predicate) {
        List<Integer> list1 = new ArrayList<>();
        for (Integer i : list) {
            if (predicate.test(i)) {
                list1.add(i);
            }
        }
        return list1;
    }

    @Test
    public void test4() {
        //原来的写法，声明匿名内部类
        List<Integer> list = Arrays.asList(1, -9, 8, 98, 7, 45, -3);
        List<Integer> list2 = filterInteger(list, new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 0; //若大于0则满足条件
            }
        });
        list2.forEach(System.out::println);
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~");

        //lambda写法
        List<Integer> list1 = Arrays.asList(1, -9, 8, 98, 7, 45, -3);
        List<Integer> list3 = filterInteger(list1, integer -> integer > 0);
        list3.forEach(System.out::println);
    }

三、方法引用

/**
 * 方法引用的使用:
 * 		使用格式：类（对象）::方法名
 * 		使用情况：
 * 			1、对象 :: 实例方法   实例方法即非静态方法
 * 			2、类 :: 静态方法
 * 			3、类 :: 实例方法
 * 		使用的要求：接口中的形参列表与返回值类型 和 方法引用的方法的形参列表与返回值类型 得相同(针对于情况1、2)
 */

对象 :: 实例方法

	
	//Consumer中的void accept(T t)
	//PrintStream中的void println(T t)

	@Test
	public void test1() {
		//Lambda表达式使用
		Consumer<String> con1 = str-> System.out.println(str);
		con1.accept("深圳");
		//方法引用的使用
		PrintStream ps = System.out;
		Consumer<String> con2 = ps::println;
		con2.accept("广州");
	}
	
	//Supplier中的T get()
	//Employee中的String getName()
	@Test
	public void test2() {
		Employee employee = new Employee(1001,"jerry",23,15000);
		//Lambda表达式
//		Supplier<String> s1 = () -> employee.getName();
//		System.out.println(s1.get());
		//方法引用的使用
		Supplier<String> s2 = employee::getName;
		System.out.println(s2.get());
	}

类 :: 静态方法

	//Comparator中的int compare(T t1,T t2)
	//Integer中的int compare(T t1,T t2)
	@Test
	public void test3() {
		//Lambda表达式
		Comparator<Integer> com1 = (t1,t2)->Integer.compare(t1,t2);
		System.out.println(com1.compare(14, 66));
		//方法引用的使用
		Comparator<Integer> com2 = Integer::compare; //此处 形参列表和上面一样，可省略了
		System.out.println(com2.compare(66, 44));
	}
	
	//Function中的R apply(T t)
	//Math中的Long round(Double d)
	@Test
	public void test4() {
		//普通写法
		Function<Double,Long> fun = new Function<>() {
			@Override
			public Long apply(Double d) {
				return Math.round(d);
			}
		};
		//Lambda
		Function<Double,Long> fun1 = (d)-> Math.round(d); //return和大括号删掉了
		System.out.println(fun1.apply(12.5));
		//方法引用
		Function<Double,Long> fun2 = Math::round; //形参列表一样，可以省略
		System.out.println(fun2.apply(12.5));
	}

类 :: 实例方法

 
	// Comparator中的int comapre(T t1,T t2)
	// String中的int t1.compareTo(t2)
	@Test
	public void test5() {
		//Lambda
		Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
		System.out.println(com1.compare("abc","cfd"));
		//方法引用
		Comparator<String> com2 = String::compareTo;
		System.out.println(com2.compare("abc", "cfd"));
	}

	//BiPredicate中的boolean test(T t1, T t2);
	//String中的boolean t1.equals(t2)
	@Test
	public void test6() {
		//Lambda
		BiPredicate<String,String> bp = (s1,s2)->s1.equals(s2);
		System.out.println(bp.test("abc", "abc"));
		//方法引用
		BiPredicate<String,String> bp1 = String::equals;
		System.out.println(bp1.test("bn", "bn"));

	}
	
	// Function中的R apply(T t)
	// Employee中的String getName();
	@Test
	public void test7() {
		//Lambda
		Employee employee = new Employee(1001, "herry", 22, 16000);
		Function<Employee,String> fun1 = e -> e.getName();
		System.out.println(fun1.apply(employee));
		//方法引用
		Function<Employee,String> fun2 = Employee::getName;
		System.out.println(fun2.apply(employee));
	}