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 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() {
// 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;
});
}
}