Lambda表达式及方法的引用

Lambda是java8的一个新特性，是一个匿名函数，所有的匿名实现类都可以用Lambda表达式来写，使用箭头操作符进行标识，它本质上是作为一个接口的实例出现的，因此用Lambda表达式，该接口一定是函数式接口。
Lambda表达式在进行操作的过程中，主要针对以下参数和返回值类型进行设置
1.无参无返回值的类型

@Test
public void test(){
    Runnable run=new Runnable() {
        @Override
        public void run() {
            System.out.println("无参无返回值");
        }
    };

    // lambda表达式写法：
    Runnable run1=() ->System.out.println("无参无返回值");
}

2.有参数无返回值类型

@Test
public void test1(){
    Consumer<String>con=new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    con.accept("有参数没有返回值");
    System.out.println();

    // lambda表达式写法：
    Consumer<String>con1=(String s) -> {
        System.out.println(s);
    };
    con1.accept("有参数没有返回值");
}

3.数据类型可以省略，根据编译器就可以进行类型推断

// lambda表达式写法：
Consumer<String>con2=(s) -> {
    System.out.println(s);
};
con2.accept("有参数没有返回值");

4.Lambda表达式只有一个参数，参数的小括号可以省略

// lambda表达式写法：
Consumer<String>con3=s -> {
    System.out.println(s);
};
con3.accept("有参数没有返回值");

5.Lambda需要两个或两个以上的参数，多条执行语句，并且可以有返回值

@Test
public void test3(){
    Comparator<Integer>com=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(com.compare(21,12));

    // lambda表达式写法：
    Comparator<Integer>com1=(o1,o2)->{
        System.out.println(o1);
        System.out.println(o2);
        return o1.compareTo(o2);
    };
    System.out.println(com1.compare(12,39));
}

6.Lambda只有一条语句，{}、return都可以省略不写

@Test
public void test4(){
    Comparator<Integer>com1=(o1,o2)->{
        return o1.compareTo(o2);
    };
    System.out.println(com1.compare(12,39));

    // lambda表达式写法：
    Comparator<Integer>com2=(o1,o2)-> o1.compareTo(o2);
    System.out.println(com2.compare(12,8)); 
}

方法的引用也是java8的新特性，方法的引用时间里在Lambda体上的操作，其本质上还是Lambda表达式。
方法的引用主要针对三种情况，对象的非静态方法引用，类的静态方法引用，类的非静态方法引用
1.对象的非静态方法的引用

// 情况一：对象 :: 实例方法
//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
@Test
public void test1() {
	Consumer<String>con1= s-> System.out.println(s);
	con1.accept("北京");

	// 方法引用
	PrintStream ps= System.out;
	Consumer<String>con2= ps::println;
	con2.accept("北京");
}

//Supplier中的T get()
//Employee中的String getName()
@Test
public void test2() {
	Employee emp=new Employee(1001,"tom",23,5600);
	Supplier<String>sup1=()->emp.getName();
	System.out.println(sup1.get());

	// 方法引用
	Supplier<String>sup2=emp::getName;
	System.out.println(sup2.get());
}

2.1类的静态方法的引用：

// 情况二：类 :: 静态方法
//Comparator中的int compare(T t1,T t2)
//Integer中的int compare(T t1,T t2)
@Test
public void test3() {
	Comparator<Integer>com=(t1,t2)->Integer.compare(t1,t2);
	System.out.println(com.compare(12,56));
	
// 方法引用
	Comparator<Integer>com1=Integer::compare;
	System.out.println(com1.compare(12, 3));
}


//Function中的R apply(T t)
//Math中的Long round(Double d)
@Test
public void test4() {
	Function<Double,Long>fun=d->Math.round(d);

	// 方法的引用
	Function<Double,Long>fun1=Math::round;
}

2.2类的非静态方法的引用：

// 情况三：类 :: 实例方法 
// Comparator中的int comapre(T t1,T t2)
// String中的int t1.compareTo(t2)
@Test
public void test5() {
	Comparator<String>com=(s1,s2)->s1.compareTo(s2);
	System.out.println(com.compare("abc","afd"));

	// 方法的引用
	Comparator<String>com2=String::compareTo;
	System.out.println(com2.compare("fdg","gej"));
}

//BiPredicate中的boolean test(T t1, T t2);
//String中的boolean t1.equals(t2)
@Test
public void test6() {
	BiPredicate<String,String>pre1=(s1,s2)->s1.equals(s2);
	System.out.println(pre1.test("abc","dfi"));

	// 方法的引用
	BiPredicate<String,String>pre2=String::equals;
	System.out.println(pre2.test("abc","abc"));
	
}