JAVA8新特性之Lambda表达式

一，问题
最近在了解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 fun = (args) -> System.out.println(args.toString());

  	Consumer funTwo = agrs -> System.out.println(agrs);// 只有一个参数时，左边参数的括号可以省掉

  }

  // 具有两个参数的lamdba表达式，无返回值
  public static void hasTwoParameterMethod() {

  	// 未使用lamdba表达式前
  	TreeSet treeSet = new TreeSet(new Comparator() {
  		@Override
  		public int compare(Integer o1, Integer o2) {
  			if (o1.equals(o2)) {
  				return 0;
  			}
  			return 1;
  		}
  	});

  	// 使用lamdba表达式后
  	TreeSet treeSetLamdba = new TreeSet( (o1,o2) -> o1.equals(o2)?0:1 );
  	treeSetLamdba.add(5);
  	treeSetLamdba.add(1);
  	System.out.println(treeSetLamdba.toString());

  }
  
  //具有两个参数的lamdba表达式，有返回值
  public static void hasTwoParameterMethodWithReturnValue() {
  	BinaryOperator bOperator = (Long x , Long y) -> {
  		System.out.println("具有两个参数的lamdba表达式，有返回值");
  		return x+y;
  	};
  	
  	BinaryOperator bOperator2 = (Long x , Long y) -> x+y; //若返回值只有一条语句，则最后的return关键字可以省略
  	
  	BinaryOperator bOperator3 = (x,y) -> x+y;	//数据类型可以省略，因为编译器可以推断出参数的数据类型是什么
  	
  }
  
  /**
   * 断言型接口
   */
  public static void predicateMethod() {
  	
  	java.util.List list = Arrays.asList("asc","adasd","a","dwqdq","gsg");
  	
  	//利用lamdba表达式实现predicate的test()方法，创新predicate对象
  	List filterString = filterString(list, (str) -> str.length() > 3);
  	
  	for (String str : filterString) {
  		
  		System.out.println(str);
  	}
  	
  }
  //将满足条件的字符串，放入集合中
  public static java.util.List filterString(java.util.List list , Predicate pre ){
  	
  	java.util.List arrayList = new ArrayList();
  	
  	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类型的数据
  public static String stringHandle(String str , java.util.function.Function function) {
  	return function.apply(str);
  }
  
  /**
   * SupplierMethod供给型接口
   */
  public static void supplierMethod() {
  	
  	List list = getNumList(10 , () -> (int)(Math.random() * 100) );
  	
  	String string = list.toString();
  	
  	System.out.println(string);
  }
  //产生若干个整数，放入集合中
  public static List getNumList(int num , Supplier sup){
  	
  	List list = new ArrayList();
  	
  	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 consumer) {
  	consumer.accept(money);
  	
  }
  
  /**
   * 对象::实例方法。调用该对象的实例方法
   */
  public static void lambdaObjectForInstanceMethod() {
  	//对象
  	PrintStream printStream = System.out;
  	//lambda常规写法
  	Consumer consumer = (str) -> printStream.println(str);
  	consumer.accept("Hello World!");
  	
  	//lambda表达式的引用写法
  	Consumer consumer2 = printStream::println;
  	consumer2.accept("哈哈哈哈");
  	
  }
  
  /**
   * 类::静态方法。调用该类的静态方法
   */
  public static void lambdaClassForStaticMethod(){
  	
  	//lambda常规写法
  	Comparator comparator = (x,y) -> Integer.compare(x, y);
  	int compare = comparator.compare(1,2);
  	System.out.println(compare);
  	
  	//lambda表达式的引用写法
  	Comparator comparator2 = Integer::compare;
  	int compare2 = comparator2.compare(3, 2);
  	System.out.println(compare2);
  	
  }
  
  /**
   * 类::实例方法。调用该类所属对象的方法
   */
  public static void lambdaClassForInstanceMethod() {
  	
  	//lambda常规写法
  	BiPredicate bPredicate = (x,y) -> x.equals(y);
  	System.out.println(bPredicate.test("abcde", "abcde"));
  	
  	//lambda表达式的引用写法
  	BiPredicate bPredicate2 = String::equals;
  	System.out.println(bPredicate.test("abcde", "abcdK"));
  }
  
  /**
   * 类::构造器。调用该类的构造器
   */
  public static void lambdaForNewInstance() {
  	
  	//lambda常规写法
  	Supplier supplier = () -> new ArrayList();
  	System.out.println(supplier.get().size());
  	
  	//lambda表达式的引用写法
  	Supplier supplier2 = ArrayList::new;
  	System.out.println(supplier.get().size());
  	
  }
  
  /**
   * 类型[]:new。创建该类型的数组
   */
  public static void lambdaForNewArray() {
  	
  	//lambda常规写法
  	java.util.function.Function fun1 = (number) -> new String[number];
  	System.out.println(fun1.apply(50).length);
  	
  	//lambda表达式的引用写法
  	java.util.function.Function fun2 = String[]::new;
  	System.out.println(fun2.apply(49).length);
  	
  }
  
}

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