Java数据结构：从入门到精通(十三)

反射、枚举以及lambda表达式

1. 反射

1.1 定义

Java的反射（reflection）机制是在运⾏时检查、访问和修改类、接⼝、字段和⽅法的机制；这种动态获取信息以及动态调⽤对象⽅法的功能称为java语⾔的反射（reflection）机制。

1.2 ⽤途(了解)

框架开发
注解处理
动态代理
配置⽂件解析
等等

1.3 反射相关的类（重要）

类名	用途
Class类	代表类的实体，在运行的Java应用程序中表示类和接口
Field类	代表类的成员变量/类的属性
Method类	代表类的方法
Constructor类	代表类的构造方法

1.3.1 Class类(反射机制的起源)

Class帮助⽂档代表类的实体，在运⾏的Java应⽤程序中表⽰类和接⼝

Java文件编译后会生成.class文件，JVM需要加载并解析这些.class文件。实际上，JVM会将每个.class文件解析为一个对象，这个对象就是java.lang.Class类的实例。因此，在程序运行时，每个Java类最终都会对应一个Class类的实例对象。

通过Java的反射机制操作这些Class对象，我们可以获取甚至修改类的属性和方法，从而实现动态操作类的功能。这使得Java类具备了动态特性。

1.3.1.1 Class类中的相关⽅法(⽅法的使⽤⽅法在后边的⽰例当中)

**(重要)**常⽤获得类相关的⽅法

方法	用途
getClassLoader()	获得类的加载器
getDeclaredClasses()	返回一个数组，数组中包含该类中所有类和接口类的对象(包括私有的)
forName(String className)	根据类名返回类的对象
newInstance()	创建类的实例
getName()	获得类的完整路径名字

(重要) 常⽤获得类中属性相关的⽅法(以下⽅法返回值为Field相关)

方法	用途
getField(String name)	获得某个公有的属性对象
getFields()	获得所有公有的属性对象
getDeclaredField(String name)	获得某个属性对象
getDeclaredFields()	获得所有属性对象

(了解)获得类中注解相关的⽅法

方法	用途
getAnnotation(Class<A> annotationClass)	返回该类中与参数类型匹配的公有注解对象
getAnnotations()	返回该类所有的公有注解对象
getDeclaredAnnotation(Class<A> annotationClass)	返回该类中与参数类型匹配的所有注解对象
getDeclaredAnnotations()	返回该类所有的注解对象

(重要) 获得类中构造器相关的⽅法（以下⽅法返回值为Constructor相关）

方法	用途
getConstructor(Class...<?> parameterTypes)	获得该类中与参数类型匹配的公有构造方法
getConstructors()	获得该类的所有公有构造方法
getDeclaredConstructor(Class...<?> parameterTypes)	获得该类中与参数类型匹配的构造方法
getDeclaredConstructors()	获得该类所有构造方法

(重要) 获得类中⽅法相关的⽅法（以下⽅法返回值为Method相关）

方法	用途
getMethod(String name, Class...<?> parameterTypes)	获得该类某个公有的方法
getMethods()	获得该类所有公有的方法
getDeclaredMethod(String name, Class...<?> parameterTypes)	获得该类某个方法
getDeclaredMethods()	获得该类所有方法

1.3.2 反射⽰例

1.3.2.1 获得Class对象的三种⽅式

在实现反射机制前，首先需要获取目标类的Class对象。通过操作Class对象的核心方法，我们就能实现反射的核心功能：在运行时动态获取任意类的属性和方法，并能调用任意对象的方法和属性。这种机制还允许我们修改部分类型信息。

获取Class对象主要有三种方式：

使用Class.forName("类的全路径名")静态方法
- 适用场景：已知类的完整路径名
使用.class语法
- 适用场景：编译时已确定要操作的类
调用对象的getClass()方法

java 复制代码

