Lamda表达式与枚举类

Lambda表达式

概述

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

能写成Lambda表达式的前提：

要有一个接口【作为方法参数类型，返回值类型】
这个接口必须有且仅有一个抽象方法

基本格式

(参数列表)->{代码逻辑}
①：()：代表接口中唯一的抽象方法
②：参数列表：对应的是接口中的抽象方法的参数列表【如果没有，就什么都不写】
③：->：箭头操作符，或者叫Lambda操作符
④：代码逻辑：就是重写方法的实现，换句话说，就是方法体

Lambda的六种使用方式

能省则省

无参数，无返回值

interface Interface1{
    void fun1();
}
public class LambdaDemo1 {
    public static void main(String[] args) {
        fun(()->{System.out.println("hello world");});

    }
    public static void fun(Interface1 interface1){
        interface1.fun1();
    }
}

有一个参数，无返回值

interface Interface2{
    void fun2(String s);
}
public class LambdaDemo2 {
    public static void main(String[] args) {
        fun("hello world",(String s)->{
            System.out.println(s);
        });
    }
    public static void fun(String s,Interface2 interface2){
        interface2.fun2(s);
    }
}

若只有一个参数，小括号可以省略不写

interface Interface3{
    void fun3(String s);
}
public class LambdaDemo3 {
    public static void main(String[] args) {
        fun("hello world",s->{System.out.println(s);});
    }
    public static void fun(String s,Interface3 interface3){
        interface3.fun3(s);
    }
}

有两个以上的参数，有返回值，并且 Lambda 体中有多条语句

interface Interface4 {
    int fun4(int i, int j);
}

public class LambdaDemo4 {
    public static void main(String[] args) {
        fun(3, 7, (a, b) -> {
            int sum = a+b;
            return sum;
        });
    }

    public static void fun(int m, int n, Interface4 interface4) {
        System.out.println("sum = " + interface4.fun4(3, 7));

    }
}

若 Lambda 体中只有一条语句， return 和大括号都可以省略不写

关于小括号里面的变量名【形式参数】，随便起，只是用来接收前面传入的实际参数

interface Interface5 {
    int fun5(int i, int j);
}

public class LambdaDemo5 {
    public static void main(String[] args) {
        fun(3, 7, (a, b) -> a + b);
    }

    public static void fun(int m, int n, Interface5 interface5) {
        System.out.println("sum = " + interface5.fun5(3, 7));

    }
}

Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”

前面已经演示过。上述Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为javac编译的时候会根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断

Lambda用法再简洁之方法引用

对象的引用 :: 实例方法名

当我们要执行的表达式是调用某个对象的方法，并且这个方法的参数列表和接口里抽象函数的参数列表一一对应时，我们就可以采用引用对象的方法的格式。

接口的实现方式是的调用其他对象的方法

interface Interface1 {
    void fun1(int i, int j);
}
public class LambdaDemo1 {
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        // 标准写法
        fun(3,7,(m,n)->{test1.fun(m,n);});
        // 简化写法
        fun(3, 7, test1::fun);

    }
    public static void fun(int m, int n, Interface1 interface1) {
        interface1.fun1(m, n);
    }
}
class Test1 {
    public void fun(int m, int n) {
        int sum = m+n;
        System.out.println("sum = " + sum);
    }
}

类 :: 静态方法名

interface Interface2{
    void fun2(String s1,String s2);
}
public class LambdaDemo2 {
    public static void main(String[] args) {
        // 标准写法
        fun("hello","world",(s1,s2)->{Test2.concat(s1,s2);});
        // 简化写法
        fun("hello","world",Test2::concat);
    }
    public static void fun(String str1,String str2,Interface2 interface2){
        interface2.fun2(str1,str2);
    }
}
class Test2{
    public static void concat(String s1,String s2){
        System.out.println(s1 + s2);
    }
}

类 :: 实例方法名

若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时

格式： ClassName::MethodName

interface Interface3 {
    boolean fun3(String s1, String s2);
}

public class LambdaDemo3 {
    public static void main(String[] args) {
        String str1 = "hello world java hadoop";
        String str2 = "java";
        // 标准写法
        fun(str1, str2, (s1, s2) -> s1.contains(s2));
        // 简化写法
        fun(str1,str2,String::contains);
    }

    public static void fun(String str1, String str2, Interface3 interface3) {
        System.out.println("isContains : " + interface3.fun3(str1, str2));
    }
}

构造方法引用 ClassName::new

interface Interface4 {
    Student fun4(String s, int i, char c);
}

public class LambdaDemo4 {
    public static void main(String[] args) {
        // 标准写法
        fun("神里绫华",18,'女',(s,i,c)->new Student(s,i,c));
        // 简化写法
        fun("神里绫华",18,'女',Student::new);
    }

    public static void fun(String name, int age, char gender, Interface4 interface4) {
        Student student = interface4.fun4(name,age,gender);
        System.out.println(student);
    }
}
class Student {
    private String name;
    private int age;
    private char gender;

    public Student(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
}

元素类型[] :: new

import java.util.Arrays;
import java.util.Random;

interface Interface5<T> {
    T[] fun5(int i);
}

public class LambdaDemo5 {
    public static void main(String[] args) {
        //标准写法	-- 如果用的是这种方式，则创建的是要给包含该元素的数组
        fun(new Random().nextInt(100),(i)->new Integer[]{i});
        // 简化写法	-- 如果用的是这种方式，则创建的是一个指定长度的空数组
        fun(3,Integer[]::new);
    }
    public static void fun(int m,Interface5<Integer> interface5) {
        Integer[] arr = interface5.fun5(m);
        System.out.println(Arrays.toString(arr));
    }
}

四种内嵌接口

免去了我们自定义接口的过程，直接使用java提供的接口就行

断言型

判断功能的接口，返回布尔值

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}   
// 就是布尔型的返回值，判定 true | false

函数型

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

供给型

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

消费型

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

枚举类

枚举类型是Java中一种用于统一管理有限的常量数据的数据类型。它将常量设置为对象，提高了代码的可读性和简洁性。通过使用枚举类型，可以在代码中更方便地读取和使用常量

将枚举相关的对象放在开头SPRING("春天", "春暖花开")
创建枚举类的属性(成员遍历)，必须是作为私有常量出现
必须将构造方法私有化，这是为了保证类的对象是有限个的目的
提供公共的获取属性的方法
重写toString()方法

使用示例：

enum Season2{
    //如果使用enum定义一个枚举类的话，必须将有限个对象放在类中的第一部分
    SPRING("春天","鸟语花香"), // public static final Season SPRING = new Season("春天","鸟语花香");
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋风萧瑟"),
    WINTER("冬天","银装素裹");

    private String name;
    private String info;

    private Season2(String name, String info) {
        this.name = name;
        this.info = info;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
    }
    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", info='" + info + '\'' +
                '}';
    }
}
public class EnumDemo2 {
    public static void main(String[] args) {
        Season2 summer = Season2.SUMMER;
        System.out.println(summer);
    }
}

posted @ 2025-01-19 20:58 爱己内求阅读(3) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Java基础

· 集合与泛型

· Lambda表达式概述

· day20

· 一，Lambda表达式

公告

昵称：爱己内求
园龄： 3个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类

大数据学习之历程(11)

ajnq-fz