lambda表达式的简单应用

lambda表达式:是Java8中的新特性
Java8中引入Lambda表达式，使得java可以函数式编程，在并发性能上迈出了实质性的一步。

函数式编程:（英语：functional programming）或称函数程序设计，又称泛函编程，是一种编程范型，它将电脑运算视为数学上的函数计算，并且避免使用程序状态以及易变对象。函数编程语言最重要的基础是λ演算（lambda calculus）。而且λ演算的函数可以接受函数当作输入（引数）和输出（传出值）

比较lambda表达式和匿名内部类:
    总结:lambda表达式就是简单的匿名内部类
    1.匿名内部类可以为任意接口创建实例,不管接口包含多少个抽象方法,只要匿名内部类实现所有的抽象方法
    即可; 但Lambda表达式只能为函数式接口创建实例(即只能有一个抽象方法)
    2.匿名内部类可以为抽象类甚至是普通类创建实例;但Lambda表达式只能为函数式接口创建实例
    3.匿名内部类实现的抽象方法的方法体允许调用接口中定义的默认(default)方法;但Lambda表达式的代码块
    不允许调用接口中的默认(default)方法

案例1

interface InterfaceA{
	public void show();
}
public class Demo1 {
	public static void main(String[] args) {
		//匿名内部类
		InterfaceA a = new InterfaceA() {
			public void show() {
				System.out.println("匿名内部类的show");
			}
		};
		a.show();
		
		//通过lambda表达式
		InterfaceA b = ()->{
			System.out.println("lambda表达式的show");
		};
		b.show();
		//简化
		InterfaceA bb = ()->System.out.println("简化的lambda表达式的show");
		bb.show();
	}
}

案例2

public class Demo2 {
	public static void main(String[] args) {
		fun();
	}
	
	//@Test
	public static void fun() {
		//1.没有参数的
		InterA a = ()->{
			System.out.println("没有参数");
		};
		a.showA();
		//简化
		InterA aa = ()->System.out.println("没有参数");
		aa.showA();
		//2.一个参数的
		InterB b = (ib)->{
			System.out.println("一个参数:"+ib);
		};
		b.showB(4);
		//简化
		InterB bb = (ib)->System.out.println("一个参数:"+ib);
		bb.showB(5);
		//3.两个参数的
		InterC c = (ia,ib)->{
			int sum = ia+ib;
			System.out.println("两个参数:"+" ia:"+ia+"   ib:"+ib+"    sum:"+sum);
		};
		c.showC(4, 6);
		//简化
		InterC cc = (ia,ib)->System.out.println("两个参数:"+" ia:"+ia+"   ib:"+ib);
		cc.showC(4, 5);
		//4.返回值
		InterD d = (i,j)->{
			int sum = i+j;
			//System.out.println("sum:"+sum);
			return sum;
		};
		int value = d.showD(4, 6);
		System.out.println(value);
		//简化  简化版的不需要写return 
		InterD dd = (i,j)->i+j;
		int value1 = dd.showD(4, 7);
		System.out.println(value1);
		
		//5.lambda表达式作为参数
		fun2(
				new InterC() {public void showC(int a, int b) {}}
			);
		fun2((i,j)->System.out.println("lambda表达式作为参数"+" i:"+i));
		
		//7.lambda表达式中变量的使用
		String value11 = "hello world";
		InterA aaa = ()->{
			System.out.println(value11);
			//value11是final类型的是一个常量,值是不能改变的
			//value11 = "haha";
		};
		aaa.showA();
	}
	
	public static void fun2(InterC c) {
		c.showC(4, 6);
	}
}

interface InterA{
	public void showA();
}
interface InterB{
	public void showB(int a);
}
interface InterC{
	public void showC(int a,int b);
}
interface InterD{
	public int showD(int a,int b);
}
@FunctionalInterface
interface InterE{
	public int showD(int a,int b);
	//public int showY(int a,int b);
}

案例3

/*
 * 方法引用与构造器引用
 * 1.引用类方法
 * 2.引用特定对象的实例方法
 * 3.引用某类对象的实例方法
 * 4.引用构造方法
 */
