Lambda Expressions

最新推荐文章于 2023-02-15 18:02:21 发布

LeoHoFly

最新推荐文章于 2023-02-15 18:02:21 发布

阅读量604

点赞数 1

CC 4.0 BY-SA版权

分类专栏：原创文章标签： android java lambda

本文链接：https://blog.youkuaiyun.com/Jaden_hool/article/details/51839730

原创专栏收录该内容

34 篇文章

订阅专栏

本文详细介绍了Java 8中引入的Lambda表达式，包括其语法、用法及应用场景。通过对比匿名内部类，展示了Lambda表达式如何简化代码，并提供了具体的示例来解释其工作原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Lambda

匿名内部类已经是一种简洁的表示方法了，但是还有一个问题，例如一个接口，它只含有一个方法，那么匿名内部类就不那么易于使用了，因为会出现很多冗余的代码，这个时候开发者就会想要将函数当成一个参数传递给一个方法，例如为控件设置点击事件。所以就出现了Lambda表达式，Java8引入了这个新特性，使用Android Studio编程时，会发现为控件设置点击事件的代码会“变样”，如下第二种表示方式就是Lambda表达式，既然官方都这样用了，那我们还有什么理由不拥抱这种方式呢。

 view.setOnClickListener(new View.OnClickListener() {//明明是这样写的
            @Override
            public void onClick(View v) {

            }
        });

  view.setOnClickListener((v) -> {//有的时候代码看上去变成了这样

        });

用法

Android Studio配置：

android {
    buildToolsVersion "24.0.0"//大于24即可
    defaultConfig {
        jackOptions {
            enabled true
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

语法

Lambda表达式只适用于只含有一个方法的接口
Lambda表达式的结构：(Type params) -> {block}，整个表达式代表的是“接口的实现类”；params代表这个“接口中的方法的形参”；Type代表“形参的类型”，可以省略；block代表“接口中方法的实现“，具体请看下面的例子；

   public interface ISyntax {//Lambda表达式只适用于只含有一个方法的接口
    int getInt(int i);
}

private void invokeSyntax(ISyntax s) {//调用这个方法需要传递ISyntax的实现类
    s.getInt(10);
}

private void learnSyntax() {
    //匿名内部类已经省略了声明对象这个步骤，看起来很简洁了。
    invokeSyntax(new ISyntax() {
        @Override
        public int getInt(int i) {
            return i++;
        }
    });

     // Lambda表达式其实也是匿名的，只不过不仅仅匿了对象名称，还匿了类名，方法名
    invokeSyntax((int i) -> { //这里的int i就是接口ISyntax中的getInt()方法中的参数
        return i++; //大括号中的内容就是getInt()方法的实现
    });

    invokeSyntax((i) -> i++);//可以省略参数类型，还可以省略大括号和“return”，直接写返回值
}

作用域

import java.util.function.Consumer;

public class LambdaScopeTest {

    public int x = 0;

    class FirstLevel {

        public int x = 1;

        void methodInFirstLevel(int x) {

            // The following statement causes the compiler to generate
            // the error "local variables referenced from a lambda expression
            // must be final or effectively final" in statement A:
            //
            // x = 99;

            Consumer<Integer> myConsumer = (y) -> 
            {
                System.out.println("x = " + x); // Statement A
                System.out.println("y = " + y);
                System.out.println("this.x = " + this.x);
                System.out.println("LambdaScopeTest.this.x = " +
                    LambdaScopeTest.this.x);
            };

            myConsumer.accept(x);

        }
    }

    public static void main(String... args) {
        LambdaScopeTest st = new LambdaScopeTest();
        LambdaScopeTest.FirstLevel fl = st.new FirstLevel();
        fl.methodInFirstLevel(23);
    }
}
This example generates the following output:

x = 23
y = 23
this.x = 1
LambdaScopeTest.this.x = 0

返回类型

Lambda表达式只含有形参列表和实现代码块，那么Java如何判断一个Lambda表达式代表的究竟是哪个接口的实现类呢？看下面的例子：

 //Target Type
public interface IInteger {
    void setInt(int i);
}

public interface IString {
    void setString(String str);
}

public interface IMultiParams {
    void setString(String str1, String str2);
}

public interface IReturn {
    String getString(String str);
}

private void use(IInteger e) {
    e.setInt(1);
}

private void use(IString t) {
    t.setString("IString");
}

private void use(IMultiParams m) {
    m.setString("param1", "param2");
}

private void use(IReturn r) {
    r.getString("IReturn");
}

public void learnTargetType() {
    //IInteger
    use((int i) -> {//该Lambda代表的是IInteger的实现类，因为参数声明了为int类型
        Log.d(TAG, "i: " + i);
    });
    //IString
    use((String str) -> {
        Log.d(TAG, "str: " + str);
    });
    //IMultiParams
    use((param1, param2) -> {
        Log.d(TAG, "param1: " + param1 + " param2: " + param2);
    });
    //IReturn
    use((String str) -> "我有返回值" + str);
}