Lambda表达式

最新推荐文章于 2024-04-11 07:03:28 发布

奋斗&&奋进

最新推荐文章于 2024-04-11 07:03:28 发布

阅读量567

点赞数 1

分类专栏： JavaSE 文章标签： Lambda表达式匿名内部类

本文链接：https://blog.csdn.net/weixin_55667484/article/details/123688539

版权

JavaSE 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Lambda表达式❓

Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口. lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression）可以看作是一个匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）

语法🚶

基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }
Lambda表达式由三部分组成：
1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
2. ->：可理解为“被用于”的意思
3. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不返回。

函数式接口📧

定义:只有一个抽象方法的接口就叫函数式接口,但jdk1.8之后,该接口能允许有具体实现的方法,但这个方法必须是被default修饰
可对接口加一个注解:@FunctionalIterface,好处在于编译期限制你接口里只写一个抽象方法

@FunctionalInterface
interface  NoParameterNoReturn{
    void test();

    default void display(){
        System.out.println("我是default方法,jdk1.8之后我可以进函数式接口啦");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        new NoParameterNoReturn(){
            @Override
            public void test(){
                System.out.println("我对函数式接口的test()抽象方法在重写呢!");
            }
        }.test();
    }
}
//打印:我对函数式接口的test()抽象方法在重写呢!

Lambda表达式的使用🏎

我们可以理解这个表达式是匿名内部类的一种等价表达
整个表达式代表着一个类,这个类实现了什么接口我们必须提前知道,然后表达式的内容须是对这个接口的抽象方法进行的重写内容

如:main1中的匿名内部类,就可以表达成main函数中的Lambda表达式

@FunctionalInterface
interface  NoParameterNoReturn{
    void test();

    default void display(){
        System.out.println("我是default方法,jdk1.8之后我可以进函数式接口啦");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        NoParameterNoReturn tmp=()-> System.out.println("我对函数式接口的test()抽象方法在重写呢!");
        tmp.test();//多态式调用咯
        //也是打印"我对函数式接口的test()抽象方法在重写呢!"
    }
    public static void main1(String[] args) {
        new NoParameterNoReturn(){
            @Override
            public void test(){
                System.out.println("我对函数式接口的test()抽象方法在重写呢!");
            }
        }.test();
    }
}

Lambda表达式的精简🎉

.参数类型可以省略，如果需要省略，每个参数的类型都要省略。
参数的小括号里面只有一个参数，那么小括号可以省略 3
如果方法体当中只有一句代码，那么大括号可以省略 4
如果方法体中只有一条语句，其是return语句，那么大括号可以省略，且还可去掉return关键字。

变量捕获🈵

匿名内部类的变量捕获

匿名内部类定义:没有名字的内部类

匿名内部类的注意事项:

1、匿名内部类不能定义任何静态成员、方法。
2、匿名内部类中的方法不能是抽象的；
3、匿名内部类必须实现接口或抽象父类的所有抽象方法。
4、匿名内部类不能定义构造器；
5、匿名内部类访问的外部类成员变量或成员方法必须用static修饰；
6、内部类可以访问外部类私有变量和方法。

匿名内部类的变量捕获

class Test {
    public void func(){
    System.out.println("func()");
    }
}
public class TestDemo {
	public static void main(String[] args) {
		int a = 100;
		new Test(){
			@Override
			public void func() {
			System.out.println("我是内部类，且重写了func这个方法！");
			System.out.println("我是捕获到变量 a == "+a
			+" 我是一个常量，或者是一个没有改变过值的变量！");
			}
		};
	}
}

a在TestDemo中不可被修改过,或者是被final修饰了也行,这样才会默认捕获到a,如果不是直接编译出错

Lambda表达式的变量捕获🌊

与匿名内部类捕获是一样的,因为上面提到了,匿名内部类的等价表达就是Lambda表达式

Lambda在集合中的使用📦

Collection接口✌️

如forEach()方法:(可见forEach的形参是一个Consumer接口)

default void forEach(Consumer<? super T> action) {
	Objects.requireNonNull(action);
	for (T t : this) {
		action.accept(t);
	}
}

如果用一个匿名内部类实现Consumer接口,并对accept方法进行重写

public class TestDemo {
    public static void main(String[] args) {
        ArrayList<String> arrayList=new ArrayList<>();
        arrayList.add("hello");
        arrayList.add("to");
        arrayList.add("my");
        arrayList.add("world");
        arrayList.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.print(s+" ");
            }
        });
    }
}
//解释一下:匿名内部类做形参,被Consumer接口接受,即发生向上转型,通过观察Collection的forEach方法可知:
//forEach方法将使用for-each循环去遍历调用forEach方法的对象,遍历到的元素将会被作为形参传至accept方法中
//那通过Consumer类型的action调用accept方法,其实是多态式调用,调用了我们重写的accept(),所以分析完就知道
//等价于将顺序表的元素逐一打印
//hello to my world

使用Lambda表达式来写

public class TestDemo {
    public static void main(String[] args) {
        ArrayList<String> arrayList=new ArrayList<>();
        arrayList.add("hello");
        arrayList.add("to");
        arrayList.add("my");
        arrayList.add("world");
        arrayList.forEach((s)-> System.out.print(s+" "));
        /*arrayList.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.print(s+" ");
            }
        });*/
    }
}
//可见表达式大大简化,但是可读性就比较差了,我们能写出来是因为我们知道我们的Lambda在表达谁
//此时表达的就是匿名内部类里的重写的匿名函数

实现了List接口的sort()👶

sort()

default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }
//只需要知道两点
//1:sort的形参是一个Comparator接口
//2:sort会根据我们给的比较器去排序线性结构中的成员

针对sort()我们可以与Collection的forEach()类似,给sotr()传一个匿名内部类做比较器咯

public class TestDemo {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("hello");
        list.add("to");
        list.add("my");
        list.add("world");
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);//升序
            }
        });
        System.out.println(list);
    }
}

又如Map也也有forEach(),用法类似,不作赘述.

Lambda表达式的总结🤒

优点:
1. 代码简洁，开发迅速
2. 方便函数式编程
3. 非常容易进行并行计算
4. Java 引入 Lambda，改善了集合操作
缺点:
1. 代码可读性变差
2. 在非并行计算中，很多计算未必有传统的 for 性能要高
3. 不容易进行调试

奋斗&&奋进

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Lambda表达式

Lambda表达式❓Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口. lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression）可以看作是一个匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）语法🚶基本语法: (parameters) -> expression 或 (parameters)
复制链接

扫一扫