Lambda表达式
<一>基本用法讲述
@FunctionalInterface
public interface IService {
void serviceLog();
}
import com.jvm.learn.inter.IService;
import org.junit.Test;
public class TestLambda1 {
/**
* 测试说明: 测试时根据条件去修改IService接口中的方法
*/
/**
* 对Lambda表达式的简单理解:
* () 是要参数列表,当没有参数时不可以省略
* ()->{} 其实相当于一个类去实现了IService接口,然后通过多态向上转型为父类对象
* 这样IService就可以调用子类[ ()->{} ]实现的方法了
*/
//无参数无返回值类型
@Test
public void testLambda1(){
IService service = () -> {
System.out.println("无参数无返回值类型");
};
service.serviceLog();
}
//只有一个参数无返回值类型
@Test
public void testLambda2(){
// IService service = (String str)->{
// System.out.println(str);
// };
// service.serviceLog("hello");
//简化写法 ---> 由于在声明抽象方法时就已经指定参数类型,因此参数类型可以省略;只有一个参数时,()也可省略
// IService service = str -> {
// System.out.println(str.toLowerCase());
// };
// service.serviceLog("HellO");
}
//两个参数无返回值类型
@Test
public void testLambda3(){
// IService service = (str1,str2)->{
// System.out.println(str1+"今年"+str2+"岁");
// };
// service.serviceLog("yby","21");
}
//有返回值类型没有参数
@Test
public void testLambda4(){
// IService service = ()->{
// return "good night";
// };
// System.out.println(service.serviceLog());
//简化写法: 当只有return语句时,{}可以省略,同时return也必须省略
// IService service=()->"你好";
// System.out.println(service.serviceLog());
}
//有返回值类型+一个参数
@Test
public void testLambda5(){
// IService service = str -> {
// return str.toLowerCase();
// };
// System.out.println(service.serviceLog("HELLO WORLD!"));
//简化写法
// IService service = str -> str.toUpperCase();
// System.out.println(service.serviceLog("hello world"));
}
//有两个参数+返回值类型
@Test
public void testLambda6(){
// IService service = (str1,str2)-> str1+":"+str2;
// System.out.println(service.serviceLog("Object","java"));
}
}
<二>进阶
@FunctionalInterface
public interface IService2 {
double checkOut(double a,double b);
}
import com.jvm.learn.Service2Impl;
import com.jvm.learn.bean.Person;
import com.jvm.learn.inter.IPerson1;
import com.jvm.learn.inter.IPerson2;
import com.jvm.learn.inter.IService2;
import org.junit.Test;
public class TestLambda2 {
@Test
public void lambda1(){
Service2Impl service2Impl = new Service2Impl();
IService2 user1 = (a,b)-> service2Impl.checkOutImpl(a,b);
System.out.println(user1.checkOut(12.90, 15.06));
IService2 user2 = (a,b)-> service2Impl.checkOutImpl(a,b);
System.out.println(user2.checkOut(23, 89));
IService2 user3 = service2Impl::checkOutImpl;
System.out.println(user3.checkOut(234, 29));
}
@Test
public void lambda2(){
IPerson1 ipersonA = ()-> new Person();
IPerson1 ipersonB = Person::new;
Person personA = ipersonA.getNoneParamPerson();
Person personB = ipersonB.getNoneParamPerson();
System.out.println(personA+" "+personB);
IPerson2 iPersonC = Person::new;
Person personC = iPersonC.getWithParamPerson("yby",21);
System.out.println(personC);
}
}
<三>JDK1.8引入的函数式接口
import com.jvm.learn.bean.Person;
import com.jvm.learn.inter.IService3;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
public class TestLambda3 {
@Test
public void sort1(){
List<Person> persons = Arrays.asList(new Person("张三",17),new Person("李四",12),new Person("小红",14),new Person("王五",21));
persons.sort((per1,per2)->per1.getAge()-per2.getAge());
System.out.println(persons);
}
public static Supplier<Integer> getNum(){
int num = 10;
return ()-> num;
}
public int getNum2(){
int num = 20;
return num;
}
@Test
public void testClosure1(){
System.out.println(getNum().get());
System.out.println(this.getNum2());
}
@Test
public void testClosure2(){
int a = 21;
Consumer<Integer> consumer = ele-> System.out.println(a);
consumer.accept(6);
}
public static void showLog(int level,String msg){
if (level == 1) System.out.println(msg);
}
public static void showLog2(int level, IService3 service3){
if (level == 1) System.out.println(service3.buildMsg());
}
@Test
public void testLazyExe(){
String msg1 = "Hello";
String msg2 = "World";
showLog(2,msg1+msg2);
showLog2(2,()->msg1+msg2);
}
public static int getMax(Supplier<Integer> supplier){
return supplier.get();
}
@Test
public void supplier(){
int[] arr = {23,63,34,84,234,456,24,10,8,2,236,109,87};
int max = getMax(()->{
int m = arr[0];
for (int num: arr) {
if (num > m) m = num;
}
return m;
});
System.out.println(max);
}
public static void consume(String str,Consumer<String> consumer){
consumer.accept(str);
}
@Test
public void consumer(){
consume("HELLO WORLD",str -> {
System.out.println(new StringBuffer(str).reverse().toString());
});
}
public static void printInfo(String str,Consumer<String> first,Consumer<String> second){
first.andThen(second).accept(str);
}
@Test
public void addThen(){
printInfo("HEllo wOrlD,JaVA",
first-> System.out.println(first.toLowerCase()),
second-> System.out.println(second.toUpperCase())
);
}
public static boolean predicate(String str, Predicate<String> predicate){
return predicate.test(str);
}
@Test
public void testPredicate(){
boolean result = predicate("Hello World",str -> str.equals("HELLO WORLD"));
System.out.println(result);
}
public static boolean add(String str,Predicate<String> pre1,Predicate<String> pre2){
return pre1.and(pre2).test(str);
}
@Test
public void testAdd(){
boolean result = add("Hello",
str->str.length()>3,
str->str.contains("H")
);
System.out.println(result);
}
public static void change(String s, Function<String,Integer> fun){
System.out.println(fun.apply(s));
}
@Test
public void apply(){
change("2343",str->Integer.parseInt(str));
}
}