反射、枚举以及lambda表达式等补充

寻星探路

发布于 2025-12-17 18:43:11

1080

一、字符串常量池

1、创建对象的思考

下面两种创建String对象的方式相同吗？

 public static void main(String[] args) {
     String s1 = "hello";
     String s2 = "hello";
     String s3 = new String("hello");
     String s4 = new String("hello");
     System.out.println(s1 == s2);    // true
     System.out.println(s1 == s3);    // false
     System.out.println(s3 == s4);    // false
 }

上述程序创建方式类似，为什么s1和s2引用的是同一个对象，而s3和s4不是呢？

在Java程序中，类似于：1， 2， 3，3.14，“hello”等字面类型的常量经常频繁使用，为了使程序的运行速度更快、更节省内存，Java为8种基本数据类型和String类都提供了常量池。

"池" 是编程中的一种常见的, 重要的提升效率的方式, 我们会在未来的学习中遇到各种 "内存池", "线程池", "数据库连接池" ....

比如：家里给大家打生活费的方式

（1）家里经济拮据，每月定时打生活费，有时可能会晚，最差情况下可能需要向家里张口要，速度慢

（2）家里有矿，一次性打一年的生活费放到银行卡中，自己随用随取，速度非常快

方式（2），就是池化技术的一种示例，钱放在卡上，随用随取，效率非常高。常见的池化技术比如：数据库连接池、线程池等。

为了节省存储空间以及程序的运行效率，Java中引入了：

（1）Class文件常量池：每个.Java源文件编译后生成.Class文件中会保存当前类中的字面常量以及符号信息

（2）运行时常量池：在.Class文件被加载时，.Class文件中的常量池被加载到内存中称为运行时常量池，运行时常量池每个类都有一份

（3）字符串常量池

2、字符串常量池(StringTable)

字符串常量池在JVM中是StringTable类，实际是一个固定大小的HashTable(一种高效用来进行查找的数据结构，后序给大家详细介绍)，不同JDK版本下字符串常量池的位置以及默认大小是不同的：

3、再谈String对象创建

由于不同JDK版本对字符串常量池的处理方式不同，此处在Java8 HotSpot上分析

3.1直接使用字符串常量进行赋值

 public static void main(String[] args) {
     String s1 = "hello";
     String s2 = "hello";
     System.out.println(s1 == s2);    // true
 }

3.2通过new创建String类对象

结论：只要是new的对象，都是唯一的。

通过上面例子可以看出：使用常量串创建String类型对象的效率更高，而且更节省空间。用户也可以将创建的字符串对象通过 intern 方式添加进字符串常量池中。

3.3intern方法

intern是一个native方法(Native方法指：底层使用C++实现的，看不到其实现的源代码)，该方法的作用是手动将创建的String对象添加到常量池中。

 public static void main(String[] args) {
     char[] ch = new char[]{'a', 'b', 'c'};
     String s1 = new String(ch);     // s1对象并不在常量池中
     //s1.intern();                 
     // s1.intern()；调用之后，会将s1对象的引用放入到常量池中
     String s2 = "abc";        
     // "abc" 在常量池中存在了，s2创建时直接用常量池中"abc"的引用
     System.out.println(s1 == s2);
 }

 // 输出false
 // 将上述方法打开之后，就会输出true

#注：在Java6 和 Java7、8中Intern的实现会有些许的差别

二、反射

1、定义

Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

2、用途

（1）在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。

（2）反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有的类Bean交给spring容器管理，无论是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的就是类的信息，spring根据这些信息，需要创建那些Bean，spring就动态的创建这些类。

3、反射基本信息

Java程序中许多对象在运行时会出现两种类型：运行时类型(RTTI)和编译时类型，例如Person p = new Student()；这句代码中p在编译时类型为Person，运行时类型为Student。程序需要在运行时发现对象和类的真实信息。而通过使用反射程序就能判断出该对象和类属于哪些类。

4 反射相关的类

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

Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为一个对象，这个对象就是java.lang.Class .这样当程序在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类 .

（1）Class类中的相关方法(方法的使用方法在后边的示例当中)

(重要)常用获得类相关的方法

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

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

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

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

4.2反射示例

（1）获得Class对象的三种方式

在反射之前，我们需要做的第一步就是先拿到当前需要反射的类的Class对象，然后通过Class对象的核心方法，达到反射的目的，即：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息。

第一种，使用 Class.forName("类的全路径名"); 静态方法。

前提：已明确类的全路径名。

第二种，使用 .class 方法。

说明：仅适合在编译前就已经明确要操作的 Class

第三种，使用类对象的 getClass() 方法

示例：

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: GAOBO
 * Date: 2020-02-20
 * Time: 15:24
 */
 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));
    }
 }

（2）反射的使用

接下来我们开始使用反射，我们依旧反射上面的Student类，把反射的逻辑写到另外的类当中进行理解

#注：所有和反射相关的包都在import java.lang.reflect 包下面。

            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));
    }
 }
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 
/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: GAOBO
 * Date: 2020-02-20
 * Time: 16:31
 */
 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();
    }
 }

5、反射优点和缺点

优点：

（1）对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法

（2）增加程序的灵活性和扩展性，降低耦合性，提高自适应能力

（3）反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。

缺点：

（1）使用反射会有效率问题。会导致程序效率降低。

（2）反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂。

6、重点总结

（1）反射的意义

（2）反射重要的几个类： Class类、Field类、 Method类、 Constructor类

（3）学会合理利用反射，一定要在安全环境下使用。

三、枚举的使用

1、背景及定义

枚举是在JDK1.5以后引入的。主要用途是：将一组常量组织起来，在这之前表示一组常量通常使用定义常量的方式：

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