public class Demo3 {
	public static void main(String[] args) {
//		 * 1.引用类方法
		Test1.fun1();
//		 * 2.引用特定对象的实例方法
		Test2.fun2();
//		 * 3.引用某类对象的实例方法
		Test3.fun3();
//		 * 4.引用构造方法
		Test4.fun4();
	}
}
//* 1.引用类方法
interface Converter{
	//将字符串转换成整数
	Integer convert(String value);
}
class Test1{
	public static void fun1() {
		//原来的方法
		Converter converter = value->Integer.valueOf(value);
		Integer v1 = converter.convert("222");
		System.out.println(v1);
		
		//简化
		//引用类方法
		//通过::实现,这里会自动将lambda表达式方法的参数全部传递给当前的方法
		Converter converter2 = Integer::valueOf;
		Integer v2 = converter2.convert("333");
		System.out.println(v2);
	}
}
//* 2.引用特定对象的实例方法
interface IA{
	public void show(String message);
}
class A{
	public void play(String i) {
		System.out.println("这里是A的方法play"+"  i:"+i);
	}
}
class Test2{
	public static void fun2() {
		//原来
		IA ia = message->new A().play(message);
		ia.show("hello");
		//简化
		IA ia2 = new A()::play;
		ia2.show("world");
	}
}
//* 3.引用某类对象的实例方法
interface IB{
	String subString(String string,int stat,int end);
}
class Test3{
	public static void fun3() {
		//原来
		IB ib = (string,stat,end)->string.substring(stat, end);
		String sub1 = ib.subString("hello world", 2, 4);
		System.out.println(sub1);
		//简化
		 //函数式接口中被实现方法的第一个参数作为调用者,后面的参数全部传递给该方法
		IB ib2 = String::substring;
		String sub2 = ib2.subString("class is over", 2, 5);
		System.out.println(sub2);
	}
}
//* 4.引用构造方法
interface IC{
	Object show(String name,int age);
}
class Person{
	String name;
	int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

}
class Test4{
	public static void fun4() {
		IC ic = (name,age)->new Person(name, age);
		Object per = ic.show("bing", 19);
		System.out.println(per);
		
		//简化 
		//构造方法引用代替lambda表达式,函数式接口中被实现方法的全部参数传该构造方法作为参数
		IC ic2 = Person::new;
		Object per1 = ic2.show("chen", 10);
		System.out.println(per1);
	}
}

案例4

interface Inter{
	public void eat();
}

class DaHuang implements Inter{
	public void eat() {
		System.out.println("eat");
	}
}
public class Demo4 {
	public static void main(String[] args) {
		//遍历集合
		String[] strings = {"java","html","BigData","python"};
		List<String> list = Arrays.asList(strings);
		//原理的遍历方法
		for (String string : list) {
			System.out.println(string);
		}
		
		System.out.println("*************");
		//通过lambda表达式
		list.forEach(string->System.out.println("字符串是:"+string));
		//再简化
		list.forEach(System.out::println);
		//多线程
		new Thread(new Runnable() {
			public void run() {
				System.out.println("通过匿名内部类创建任务");
			}
		}).start();
		//通过lambda表达式
		new Thread(()->System.out.println("通过lambda表达式创建任务")).start();
		//排序--使用Collections
//		Collections.sort(list, new Comparator<String>() {
//			public int compare(String o1, String o2) {
//				return o1.compareTo(o2);
//			}
//		});
		
		//使用lambda表达式
		Collections.sort(list, (o1,o2)->o1.compareTo(o2));
		System.out.println(list);
		
		//动态代理
		Inter inter = new DaHuang();
		Proxy.newProxyInstance(inter.getClass().getClassLoader(), new Class[] {Inter.class}, new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				System.out.println("洗手");
				Object object = method.invoke(inter, args);
				return object;
			}
		});
		//lambda表达式
		Proxy.newProxyInstance(inter.getClass().getClassLoader(), new Class[] {Inter.class},(proxy,method,arg)->{
			System.out.println("洗手");
			Object object = method.invoke(inter, arg);
			return object;
		});
	}
}