lambda表达式

最新推荐文章于 2023-06-23 15:08:49 发布

sdau20163940

最新推荐文章于 2023-06-23 15:08:49 发布

阅读量95

点赞数

分类专栏：技术学习文章标签： lambda java

本文链接：https://blog.csdn.net/sinat_37668729/article/details/115558213

版权

技术学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Lambda表达式学习笔记

1.为什么使用Lambda？

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

2.Lambda表达式使用举例

package com.deng;

import org.junit.Test;

import java.util.Comparator;

/**
 * Lambda表达式使用举例
 * @author Deng Huawei
 * @create 2021-04-09 12:36
 */
public class TestLambda {

    @Test
    public void test1(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("This is a test!");
            }
        };
        r1.run();
        System.out.println("--------------------下面是Lambda表达式---------------------");
        Runnable r2 = () -> System.out.println("This is a Lambda test!");
        r2.run();
    }

    @Test
    public void test2(){
        Comparator<Integer> cmp1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        int compare1 = cmp1.compare(12,10);
        System.out.println(compare1);
        System.out.println("--------------------------Lambda-------------------");
        Comparator<Integer> cmp2 = (o1,o2) -> Integer.compare(o1,o2);
        int compare2 = cmp2.compare(21,32);
        System.out.println(compare2);
        System.out.println("--------------------------方法引用-------------------");
        Comparator<Integer> cmp3 = Integer::compare;
        int compare3 = cmp3.compare(21,32);
        System.out.println(compare3);
    }
}

3.Lambda表达式语法使用

3.1.举例

(o1,o2) -> Integer.compare(o1,o2);

3.2.格式

-> :lambda操作符，或箭头操作符
->左边：lambda形参列表（其实就是接口中的抽象方法形参列表）
->右边：lambda体（其实就是重写的方法的方法体）

3.3.Lambda表达式的使用（6种情况）

语法格式1：无参，无返回值（上面的Runnable方法！！）

@Test
public void test1(){
    Runnable r1 = () -> {System.out.println("This is a test!");}
    r1.run();
}

语法格式2：Lambda需要一个参数，但是没有返回值

    @Test
    public void test2(){
        Consumer<String> con1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con1.accept("普通方法！");
        System.out.println("**************************");
        Consumer<String> con2 = (String s) -> {
            System.out.println(s);
        };
        con2.accept("lambda表示方法！");
    }

语法格式3：数据类型可以省略，因为可由编译器推断得出，称为“类型推断“

   //语法格式3：数据类型可以省略，因为可由编译器推断得出，称为“类型推断“
    @Test
    public void test3(){
        Consumer<String> con2 = (String s) -> {
            System.out.println(s);
        };
        con2.accept("lambda表示方法！");
        System.out.println("*************************优化！！");
        Consumer<String> con3 = (s) -> {
            System.out.println(s);
        };
        con2.accept("lambda表示优化方法！类型推断！！！");
    }

类型推断：

 ArrayList<String> arrayList = new ArrayList<>();   //类型推断
        int[] arr = new int[]{12,2,3,};    //可改为
        int[] arr1 = {1,2,3};               //类型推断

语法格式4：Lambda 若只需要一个参数时，参数的小括号可以省略

//语法格式4：Lambda 若只需要一个参数时，参数的小括号可以省略
@Test
public void test4(){
    Consumer<String> con3 = (s) -> {
        System.out.println(s);
    };
    con3.accept("lambda表示优化方法！类型推断！！！");
    System.out.println("***************************");
    Consumer<String> con4 = s-> {
        System.out.println(s);
    };
    con4.accept("lambda表示优化方法,类型推断！！！去掉小括号");
}

语法格式5：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值

//语法格式5：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
@Test
public void test5(){
    Comparator<String> com1 = new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        }
    };
    System.out.println(com1.compare("12", "21"));
    System.out.println("原始写法****************************");

    Comparator<String> com2 = (o1,o2) ->{
        System.out.println(o1);
        System.out.println(o2);
        return o1.compareTo(o2);
    };
    System.out.println(com1.compare("12", "6"));
}

语法格式6：当：Lambda体只有一条语句时，return与大括号若有，都可以省略

//语法格式6：当：Lambda体只有一条语句时，return与大括号若有，都可以省略
@Test
public void test6(){
    Comparator<Integer> com1 = (o1,o2) ->{
        return o1.compareTo(o2);
    };
    System.out.println(com1.compare(12,6));
    System.out.println("*******************************");
    Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);  //System.out.println();
    System.out.println(com2.compare(60,63));
}

3.4.Lambda表达式本质

作为接口的实例（具体实现类）

4.总结

->左边：lambda形参列表的参数类型可以省略（类型推断）；如果参数列表只有一个参数，其一对()也可以省略
->右边：lambda体应该使用一对{}进行包裹，如果lambda体只有一条执行语句（可能是return语句），可以省略一对{}以及这个return关键字（注意：省了{}一定要去掉return）；

重点！！！！需要接口只有一个抽象方法，依赖于函数式接口！！！！！！！！！！！！！！

5.练习

将Employee按照年龄进行排序，如果年龄相同，则按照姓名进行排序。提示：Collections.sort()

public class test {
    List<employee> list = Arrays.asList(
            new employee(1,"张三",18,2000),
            new employee(2,"李四",25,2011),
            new employee(3,"王五",20,3000),
            new employee(4,"孙武路",23,3000),
            new employee(5,"张无忌",30,5000)
    );

    @Test
    public void test(){
        Collections.sort(list, (e1,e2) -> {
            if(e1.getAge() == e2.getAge()){
                return e1.getName().compareTo(e2.getName());
            }else {
                return Integer.compare(e1.getAge(),e2.getAge());
            }
        });
        for (employee emp : list) {
            System.out.println(emp);
        }
    }
}