jdk1.8-lambda

lambda表达式;
1.可将原有的匿名内部类替换为命名内部类；
2.当方法的参数为接口类型时，可在调用方法时，用lambda表达式实现这个接口;
3.语法：参数列表 -> 单条执行语句/执行块;

4.被lambda表达的接口，只能有一个方法；
优势：
让代码实现起来更加简洁，从而显著提高开发效率
缺点：
代码会变得相对不易阅读；

下面直接上代码：

import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 *
 * @author chengxp
 *
 */
public class LambdaTest {

	/**
	 * lambda呈现入口
	 */
	public void exeEntry(String message,HandlerArg handlerArg){

		handlerArg.handleEntry(message);
	}

	/**
	 * 声明一个接口，以lambda的语法来表达该接口的方法调用
	 */
	public interface HandlerArg{

		public void handleEntry(String message);
	}

	/**
	 * 声明一个接口，以lambda的语法来表达该接口的方法调用
	 */
	public interface HandlerArgs{

		public int handleEntry(String message1,String message2);
	}

	/**
	 * lambda呈现入口
	 * @param handlerArgs
	 */
	public int exeEntry(String message1,String message2,HandlerArgs handlerArgs){

		return handlerArgs.handleEntry(message1, message2);
	}
	public static void main(String[] args) {

		LambdaTest lambdaTest = new LambdaTest();

		//1、
		//1."msg"为传入HandlerArg接口的handleEntry方法所需参数，在"->前面"；然后面 直接执行方法所要作的事；
		//2.参数可不声明参数类型；
		//3.单个参数不须要被"()"包围起来；
		//lambdaTest.exeEntry("the hardest thing is to feel good everyday",msg -> System.out.println(msg));

		//2、
		//也能够预先实现接口，再将接口做为参数传递
		//HandlerArg handlerArg = msg -> System.out.println(msg);
		//lambdaTest.exeEntry("the hardest thing is to feel good everyday",handlerArg);

		//3、
		//多条语句，则直接做为一个函数来使用，其实这里就相似于javaScript的方法传递了
		//lambdaTest.exeEntry("the hardest thing is to feel good everyday",msg -> {

		//	String strPrefix = "chengxp said：";
		//	System.out.println(strPrefix + msg);
		//});

		//4、
		//多个参数，并处理后返回结果
//		int strsLength = lambdaTest.exeEntry("sdf5745","fgdg", (msg1,msg2) -> {return msg1.length() + msg2.length();});
//		System.out.println("两个字符串长度之和为：" + strsLength);

		//5、
		//例如集合框架中用的比较多的排序，能够这么写
		List<String> strs = new ArrayList<>();
		strs.add("bb");
		strs.add("cc");
		strs.add("dd");
		strs.add("aa");

		//之前是这么写的
		Collections.sort(strs, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {

				return o1.compareTo(o2);
			}
		});
		//这里也是1.8的遍历语法。不过试了一下，效率没有普通的for循环效率高。
		strs.forEach(str -> System.out.println(str));

		//用lambda写
		Collections.sort(strs,(s1,s2) -> s1.compareTo(s2));
		strs.forEach(str -> System.out.println(str));
	}
}

为突出效果，使之更加便于理解，请分别运行代码。