class Student {
    //私有属性name
    private String name = "bit";
    //公有属性age
    public int age = 18;
    //不带参数的构造⽅法
    public Student(){
        System.out.println("Student()");
    }
    private Student(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("Student(String,name)");
    }
    private void eat(){
        System.out.println("i am eat");
    }
    public void sleep(){
        System.out.println("i am pig");
    }
    private void function(String str) {
        System.out.println(str);
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) {
/*
1.通过getClass获取Class对象
*/
        Student s1 = new Student();
        Class c1 = s1.getClass();
/*
2.直接通过 类名.class 的⽅式得到,该⽅法最为安全可靠，程序性能更⾼
这说明任何⼀个类都有⼀个隐含的静态成员变量 class
*/
        Class c2 = Student.class;
/*
3、通过 Class 对象的 forName() 静态⽅法来获取，⽤的最多，
但可能抛出 ClassNotFoundException 异常
*/
        Class c3 = null;
        try {
//注意这⾥是类的全路径，如果有包需要加包的路径
            c3 = Class.forName("Student");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
//⼀个类在 JVM 中只会有⼀个 Class 实例,即我们对上⾯获取的
//c1,c2,c3进⾏ equals ⽐较，发现都是true
        System.out.println(c1.equals(c2));
        System.out.println(c1.equals(c3));
        System.out.println(c2.equals(c3));
    }
}

1.3.2.2 反射的使⽤

接下来我们开始使⽤反射，我们依旧反射上⾯的Student类，把反射的逻辑写到另外的类当中进⾏理解
**注意：**所有和反射相关的包都在 import java.lang.reflect 包下⾯。

java 复制代码

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectClassDemo {
    // 创建对象
    public static void reflectNewInstance() {
        try {
            Class<?> classStudent = Class.forName("Student");
            Object objectStudent = classStudent.newInstance();
            Student student = (Student) objectStudent;
            System.out.println("获得学⽣对象："+student);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    // 反射私有的构造⽅法 屏蔽内容为获得公有的构造⽅法
    public static void reflectPrivateConstructor() {
        try {
            Class<?> classStudent = Class.forName("Student");
//注意传⼊对应的参数
            Constructor<?> declaredConstructorStudent =
                    classStudent.getDeclaredConstructor(String.class,int.class);
//Constructor<?> declaredConstructorStudent =
            classStudent.getConstructor();
//设置为true后可修改访问权限
            declaredConstructorStudent.setAccessible(true);
            Object objectStudent = declaredConstructorStudent.newInstance("⾼
                    博",15);
//Object objectStudent = declaredConstructorStudent.newInstance();
                    Student student = (Student) objectStudent;
            System.out.println("获得私有构造哈数且修改姓名和年龄："+student);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    // 反射私有属性
    public static void reflectPrivateField() {
        try {
            Class<?> classStudent = Class.forName("Student");
            Field field = classStudent.getDeclaredField("name");
            field.setAccessible(true);
//可以修改该属性的值
            Object objectStudent = classStudent.newInstance();
            Student student = (Student) objectStudent;
            field.set(student,"⼩明");
            String name = (String) field.get(student);
            System.out.println("反射私有属性修改了name："+ name);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    // 反射私有⽅法
    public static void reflectPrivateMethod() {
        try {
            Class<?> classStudent = Class.forName("Student");
            Method methodStudent =
                    classStudent.getDeclaredMethod("function",String.class);
            System.out.println("私有⽅法的⽅法名为："+methodStudent.getName());
//私有的⼀般都要加
            methodStudent.setAccessible(true);
            Object objectStudent = classStudent.newInstance();
            Student student = (Student) objectStudent;
            methodStudent.invoke(student,"我是给私有的function函数传的参数");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    public static void main(String[] args) {
//reflectNewInstance();
//reflectPrivateConstructor();
//reflectPrivateField();
        reflectPrivateMethod();
    }
}

1.4 反射优点和缺点

优点：

能够动态获取类的所有属性和方法，并支持对任意对象的方法调用
提升程序灵活性和扩展性，降低模块间耦合度，增强自适应能力
广泛应用于主流框架如Struts、Hibernate、Spring等

缺点：

存在性能开销，可能导致程序效率降低（参考：反射性能分析）
绕过源代码直接操作，增加了代码复杂度，可能带来维护困难

1.5 重点总结

反射的核心价值
反射关键类解析：Class类、Field类、Method类、Constructor类
反射使用准则：必须在安全环境下合理运用

2. 枚举的使⽤

2.1 背景及定义

枚举是在JDK1.5以后引⼊的。主要⽤途是：将⼀组常量组织起来，在这之前表⽰⼀组常量通常使⽤定义常量的⽅式：

java 复制代码

public static final int RED = 1;
public static final int GREEN = 2;
public static final int BLACK = 3;

然而使用常量存在一些缺陷。比如数字1可能被误认为是RED的表示。我们可以改用枚举来组织这些值，这样就能获得明确的枚举类型，而非普通的整型数值1。

java 复制代码

public enum TestEnum {
    RED,BLACK,GREEN;
}

优点：将常量组织起来统⼀进⾏管理

场景：错误状态码，消息类型，颜⾊的划分，状态机等等....
本质：是 java.lang.Enum 的⼦类，也就是说，⾃⼰写的枚举类，就算没有显⽰的继承 Enum ，但是其默认继承了这个类。

2.2 使⽤

switch语句

java 复制代码

public enum TestEnum {
    RED,BLACK,GREEN,WHITE;

    public static void main(String[] args) {
        TestEnum testEnum = TestEnum.BLACK;
        switch(testEnum){
            case RED:
                System.out.println("red");
                break;
            case BLACK:
                System.out.println("black");
                break;
            case WHITE:
                System.out.println("WHITE");
                break;
            case GREEN:
                System.out.println("black");
                break;
            default:
                break;
        }
    }
}

常⽤⽅法

方法名称	描述
values()	以数组形式返回枚举类型的所有成员
ordinal()	获取枚举成员的索引位置
valueOf()	将普通字符串转换为枚举实例
compareTo()	比较两个枚举成员在定义时的顺序

⽰例⼀：

java 复制代码

public enum TestEnum {
    RED,BLACK,GREEN,WHITE;

    public static void main(String[] args) {
        TestEnum[] testEnums = TestEnum.values();
        for(TestEnum i : testEnums){
            System.out.println(i + " " + i.ordinal()+" ");
        }
        System.out.println("=========================");
        System.out.println(TestEnum.valueOf("GREEN"));
    }
}

⽰例⼆：

java 复制代码

public enum TestEnum {
    RED,BLACK,GREEN,WHITE;
    public static void main(String[] args) {
//拿到枚举实例BLACK
        TestEnum testEnum = TestEnum.BLACK;
//拿到枚举实例RED
        TestEnum testEnum21 = TestEnum.RED;
        System.out.println(testEnum.compareTo(testEnum21));
        System.out.println(BLACK.compareTo(RED));
        System.out.println(RED.compareTo(BLACK));
    }
}

刚刚说过，在Java当中枚举实际上就是⼀个类。所以我们在定义枚举的时候，还可以这样定义和使⽤枚举：

重要：枚举的构造⽅法默认是私有的

java 复制代码

public enum TestEnum {
    RED("red",1),BLACK("black",2),WHITE("white",3),GREEN("green",4);
    private String name;
    private int key;
    /**
     * 1、当枚举对象有参数后，需要提供相应的构造函数
     * 2、枚举的构造函数默认是私有的 这个⼀定要记住
     * @param name
     * @param key
     */
    private TestEnum (String name,int key) {
        this.name = name;
        this.key = key;
    }
    public static TestEnum getEnumKey (int key) {
        for (TestEnum t: TestEnum.values()) {
            if(t.key == key) {
                return t;
            }
        }
        return null;
    }
    public static void main(String[] args) {
        System.out.println(getEnumKey(2));
    }
}

2.3 枚举优点缺点

优点：

枚举常量定义简单且类型安全
自带内置方法，代码实现更优雅

缺点：

不支持继承，缺乏扩展性

2.4 枚举和反射

2.4.1 枚举是否可以通过反射，拿到实例对象呢?

我们刚刚在反射⾥边看到了，任何⼀个类，哪怕其构造⽅法是私有的，我们也可以通过反射拿到他的实例对象，那么枚举的构造⽅法也是私有的，我们是否可以拿到呢？接下来，我们来实验⼀下：

同样利⽤上述提供的枚举类来进⾏举例：

java 复制代码

public enum TestEnum {
    RED("red",1),BLACK("black",2),WHITE("white",3),GREEN("green",4);
    private String name;
    private int key;
    /**
     * 1、当枚举对象有参数后，需要提供相应的构造函数
     * 2、枚举的构造函数默认是私有的 这个⼀定要记住
     * @param name
     * @param key
     */
    private TestEnum (String name,int key) {
        this.name = name;
        this.key = key;
    }
    public static TestEnum getEnumKey (int key) {
        for (TestEnum t: TestEnum.values()) {
            if(t.key == key) {
                return t;
            }
        }
        return null;
    }
    public static void reflectPrivateConstructor() {
        try {
            Class<?> classStudent = Class.forName("TestEnum");
//注意传⼊对应的参数,获得对应的构造⽅法来构造对象,当前枚举类是提供了两个参数分别是String和int。
            Constructor<?> declaredConstructorStudent =
                    classStudent.getDeclaredConstructor(String.class,int.class);
//设置为true后可修改访问权限
            declaredConstructorStudent.setAccessible(true);
            Object objectStudent = declaredConstructorStudent.newInstance("绿
                    ⾊",666);
                    TestEnum testEnum = (TestEnum) objectStudent;
            System.out.println("获得枚举的私有构造函数："+testEnum);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    public static void main(String[] args) {
        reflectPrivateConstructor();
    }
}

输出结果：

java.lang.NoSuchMethodException: TestEnum.<init>(java.lang.String, int)

at java.lang.Class.getConstructor0(Class.java:3082)

at java.lang.Class.getDeclaredConstructor(Class.java:2178)

at TestEnum.reflectPrivateConstructor(TestEnum.java:40)

at TestEnum.main(TestEnum.java:54)

我们提供的枚举的构造⽅法就是两个参数分别是 String 和 int ，这⾥的异常信息是

java.lang.NoSuchMethodException: TestEnum.<init>(java.lang.String,int) 枚举⽐较特殊，虽然我们写的是两个，但是默认他还添加了两个参数，哪两个参数呢？我们看⼀下Enum类的源码：

java 复制代码

protected Enum(String name, int ordinal) {
    this.name = name;
    this.ordinal = ordinal;
}

java 复制代码

    public static void reflectPrivateConstructor() {
        try {
            Class<?> classStudent = Class.forName("TestEnum");
//注意传⼊对应的参数,获得对应的构造⽅法来构造对象,当前枚举类是提供了两个参数分别是String和int。
            Constructor<?> declaredConstructorStudent =
                    classStudent.getDeclaredConstructor(String.class,int.class,String.class,int.cla ss);
//设置为true后可修改访问权限
            declaredConstructorStudent.setAccessible(true);
//后两个为⼦类参数，⼤家可以将当前枚举类的key类型改为double验证
            Object objectStudent = declaredConstructorStudent.newInstance("⽗类参 数",666,"⼦类参数",888);
            TestEnum testEnum = (TestEnum) objectStudent;
            System.out.println("获得枚举的私有构造函数："+testEnum);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

此时运⾏程序结果是：

java.lang.IllegalArgumentException: Cannot reflectively create enum objects

at java.lang.reflect.Constructor.newInstance(Constructor.java:416)

at TestEnum.reflectPrivateConstructor(TestEnum.java:46)

at TestEnum.main(TestEnum.java:55)

这正是我需要的结果！当前报错信息显示，问题出在 newInstance() 方法上。让我们深入分析这个方法的源码，看看为何会抛出 java.lang.IllegalArgumentException 异常。

源码显⽰

是的，枚举类型在这里会被过滤，无法通过反射获取枚举类的实例！这道题源自2017年阿里巴巴的一道经典面试题，结果令人意外。重点提示：为什么枚举实现单例模式是线程安全的？建议同学们牢记这个知识点。

2.5 总结

枚举本⾝就是⼀个类，其构造⽅法默认为私有的，且都是默认继承与 java.lang.Enum
枚举可以避免反射和序列化问题
枚举的优点和缺点

2.6 ⾯试问题(单例模式学完后可以回顾)：

写⼀个单例模式。

java 复制代码

    public class Singleton {
        private volatile static Singleton uniqueInstance;

        private Singleton() {
        }

        public static Singleton getInstance() {
            if (uniqueInstance == null) {
                synchronized (Singleton.class) {
                    if (uniqueInstance == null) { //进⼊区域后，再检查⼀次，如果仍是null,才创建实例
                        uniqueInstance = new Singleton();
                    }
                }
            }
            return uniqueInstance;
        }
    }

⽤静态内部类实现⼀个单例模式

java 复制代码

    class Singleton {
        /** 私有化构造器 */
        private Singleton() {
        }
        /** 对外提供公共的访问⽅法 */
        public static Singleton getInstance() {
            return UserSingletonHolder.INSTANCE;
        }
        /** 写⼀个静态内部类，⾥⾯实例化外部类 */
        private static class UserSingletonHolder {
            private static final Singleton INSTANCE = new Singleton();
        }
    }
    public class Main {
        public static void main(String[] args) {
            Singleton u1 = Singleton.getInstance();
            Singleton u2 = Singleton.getInstance();
            System.out.println("两个实例是否相同："+ (u1==u2));
        }
    }

⽤枚举实现⼀个单例模式

java 复制代码

    public enum TestEnum {
        INSTANCE;
        public TestEnum getInstance(){
            return INSTANCE;
        }
        public static void main(String[] args) {
            TestEnum singleton1=TestEnum.INSTANCE;
            TestEnum singleton2=TestEnum.INSTANCE;
            System.out.println("两个实例是否相同："+(singleton1==singleton2));
        }
    }

3. Lambda表达式

3.1 背景

Lambda表达式是Java SE 8的重要新特性，它允许开发者用简洁的表达式替代功能接口。与普通方法类似，Lambda表达式包含参数列表和执行主体（可以是表达式或代码块）。这种语法源于数学中的λ演算，也被称为闭包(Closure)。

3.1.1 Lambda表达式的语法

Lambda表达式基本语法：

(parameters) -> expression
(parameters) -> { statements; }

Lambda表达式包含三个组成部分：

参数列表：类似方法形参列表，对应函数式接口中的参数。参数类型可以显式声明，也可由JVM隐式推断。当仅有一个推断类型参数时，圆括号可省略
箭头符号 ->：表示"被用于"的含义
方法体 ：可以是单行表达式或代码块，用于实现函数式接口中的方法：
- 代码块可返回值或不返回（与普通方法体相同）
- 表达式可返回值或不返回

// 1. 不需要参数,返回值为 2

() -> 2

// 2. 接收⼀个参数(数字类型),返回其2倍的值

x -> 2 * x

// 3. 接受2个参数(数字),并返回他们的和

(x, y) -> x + y

// 4. 接收2个int型整数,返回他们的乘积

(int x, int y) -> x * y

// 5. 接受⼀个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)

(String s) -> System.out.print(s)

3.1.2 函数式接⼝

理解Lambda表达式，首先要明确函数式接口的概念。函数式接口是指仅包含一个抽象方法的接口。

注意：

当接口仅包含一个抽象方法时，即可视为函数式接口
使用@FunctionalInterface注解时，编译器会严格校验接口是否符合函数式接口定义。若存在多个抽象方法，将导致编译错误。实际上，只要确保接口只有一个抽象方法，该注解可省略。添加注解后，编译器会自动进行验证。

定义⽅式：

@FunctionalInterface

interface NoParameterNoReturn {

//注意：只能有⼀个⽅法

void test();

}

但是这种⽅式也是可以的：

@FunctionalInterface

interface NoParameterNoReturn {

void test();

default void test2() {

System.out.println("JDK1.8新特性，default默认⽅法可以有具体的实现");

}

}

3.2 Lambda表达式的基本使⽤

⾸先，我们事先准备好⼏个接⼝：

java 复制代码

    //⽆返回值⽆参数
    @FunctionalInterface
    interface NoParameterNoReturn {
        void test();
    }
    //⽆返回值⼀个参数
    @FunctionalInterface
    interface OneParameterNoReturn {
        void test(int a);
    }
    //⽆返回值多个参数
    @FunctionalInterface
    interface MoreParameterNoReturn {
        void test(int a,int b);
    }
    //有返回值⽆参数
    @FunctionalInterface
    interface NoParameterReturn {
        int test();
    }
    //有返回值⼀个参数
    @FunctionalInterface
    interface OneParameterReturn {
        int test(int a);
    }
    //有返回值多参数
    @FunctionalInterface
    interface MoreParameterReturn {
        int test(int a,int b);
    }

我们之前提到过，Lambda表达式可以理解为匿名内部类的简化形式。实际上，Lambda会创建一个实现了指定接口并重写其方法的类。

不使用Lambda表达式时的调用方式：

java 复制代码

    NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
        @Override
        public void test() {
            System.out.println("hello");
        }
    };
noParameterNoReturn.test();

具体使⽤⻅以下⽰例代码：

java 复制代码

    public class TestDemo {
        public static void main(String[] args) {
            NoParameterNoReturn noParameterNoReturn = ()->{
                System.out.println("⽆参数⽆返回值");
            };
            noParameterNoReturn.test();
            OneParameterNoReturn oneParameterNoReturn = (int a)->{
                System.out.println("⼀个参数⽆返回值："+ a);
            };
            oneParameterNoReturn.test(10);
            MoreParameterNoReturn moreParameterNoReturn = (int a,int b)->{
                System.out.println("多个参数⽆返回值："+a+" "+b);
            };
            moreParameterNoReturn.test(20,30);
            NoParameterReturn noParameterReturn = ()->{
                System.out.println("有返回值⽆参数！");
                return 40;
            };
//接收函数的返回值
            int ret = noParameterReturn.test();
            System.out.println(ret);
            OneParameterReturn oneParameterReturn = (int a)->{
                System.out.println("有返回值有⼀个参数！");
                return a;
            };
            ret = oneParameterReturn.test(50);
            System.out.println(ret);
            MoreParameterReturn moreParameterReturn = (int a,int b)->{
                System.out.println("有返回值多个参数！");
                return a+b;
            };
            ret = moreParameterReturn.test(60,70);
            System.out.println(ret);
        }
    }

3.2.1 语法精简

参数类型可以省略，如果需要省略，每个参数的类型都要省略。
参数的⼩括号⾥⾯只有⼀个参数，那么⼩括号可以省略
如果⽅法体当中只有⼀句代码，那么⼤括号可以省略
如果⽅法体中只有⼀条语句，且是return语句，那么⼤括号可以省略，且去掉return关键字。

⽰例代码：

java 复制代码

    public static void main(String[] args) {
        MoreParameterNoReturn moreParameterNoReturn = ( a, b)->{
            System.out.println("⽆返回值多个参数，省略参数类型："+a+" "+b);
        };
        moreParameterNoReturn.test(20,30);
        OneParameterNoReturn oneParameterNoReturn = a ->{
            System.out.println("⽆参数⼀个返回值,⼩括号可以胜率："+ a);
        };
        oneParameterNoReturn.test(10);
        NoParameterNoReturn noParameterNoReturn = ()->System.out.println("⽆参数⽆返
                回值，⽅法体中只有⼀⾏代码");
                noParameterNoReturn.test();
//⽅法体中只有⼀条语句，且是return语句
        NoParameterReturn noParameterReturn = ()-> 40;
        int ret = noParameterReturn.test();
        System.out.println(ret);
    }

3.3 变量捕获

在Lambda表达式中存在变量捕获机制，理解这一概念有助于我们更深入地掌握Lambda表达式的作用域。值得注意的是，Java的匿名类同样支持变量捕获功能。

3.3.1 匿名内部类

匿名内部类是一种没有名称的内部类。本文主要讲解变量捕获的概念，因此我们只需掌握匿名内部类的基本用法即可。下面通过简单示例来演示其使用方法。

如需深入了解匿名内部类，可参考这篇文章： https://www.cnblogs.com/SQP51312/p/6100314.html

现在让我们通过代码示例进行学习：

java 复制代码

class Test {
    public void func(){
        System.out.println("func()");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        new Test(){
            @Override
            public void func() {
                System.out.println("我是内部类，且重写了func这个⽅法！");
            }
        };
    }
}

在上述代码当中的main函数当中，我们看到的就是⼀个匿名内部类的简单的使⽤。

3.3.2 匿名内部类的变量捕获

java 复制代码

class Test {
    public void func(){
        System.out.println("func()");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        int a = 100;
        new Test(){
            @Override
            public void func() {
                System.out.println("我是内部类，且重写了func这个⽅法！");
                System.out.println("我是捕获到变量 a == "+a
                        +" 我是⼀个常量，或者是⼀个没有改变过值的变量！");
            }
        };
    }
}

代码中的变量a属于捕获变量。该变量必须满足以下条件之一：

被final修饰；
未被final修饰时，在使用前未被修改。以下示例代码展示了错误用法。

java 复制代码

public class TestDemo {
    public static void main(String[] args) {
        int a = 100;
        new Test(){
            @Override
            public void func() {
                a = 99;
                System.out.println("我是内部类，且重写了func这个⽅法！");
                System.out.println("我是捕获到变量 a == "+a
                        +" 我是⼀个常量，或者是⼀个没有改变过值的变量！");
            }
        };
    }
}

该代码直接编译报错。

3.3.3 Lambda的变量捕获

在Lambda当中也可以进⾏变量的捕获，具体我们看⼀下代码。

java 复制代码

@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
    public static void main(String[] args) {
        int a = 10;
        NoParameterNoReturn noParameterNoReturn = ()->{
// a = 99; error
            System.out.println("捕获变量："+a);
        };
        noParameterNoReturn.test();
    }

3.4 Lambda在集合当中的使⽤

为了能够让Lambda和Java的集合类集更好的⼀起使⽤，集合当中，也新增了部分接⼝，以便与

Lambda表达式对接。

对应的接口	新增的方法
Collection	removeIf() spliterator() stream() parallelStream() forEach()
List	replaceAll() sort()
Map	getOrDefault() forEach() replaceAll() putIfAbsent() remove() replace() computeIfAbsent() computeIfPresent() compute() merge()

以上⽅法的作⽤可⾃⾏查看我们发的帮助⼿册。我们这⾥会⽰例⼀些⽅法的使⽤。注意：Collection的forEach()⽅法是从接⼝ java.lang.Iterable 拿过来的。

3.4.1 Collection接⼝

forEach() ⽅法演⽰

该⽅法在接⼝ Iterable 当中，原型如下：

java 复制代码

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

该⽅法表⽰：对容器中的每个元素执⾏action指定的动作。

java 复制代码

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("world");
        list.add("hello");
        list.add("lambda");
        list.forEach(new Consumer<String>(){
            @Override
            public void accept(String str){
//简单遍历集合中的元素。
                System.out.print(str+" ");
            }
        });
    }

我们可以修改为如下代码：

java 复制代码

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("world");
        list.add("hello");
        list.add("lambda");
//表⽰调⽤⼀个，不带有参数的⽅法，其执⾏花括号内的语句，为原来的函数体内容。
        list.forEach(s -> {
            System.out.println(s);
        });
    }

3.4.2 List接⼝

sort()⽅法的演⽰

sort⽅法源码：该⽅法根据c指定的⽐较规则对容器元素进⾏排序。

java 复制代码

    public void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

使⽤⽰例：

java 复制代码

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("world");
        list.add("hello");
        list.add("lambda");
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String str1, String str2){
//注意这⾥⽐较⻓度
                return str1.length()-str2.length();
            }
        });
        System.out.println(list);
    }

修改为lambda表达式：

java 复制代码

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("world");
        list.add("hello");
        list.add("lambda");
//调⽤带有2个参数的⽅法，且返回⻓度的差值
        list.sort((str1,str2)-> str1.length()-str2.length());
        System.out.println(list);
    }

3.4.3 Map接⼝

HashMap 的 forEach()

该⽅法原型如下：

java 复制代码

    default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }

作⽤是对Map中的每个映射执⾏action指定的操作。

代码⽰例：

java 复制代码

    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "world");
        map.put(3, "hello");
        map.put(4, "lambda");
        map.forEach(new BiConsumer<Integer, String>(){
            @Override
            public void accept(Integer k, String v){
                System.out.println(k + "=" + v);
            }
        });
    }

使⽤lambda表达式后的代码：

java 复制代码

    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "bit");
        map.put(3, "hello");
        map.put(4, "lambda");
        map.forEach((k,v)-> System.out.println(k + "=" + v));
    }

3.5 总结

Lambda表达式具有显著的优点，主要体现在代码简洁性方面。当然，它也存在一些不足之处，特别是对代码可读性的影响。

主要优势：

显著提升代码简洁度，加快开发效率
完美契合函数式编程范式
天然支持并行计算
为Java集合操作带来革命性改进

主要缺点：

降低代码可读性
在串行计算场景下，性能可能不如传统for循环
调试难度较大

Java数据结构部分到这已经结束,感谢您的观看!