-> Lombda 表达式学习笔记

2016年的 OneNote 笔记迁移到 博客园

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升

1、内部类：对内部类的一种简化方式

interface MyInterface{
 
　　public void info();
}

class InterfaceTest implements MyInterface{
 
　　@Override
　　public void info() {
　　　　System.out.println("普通的实现接口的方式");
　　}
}

@Test
public void test1() {
 
　　MyInterface m1 = new MyInterface() {
　　　　@Override
　　　　public void info() {
　　　　　　System.out.println("内部类的方式直接 new 接口方式实现接口方法");
　　　　}
　　};
　　m1.info();// 方法中直接调用
}

@Test
public void lambda() {
　　// lambda表达式，一行解决
　　MyInterface m2 = () -> System.out.println("lambda表达式的方式实现");
　　　　m2.info();
}

public class LambdaTest2 {
 
　　@Test
　　public void test() {
　　　　Runnable r1 = new Runnable() {
　　　　　　@Override
　　　　　　public void run() {
　　　　　　　　System.out.println("Runnable接口");
　　　　　　}
　　　　};
　　　　r1.run();
　　　　Runnable r2 = ()->System.out.println("Runnable接口");
　　　　r2.run();
　　}
}

 

Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：

左侧：指定了 Lambda 表达式需要的参数列表

右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即 Lambda 表达式要执行的功能。

 

/**
 * 语法格式一：无参，无返回值
 */
 
@Test
public void test() {
　　Runnable r1 = new Runnable() {
　　　　@Override
　　　　public void run() {
　　　　　　System.out.println("Runnable接口");
　　　　　　System.out.println("Runnable接口");
　　　　　　System.out.println("Runnable接口");
　　　　}
　　};

　　r1.run();
　　Runnable r2 = ()->{ 
　　　　System.out.println("Runnable接口");
　　　　System.out.println("Runnable接口");
　　　　System.out.println("Runnable接口");
　　}
　　r2.run();
}
// 当只有一行语句时 ， ｛｝可以省略

/**
 * 语法格式二：Lambda 需要一个参数，但是没有返回值。
 */
@Test
public void test() {
　　Consumer<String> con1 = new Consumer<String>() {
　　　　@Override
　　　　public void accept(String t) {
　　　　　　System.out.println(t);
　　　　}
　　};
　　Consumer<String>  con2 = (String t)->{
　　　　System.out.println(t);
　　};
}

/**
 * 语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
 */
@Test
public void test() {
　　Consumer<String> con1 = new Consumer<String>() {
　　　　@Override
　　　　public void accept(String t) {
　　　　　　System.out.println(t);
　　　　}
　　};
　　// 由前面的泛型类型可得出参数类型，可以省略
　　Consumer<String> con2 = (t) -> {
　　　　System.out.println(t);
　　};
}

/**
 * 语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
 */
@Test
public void test4() {
　　Consumer<String> consumer1 = new Consumer<String>() {
 
　　　　@Override
　　　　public void accept(String t) {
　　　　　　System.out.println(t);
　　　　}
　　};
 
　　System.out.println("--------------lambda表达式-------------------------");
　　Consumer<String> consumer2 = t -> {
　　　　System.out.println(t);
　　};
 
　　System.out.println("----------------进一步简化-----------------");
　　Consumer<String> consumer2 = t -> System.out.println(t);
}

 

/**
 * 语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
  * 多个参数时类型可以省，括号不能省
 */
@Test
public void test5() {
　　Comparator<String> comparator1 = new Comparator<String>() {
　　　　@Override
　　　　public int compare(String arg0, String arg1) {
　　　　　　return arg0.compareTo(arg1);
　　　　}
　　};
　　System.out.println("--------------------lambda表达式----------------------");
　　Comparator<String> comparator2 = (arg0, arg1) -> {
　　　　return arg0.compareTo(arg1);
　　};
}

/**
 * 语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
 */
@Test
public void test6() {
　　Comparator<String> comparator1 = new Comparator<String>() {
　　　　@Override
　　　　public int compare(String arg0, String arg1) {
　　　　　　return 0;
　　　　}
　　};
　　System.out.println("--------------------lambda表达式----------------------");
　　Comparator<String> comparator2 = (arg0,arg1) -> arg0.compareTo(arg1);
}