JAVA8新特性之Lambda表达式

野性酷女 2022-01-14 10:55 245阅读 0赞

一，问题  
最近在了解JAVA8的一些新特性，其中lambda表达式是我们JAVA8提供的一个语法糖，感觉还是挺好玩的，可以让我们的代码更加简洁。因此学习一下。

二，解决方案

package language.lambda;
    
    import java.io.PrintStream;
    import java.util.*;
    import java.util.function.BiPredicate;
    import java.util.function.BinaryOperator;
    import java.util.function.Consumer;
    import java.util.function.Predicate;
    import java.util.function.Supplier;
    
    import com.sun.org.apache.xpath.internal.functions.Function;
    
    
    /**
    * 学习lamdba表达式
    * 
    * @author KOLO
    *
    */
    public class LamdbaClass {
    
      /*
       * lamdba表达式：左边是参数，中间是操作符 -> ，右边是lamdba表达式执行的功能
       * lamdba表达式帮助只有一个抽象方法的函数式接口来创建对象
       * 
       */
      
      public static void main(String[] args) {
      	// 创建匿名函数，没有参数
      	createAonymousMethod();
      	// 具有一个参数的lamdba表达式
      	hasOneParameterMethod();
      	//  具有两个参数的lamdba表达式，无返回值
      	hasTwoParameterMethod();
      	//具有两个参数的lamdba表达式，有返回值
      	hasTwoParameterMethodWithReturnValue();
      	
      	//Java内置的四大函数式接口 Consumer消费者 、 Supplier提供者 、  Function函数型接口  、  Predicate断定型接口 
      	predicateMethod(); //断定型接口 
      	functionMethod();//函数型接口
      	supplierMethod();//供给型接口
      	consumerMethod();//消费者型接口
      	
      	//lambda表达式引用成员方法、静态方法、构造器、数组。只能在lambda表达式内使用
      	lambdaObjectForInstanceMethod();//对象::实例方法
      	lambdaClassForStaticMethod();	//类::静态方法
      	lambdaClassForInstanceMethod();	//类::实例方法
      	lambdaForNewInstance();			//类::new
      	lambdaForNewArray();			//类型[]:new
      	
      }
    
      // 创建匿名函数，没有参数
      public static void createAonymousMethod() {
    
      	Runnable runnable = () -> System.out.println("我的线程任务就说一句话！");
      	new Thread(runnable).start();
    
      	new Thread(() -> System.out.println("这是lamdba表达式！")).start();
    
      }
    
      // 具有一个参数的lamdba表达式
      public static void hasOneParameterMethod() {
    
      	Consumer<String> fun = (args) -> System.out.println(args.toString());
    
      	Consumer<String> funTwo = agrs -> System.out.println(agrs);// 只有一个参数时，左边参数的括号可以省掉
    
      }
    
      // 具有两个参数的lamdba表达式，无返回值
      public static void hasTwoParameterMethod() {
    
      	// 未使用lamdba表达式前
      	TreeSet<Integer> treeSet = new TreeSet<Integer>(new Comparator<Integer>() {
      		@Override
      		public int compare(Integer o1, Integer o2) {
      			if (o1.equals(o2)) {
      				return 0;
      			}
      			return 1;
      		}
      	});
    
      	// 使用lamdba表达式后
      	TreeSet<Integer> treeSetLamdba = new TreeSet<Integer>( (o1,o2) -> o1.equals(o2)?0:1 );
      	treeSetLamdba.add(5);
      	treeSetLamdba.add(1);
      	System.out.println(treeSetLamdba.toString());
    
      }
      
      //具有两个参数的lamdba表达式，有返回值
      public static void hasTwoParameterMethodWithReturnValue() {
      	BinaryOperator<Long> bOperator = (Long x , Long y) -> {
      		System.out.println("具有两个参数的lamdba表达式，有返回值");
      		return x+y;
      	};
      	
      	BinaryOperator<Long> bOperator2 = (Long x , Long y) -> x+y; //若返回值只有一条语句，则最后的return关键字可以省略
      	
      	BinaryOperator<Long> bOperator3 = (x,y) -> x+y;	//数据类型可以省略，因为编译器可以推断出参数的数据类型是什么
      	
      }
      
      /**
       * 断言型接口
       */
      public static void predicateMethod() {
      	
      	java.util.List<String> list = Arrays.asList("asc","adasd","a","dwqdq","gsg");
      	
      	//利用lamdba表达式实现predicate的test()方法，创新predicate对象
      	List<String> filterString = filterString(list, (str) -> str.length() > 3);
      	
      	for (String str : filterString) {
      		
      		System.out.println(str);
      	}
      	
      }
      //将满足条件的字符串，放入集合中
      public static java.util.List<String> filterString(java.util.List<String> list , Predicate<String> pre ){
      	
      	java.util.List<String> arrayList = new ArrayList<String>();
      	
      	for (String str : list) {
      		if (pre.test(str)) {
      			arrayList.add(str);
      		}
      	} 
      	return arrayList;
      }
      
      /**
       * FunctionMethod函数型接口
       */
      public static void functionMethod() {
      	
      	//利用lamdba表达式实现function的apply接口，创造function的对象
      	String string = stringHandle("    恭喜你！     ", (str) -> str.trim());
      	
      	System.out.println(string);
      	
      }
      //函数型功能，将Function<T,R>中的T类型数据，得到R类型的数据
      public static String stringHandle(String str , java.util.function.Function<String, String> function) {
      	return function.apply(str);
      }
      
      /**
       * SupplierMethod供给型接口
       */
      public static void supplierMethod() {
      	
      	List<Integer> list = getNumList(10 , () -> (int)(Math.random() * 100) );
      	
      	String string = list.toString();
      	
      	System.out.println(string);
      }
      //产生若干个整数，放入集合中
      public static List<Integer> getNumList(int num , Supplier<Integer> sup){
      	
      	List<Integer> list = new ArrayList<Integer>();
      	
      	for (int i = 0; i < num; i++) {
      		list.add(sup.get());
      	}
      	
      	return list;
      }
      
      /**
       * 消费者型接口
       */
      public static void consumerMethod() {
      	consumerMoney(10000 , (Number) -> System.out.println("你成功消费了："+ Number + "元。") );
      	
      }
      //打印消费的金额数
      public static void consumerMoney(int money , Consumer<Integer> consumer) {
      	consumer.accept(money);
      	
      }
      
      /**
       * 对象::实例方法。调用该对象的实例方法
       */
      public static void lambdaObjectForInstanceMethod() {
      	//对象
      	PrintStream printStream = System.out;
      	//lambda常规写法
      	Consumer<String> consumer = (str) -> printStream.println(str);
      	consumer.accept("Hello World!");
      	
      	//lambda表达式的引用写法
      	Consumer<String> consumer2 = printStream::println;
      	consumer2.accept("哈哈哈哈");
      	
      }
      
      /**
       * 类::静态方法。调用该类的静态方法
       */
      public static void lambdaClassForStaticMethod(){
      	
      	//lambda常规写法
      	Comparator<Integer> comparator = (x,y) -> Integer.compare(x, y);
      	int compare = comparator.compare(1,2);
      	System.out.println(compare);
      	
      	//lambda表达式的引用写法
      	Comparator<Integer> comparator2 = Integer::compare;
      	int compare2 = comparator2.compare(3, 2);
      	System.out.println(compare2);
      	
      }
      
      /**
       * 类::实例方法。调用该类所属对象的方法
       */
      public static void lambdaClassForInstanceMethod() {
      	
      	//lambda常规写法
      	BiPredicate<String, String> bPredicate = (x,y) -> x.equals(y);
      	System.out.println(bPredicate.test("abcde", "abcde"));
      	
      	//lambda表达式的引用写法
      	BiPredicate<String, String> bPredicate2 = String::equals;
      	System.out.println(bPredicate.test("abcde", "abcdK"));
      }
      
      /**
       * 类::构造器。调用该类的构造器
       */
      public static void lambdaForNewInstance() {
      	
      	//lambda常规写法
      	Supplier<ArrayList> supplier = () -> new ArrayList();
      	System.out.println(supplier.get().size());
      	
      	//lambda表达式的引用写法
      	Supplier<ArrayList> supplier2 = ArrayList::new;
      	System.out.println(supplier.get().size());
      	
      }
      
      /**
       * 类型[]:new。创建该类型的数组
       */
      public static void lambdaForNewArray() {
      	
      	//lambda常规写法
      	java.util.function.Function<Integer, String[]> fun1 = (number) -> new String[number];
      	System.out.println(fun1.apply(50).length);
      	
      	//lambda表达式的引用写法
      	java.util.function.Function<Integer, String[]> fun2 = String[]::new;
      	System.out.println(fun2.apply(49).length);
      	
      }
      
    }

上诉内容参考自：[https://blog.csdn.net/J080624/article/details/84976155][https_blog.csdn.net_J080624_article_details_84976155]

[https_blog.csdn.net_J080624_article_details_84976155]: https://blog.csdn.net/J080624/article/details/84976155