1. 方法引用demo1
package com.tina.demolambda.demo0826;
import com.tina.demolambda.util.User;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.io.PrintStream;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.*;
/**
* @program: demo-lambda
* @description 方法的引用 ：也是函数式接口的实例
* <p>
* 方法引用使用的要求：
* 要求接口中的抽象方法的形参列表和返回值类型与发放引用的发放的形参列表和返回值类型相同
* @author: tina.liu
* @create: 2020-08-26 09:11
**/
@Slf4j
public class Demo {
/**
* 情况一： 对象：：实例发放
* Consumer中的void accept(T t)
* PrintStream中的void println(T t)
*/
@Test
public void test2() {
User user = new User(1, "xiaokai");
Supplier<String> sup1 = () -> user.getAccount();
System.out.println(sup1.get());
log.info("####################################");
Supplier<String> sup2 = user::getAccount;
System.out.println(sup2.get());
Consumer<String> con1 = str -> System.out.println(str);
con1.accept("北京");
log.info("####################################");
PrintStream ps = System.out;
Consumer<String> con2 = ps::println;
}
/**
* 情况二 类：：静态方法
* Comparator中的int compare(T t1, T t2)
* Integer中的int compare(T t1, T t2)
*/
@Test
public void test1() {
Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
//log.info("值为{}",com1.compare(2,3));
Comparator<Integer> com2 = Integer::compare;
log.info("值为{}",com1.compare(0,0));
}
/**
* Function中的R apply(T t)
* Math中的Long roud(Double d) 方法的引用
*
*/
@Test
public void test3(){
//1 第一种写法
Function<Double,Long> function = new Function<Double, Long>() {
@Override
public Long apply(Double aDouble) {
return Math.round(aDouble);
}
};
// 2 第二种写法
Function<Double,Long> function2 = aDouble -> Math.round(aDouble);
//3 第三种写法
Function<Double,Long> function3 = Math::round;
log.info("值为{}",function3.apply(8.99));
}
/**
*
* 类：：实例方法
* Comparator 中的int compare(T1 t1,T2 t2)
* String中的int t1.compareTo(t2)
*/
@Test
public void test4(){
// 第一种写法
Comparator<String> comparator = new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
};
//第二种写法
Comparator<String> comparator2 = ((o1, o2) -> o1.compareTo(o2));
// 第三种写法
Comparator<String> comparator3 = String::compareTo;
log.info("值为{}",comparator3.compare("0","2"));
}
/**
* BigPredicate中的boolean test(T t1,T t2)
* String中的boolean t1.equals(t2)
*
*/
@Test
public void test5(){
// 第一种写法
BiPredicate<String,String> biPredicate = new BiPredicate() {
@Override
public boolean test(Object o, Object o2) {
return o.equals(o2);
}
};
//第二种写法
BiPredicate<String,String> biPredicate2 = ((o, o2) -> o.equals(o2));
// 第三种写法
BiPredicate<String,String> biPredicate3 = String::equals;
log.info("返回的值为{}",biPredicate3.test("3","5"));
}
/**
* Function中的R apply(T t)
* Employee中的String getName()
*
*/
@Test
public void test6(){
User user = new User(1, "xiaokai");
// 第一种写法
Function<User,String> function = new Function<User, String>() {
@Override
public String apply(User user) {
return user.getAccount();
}
};
// 第二种写法
Function<User,String> function2 = user1 -> user.getAccount() ;
//第三种写法
Function<User,String> function3 = User::getAccount;
log.info("返回值为{}",function3.apply(user));
}
///////////////构造器方法的引用和，数组的引用////////////////
/**
*
* 构造器的引用
*/
@Test
public void TEST1(){
// 1 第一种方法
Supplier<User> user = new Supplier<User>() {
@Override
public User get() {
return new User();
}
};
//2 第二种方法
Supplier<User> user2 = ()->new User();
//3 第三种方法
Supplier<User> user3 = User::new ;
User user1 = user3.get();
log.info(" 返回值的为{}",user1);
}
// BiFunction 中的R apply（T t,U u）
@Test
public void test(){
BiFunction<Integer,String,User> function1 = new BiFunction<Integer, String, User>() {
@Override
public User apply(Integer integer, String s) {
User user = new User();
user.setAccount(s);
user.setId(integer);
return user;
}
};
//log.info("返回的值为{}",function1.apply(1,"tina"));
BiFunction<Integer,String,User> function2 = (id,account) -> new User(id,account);
log.info("返回的值为{}",function2.apply(1,"tina"));
BiFunction<Integer,String,User> function = User::new;
log.info("返回的值为{}",function.apply(1,"tina"));
}
/**
* 数组的引用
* Function中 R apply(T t)
*
*/
@Test
public void TEST3(){
Function<Integer,String[]> function = new Function<Integer, String[]>() {
@Override
public String[] apply(Integer integer) {
return new String[integer];
}
};
String[] arr = function.apply(5);
//log.info("打印的值为{}", Arrays.toString(arr));
Function<Integer,String[]> function1 = length -> new String[length];
String[] arr1 = function1.apply(5);
//log.info("打印的值为{}", Arrays.toString(arr1));
Function<Integer,String[]> function3 = String[]::new ;
String[] arr3 = function3.apply(10);
log.info("打印的值为{}", Arrays.toString(arr3));
}
}
1. 方法引用demo
/**
* 方法引用
* 对象::静态方法名
* 类::静态方法名
* 类::实例方法名
*
*/
@Test
public void test3(){
//数组引用
Function<Integer,String[]> function3 = (x) ->new String[x];
Function<Integer,String[]> function4 = String[]::new ;
//对象:: 静态方法名字
Supplier<Student> supplier3 = ()->new Student() ;
Supplier<Student> supplier4 = Student::new; //构造器引用 (具体调用哪个构造器，取决传入的参数)
Function<Integer,Student> function1 = (x)-> new Student(x);
Function<Integer,Student> function2 = Student::new;//构造器引用 (具体调用哪个构造器，取决传入的参数)
//类::静态方法
Comparator<Integer> comparator1 = (x,y) ->Integer.compare(x,y);
Comparator<Integer> comparator2 = Integer::compareTo;
//对象::实例方法名字
Consumer con2 = System.out::println;
Student student = new Student();
Supplier getAge = student::getAge;
}
网友评论