但是常量举例有不好的地方，例如：可能碰巧有个数字1，但是他有可能误会为是RED，现在我们可以直接用枚举来进行组织，这样一来，就拥有了类型，枚举类型。而不是普通的整形1.

 public enum TestEnum {
    RED,BLACK,GREEN;
 }

优点：将常量组织起来统一进行管理

场景：错误状态码，消息类型，颜色的划分，状态机等等....

本质：是java.lang.Enum的子类，也就是说，自己写的枚举类，就算没有显示的继承Enum，但是其默认继承了这个类。

2、使用

2.1switch语句

 public static  final int RED = 1;
 public static  final int GREEN = 2;
 public static  final int BLACK = 3;
 public enum TestEnum {
    RED,BLACK,GREEN;
 }
 public enum TestEnum {
    RED,BLACK,GREEN,WHITE;
    public static void main(String[] args) {
        TestEnum testEnum2 = TestEnum.BLACK;
       switch (testEnum2) {
            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;
        }
    }
 }

2.2常用方法

Enum类的常用方法

示例一：

 /**
 * Created with IntelliJ IDEA.
 * Description:
 * User: GAOBO
 * Date: 2020-02-06
 * Time: 16:19
 */
 public enum TestEnum {
    RED,BLACK,GREEN,WHITE;
    public static void main(String[] args) {
        TestEnum[] testEnum2 =  TestEnum.values();
        for (int i = 0; i < testEnum2.length; i++) {
            System.out.println(testEnum2[i] + " " + testEnum2[i].ordinal());
        }
        System.out.println("=========================");
        System.out.println(TestEnum.valueOf("GREEN"));
    }
 }

示例二：

 /**
 * Created with IntelliJ IDEA.
 * Description:
 * User: GAOBO
 * Date: 2020-02-06
 * Time: 16:19
 */
 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当中枚举实际上就是一个类。所以我们在定义枚举的时候，还可以这样定义和使用枚举：

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

 /**
 * Created with IntelliJ IDEA.
 * Description:
 * User: GAOBO
 * Date: 2020-02-06
 * Time: 16:19
 */
 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));
     }
 }

3、枚举优点缺点

优点：

（1）枚举常量更简单安全。

（2）枚举具有内置方法，代码更优雅

缺点：

（1）不可继承，无法扩展

四、Lambda表达式

1、背景

Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression），基于数学中的λ演算得名，也可称为闭包（Closure）。

1.1Lambda表达式的语法

基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }

Lambda表达式由三部分组成：

（1）paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。

（2）->：可理解为“被用于”的意思

（3）方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不返回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不返回。

// 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)

1.2函数式接口

要了解Lambda表达式,首先需要了解什么是函数式接口，函数式接口定义：一个接口有且只有一个抽象方法。

注意：

（1）如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口

（2）如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。

定义方式：

 @FunctionalInterface
 interface NoParameterNoReturn {
    //注意：只能有一个方法
    void test();
 }

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

@FunctionalInterface
 interface NoParameterNoReturn {
    void test();
    default void test2() {
        System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");
    }
 }

2、Lambda表达式的基本使用

首先，我们实现准备好几个接口：

 //无返回值无参数
 @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表达式的时候的调用方式：

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

2.1语法精简

（1）参数类型可以省略，如果需要省略，每个参数的类型都要省略。

（2）参数的小括号里面只有一个参数，那么小括号可以省略

（3）如果方法体当中只有一句代码，那么大括号可以省略

（4）如果方法体中只有一条语句，且是return语句，那么大括号可以省略，且去掉return关键字。

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、变量捕获

Lambda 表达式中存在变量捕获，了解了变量捕获之后，我们才能更好的理解Lambda 表达式的作用域。Java当中的匿名类中，会存在变量捕获。

3.1匿名内部类

匿名内部类就是没有名字的内部类。我们这里只是为了说明变量捕获，所以，匿名内部类只要会使用就好，那么下面我们来，简单的看看匿名内部类的使用就好了。

我们通过简单的代码来学习一下：

 /**
 * Created with IntelliJ IDEA.
 * Description:
 * User: GAOBO
 * Date: 2020-04-15
 * Time: 16:16
 */
 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.2匿名内部类的变量捕获

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修饰的你要保证在使用之前，没有修改。就是错误的代码，直接编译报错。

3.3Lambda的变量捕获

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

@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();
 }

4、Lambda在集合当中的使用

为了能够让Lambda和Java的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与Lambda表达式对接。

4.1Collection接口

forEach()方法演示

该方法在接口Iterable当中，原型如下：

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

该方法表示：对容器中的每个元素执行action指定的动作。

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

输出结果：Hello bit hello lambda

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

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

输出结果：Hello bit hello lambda

4.2List接口

sort()方法的演示

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

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++;
 }

使用示例：

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("bit");
        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);
 }

输出结果：bit, Hello, hello, lambda

修改为lambda表达式：

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

输出结果：bit, Hello, hello, lambda

4.3Map接口

HashMap的forEach()

该方法原型如下：

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指定的操作。

代码示例：

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(new BiConsumer<Integer, String>(){
        @Override
        public void accept(Integer k, String v){
            System.out.println(k + "=" + v);
        }
    });
 }

输出结果：

1=hello 2=bit 3=hello 4=lambda

使用lambda表达式后的代码：

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));
 }

输出结果：

1=hello 2=bit 3=hello 4=lambda

5、总结

Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读。

优点：

（1）代码简洁，开发迅速

（2）方便函数式编程

（3）非常容易进行并行计算

（4）Java 引入Lambda，改善了集合操作

缺点：

（1）代码可读性变差

（2）在非并行计算中，很多计算未必有传统的 for 性能要高

（3）不容易进行调试

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-08-08，如有侵权请联系 cloudcommunity@tencent.com 删除

反射

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度