标签：Java int System println Lambda 表达式 out

Lambda表达式

Lambda表达式,也可以称为闭包,是Java 8发布的最重要新特性

Lambda允许把函数作为一个方法的参数(函数作为参数传递进方法中)
使用Lambda表达式可以使代码变的更加简洁紧凑
语法:
- (parameter) -> expression
- (parameter) -> { statement; }
parameter: 参数列表,如果只有一个参数,可以省略括号,如果没有参数,也需要使用括号;
expression 或 { statement; } 是Lambda表达式的主体

我们可以举一个简单的例子

public class Main {
    public static void main(String[] args) {
//        Lambda表达式计算两数之和
        MathOperation addition = (a, b) -> a + b;
        MathOperation addition2 = (a, b) -> a + b;
        MathOperation addition3 = (a, b) -> a*b;
        System.out.println(addition.operate(5,3));
        System.out.println(addition2.operate(5,3));
        System.out.println(addition3.operate(5,3));

    }
}
interface  MathOperation{
    int operate(int a, int b);
}

在上面的例子中，MathOperation 是一个函数式接口，它包含一个抽象方法 operation，Lambda 表达式(a, b) -> a + b 实现了这个抽象方法，表示对两个参数进行相加操作。

所以,Lambda表达式可以用来实现接口的方法,但是只可以实现一种方法,一种以上如下图

MathOperation operation = (a, b) -> {
            return a / b;
        };
MathOperation operation = (a, b) -> {
            return a * b + 10;
        };

重要特征

简洁性

Lambda 表达式提供了一种更为简洁的语法，尤其适用于函数式接口。相比于传统的匿名内部类，Lambda 表达式使得代码更为紧凑，减少了样板代码的编写。

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

public class Main {
    public static void main(String[] args) {
        //使用匿名内部类
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World!");
            }
        };
        runnable1.run();

// 使用 Lambda 表达式
        Runnable runnable2 = () -> System.out.println("Hello World!");
        runnable2.run();
    }
}

函数式编程支持

Lambda 表达式是函数式编程的一种体现，它允许将函数当作参数传递给方法，或者将函数作为返回值，这种支持使得 Java 在函数式编程方面更为灵活，能够更好地处理集合操作、并行计算等任务

List<String> names = Arrays.asList("Alice","Bob","Cuiweiyang");
names.forEach(name -> System.out.println(name));

实现了一下接口

变量捕获

Lambda 表达式可以访问外部作用域的变量，这种特性称为变量捕获，Lambda 表达式可以隐式地捕获 final 或事实上是 final 的局部变量。

int  x = 10;
Function function = a -> System.out.println(a+x);//注意返回值类型
function.oper(5);

interface Function{
    void oper(int a);
}

方法引用

Lambda 表达式可以通过方法引用进一步简化，方法引用允许你直接引用现有类或对象的方法，而不用编写冗余的代码

// 使用方法引用
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(System.out::println);

可并行性

Lambda 表达式能够更方便地实现并行操作，通过使用 Stream API 结合 Lambda 表达式，可以更容易地实现并行计算，提高程序性能。

// 使用 Lambda 表达式和 Stream API 进行并行计算
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum =numbers.parallelStream().mapToInt(Integer::intValue).sum();
System.out.println("sum: "+sum);

Lambda 表达式的引入使得 Java 编程更加灵活、简洁，并推动了函数式编程的发展。