反射、枚举及lambda表达式

最新推荐文章于 2024-05-25 10:57:37 发布

羽翼~

最新推荐文章于 2024-05-25 10:57:37 发布

阅读量120

点赞数 2

分类专栏：初阶数据结构-Java 文章标签：开发语言 java

本文链接：https://blog.csdn.net/qq_64668629/article/details/133964186

版权

初阶数据结构-Java 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

文章目录

一、反射
二、枚举
三、lambda表达式

一、反射

1.1 定义和用途

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

在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。
反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有的类Bean交给spring容器管理，无论是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的就是类的信息，spring根据这些信息，需要创建那些Bean，spring就动态的创建这些类。

1.2 反射基本信息

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

1.3 反射相关的类（重要）

在这里插入图片描述

1.4 Class类（反射机制的起源）

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

常用获得类相关方法**(重要)**
常用获得类中属性相关的方法**(重要)**(以下方法返回值为Field相关)
获得类中构造器相关的方法**(重要)**（以下方法返回值为Constructor相关）
获得类中方法相关的方法**(重要)**（以下方法返回值为Method相关）
获得类中注解相关的方法(了解)

2. 反射示例
2.1 获得Class对象的三种方式
在反射前，需要做的第一步是拿到当前需要反射的类的Class对象，然后通过Class对象的核心方法，达到反射的目的，即：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息。
第一种：使用Class.forName(“类的全路径名”)，静态方法。
前提：已明确类的全路径名
第二种：使用**.class方法。
说明：仅适合在编译前就已经明确要操作的 Class
第三种：使用类对象的getClass()**方法。
在这里插入图片描述
Student类放在包reflect中。

class Student{
   //私有属性name
   private String name = "hello";
   //公有属性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("私有的方法，正在吃饭");
   }
   public void sleep(){
      System.out.println("公有的方法，正在睡觉");
   }
   private void function(String str) {
      System.out.println("私有的方法，str"+str);
   }
   @Override
   public String toString() {
      return "Student{" +
	  "name='" + name + '\'' +
	  ", age=" + age +
	  '}';
	  }
   }
public class Text {
    public static void main(String[] args) {
        // 1.通过getClass获取Class对象
        Student student1 = new Student();
        Class class1 = student1.getClass();
        /*
            2.直接通过 类名.class 的方式得到,该方法最安全可靠，程序性能更高
            说明任何一个类都有一个隐含的静态成员变量 class
         */
        Class class2 = Student.class;
        /*
            3.通过 Class对象的 forName() 静态方法来获取，用的最多
            注意这里是类的全路径，如果有包需要加包的路径
            可能抛出 ClassNotFoundException 异常
         */
        Class class3 = null;
        try{
            class3 = Class.forName("reflect.Student");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(class1);//class reflect.Student
        System.out.println(class2);//class reflect.Student
        System.out.println(class3);//class reflect.Student
        /*
           一个类在 JVM 中只会有一个 Class 实例
         */
        System.out.println(class1 == class2);//true
        System.out.println(class1 == class3);//true
        System.out.println(class2 == class3);//true
    }
}

2.2 反射的使用
接下来开始使用反射，反射上面的Student类，把反射的逻辑写到另外的类当中进行理解
注意：所有和反射相关的包都在 import java.lang.reflect 包下面。

package reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectText {
    //创建对象
    public static void reflectNewInstance(){
        try{
            Class<?> classStudent = Class.forName("reflect.Student");
            //                                       创建类的实例
            Student student = (Student) classStudent.newInstance();
            /*
              Student():公开的且不带参数的构造方法
              Student{name='hello', age=18}
              以上为打印结果
            */
            System.out.println(student);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    //反射私有的构造方法，屏蔽共有构造方法
    public static void reflectPrivateConstructor(){
        try {
            Class<?> classStudent = Class.forName("reflect.Student");
            //注意传入对应的参数
            Constructor<?> declaredconstructorStudent = classStudent.getDeclaredConstructor(String.class,int.class);
            ///设置为true后可修改访问权限  此时，私有的构造方法为公有
            declaredconstructorStudent.setAccessible(true);
            Student student = (Student) declaredconstructorStudent.newInstance("wangwu",15);
            /*
            Student(String,name)：私有的且带两个参数的构造方法
            获取私有构造函数并修改姓名和年龄：Student{name='wangwu', age=15}
            以上为打印内容
             */
            System.out.println("获取私有构造函数并修改姓名和年龄："+student);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //反射私有属性
    public static void reflectPrivateField(){
        try {
            Class<?> classStudent = Class.forName("reflect.Student");
            Field field = classStudent.getDeclaredField("name");
            field.setAccessible(true);
            //可以修改该属性的值
            Student student = (Student) classStudent.newInstance();
            field.set(student,"小明");
            /*
            Student():公开的且不带参数的构造方法
            Student{name='小明', age=18}
            以上为打印内容
             */
            System.out.println(student);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //反射私有方法
    public static void reflectPrivateMethod() {
        try {
            Class<?> classStudent = Class.forName("reflect.Student");
            //                                                            方法名     参数
            Method methodStudent = classStudent.getDeclaredMethod("function", String.class);
            //私有的要加setAccessible(true) 才能使用
            methodStudent.setAccessible(true);
            Student student = (Student) classStudent.newInstance();
            /*
            Student():公开的且不带参数的构造方法
            私有的方法，str反射私有的方法并调用
            以上为打印内容
             */
            methodStudent.invoke(student,"反射私有的方法并调用");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        //reflectNewInstance();
        //reflectPrivateConstructor();
        //reflectPrivateField();
        reflectPrivateMethod();
    }
}

1.5 反射优缺点

优点：

对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法
增加程序的灵活性和扩展性，降低耦合性，提高自适应能力
反射已经运用在很多流行框架如：Struts、Hibernate、Spring 等等
缺点：
使用反射会有效率问题。会导致程序效率降低。
反射技术绕过源代码的技术，会带来维护问题。反射代码比相应的直接代码更复杂。

1.6 总结

反射意义：当某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放时，可以通过反射来获取所需的私有成员或是方法。
反射重要的几个类： Class类、Field类、 Method类、 Constructor类。
学会合理利用反射，一定要在安全环境下使用。

二、枚举

2.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 使用

1.switch语句

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

    public static void main(String[] args) {
        EnumText enumText1 = EnumText.RED;
        EnumText enumText2 = EnumText.BLACK;
        EnumText enumText3 = EnumText.GREEN;
        System.out.println(enumText1);//RED
        System.out.println(enumText2);//BLACK
        System.out.println(enumText3);//GREEN
        switch (enumText1){
            case RED:
                System.out.println("red");
                break;
            case BLACK:
                System.out.println("black");
                break;
            case GREEN:
                System.out.println("green");
                break;
            case WHITE:
                System.out.println("white");
                break;
            default:
                break;
        }
    }
}

2.Enum类常用方法
在这里插入图片描述

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

    public static void main(String[] args) {
        //.values()获取枚举类型所有成员
        EnumText[] enumText1 = EnumText.values();
        for (int i = 0; i < enumText1.length; i++) {
            //.ordinal()获取枚举成员索引位置
            //RED: 0
            //BLACK: 1
            //GREEN: 2
            //WHITE: 3
            System.out.println(enumText1[i]+": "+enumText1[i].ordinal());
        }
        System.out.println(EnumText.valueOf("GREEN"));//GREEN
    }
}

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

    public static void main(String[] args) {
        EnumText enumText1 = EnumText.RED;
        EnumText enumText2 = EnumText.BLACK;
        System.out.println(enumText1.compareTo(enumText2));//-1
        System.out.println(RED.compareTo(enumText2));//-1
        System.out.println(RED.compareTo(BLACK));//-1
    }
}

在Java当中枚举实际上就是一个类，在定义枚举时，还可以这样定义和使用枚举：
重要：枚举的构造方法默认是私有的

public enum EnumText2 {
    RED("red",1),BLACK("black",2),GREEN("green",3),WHITE("white",4);//枚举成员必须在第一行
    private String name;
    private int key;

    /**
     * 当枚举对象有参数后，需要提供相应的构造方法,且构造方法是私有的
     * @param name
     * @param key
     */
    private EnumText2(String name,int key){
        this.name = name;
        this.key = key;
    }
    public static EnumText2 getEnumKey(int key){
        for (EnumText2 enumText2:EnumText2.values()) {
            if (enumText2.key == key){
                return enumText2;
            }
        }
        return null;
    }

    public static void main(String[] args) {
        System.out.println(getEnumKey(0));//null
        System.out.println(getEnumKey(1));//RED
    }
}

2.3 枚举优缺点

优点：

枚举常量更简单安全
枚举具有内置方法，代码更优雅
缺点：
不可继承，无法扩展

2.4 枚举和反射

1.枚举是否可以通过反射，拿到实例对象呢？
通过对上述反射的了解，可以知道，任何一个类，哪怕其构造方法是私有的，我们也可以通过反射拿到他的实例对象，那么枚举的构造方法也是私有的，我们是否可以拿到呢？接下来，我们来实验一下：

public enum EnumText2 {
    RED("red",1),BLACK("black",2),GREEN("green",3),WHITE("white",4);
    private String name;
    private int key;

    /**
     * 当枚举对象有参数后，需要提供相应的构造方法,且构造方法是私有的
     * @param name
     * @param key
     */
    private EnumText2(String name,int key){
        this.name = name;
        this.key = key;
    }
    //获取key对应的枚举成员
    public static EnumText2 getEnumKey(int key){
        for (EnumText2 enumText2:EnumText2.values()) {
            if (enumText2.key == key){
                return enumText2;
            }
        }
        return null;
    }
    //获取枚举的私有构造方法
    public static void reflectPrivateConstructor() {
        try {
            //                   获取Class对象：EnumText2
            Class<?> classEnum = Class.forName("enums.EnumText2");
            //获取私有构造方法                                  当前枚举类是提供了两个参数分别是String和int
            Constructor<?> declaredConstructorEnum = classEnum.getDeclaredConstructor(String.class,int.class);
            // 设为true 修改构造方法访问权限
            declaredConstructorEnum.setAccessible(true);
            //                                                        创建类的实例
            EnumText2 enumText2 = (EnumText2) declaredConstructorEnum.newInstance("蓝色",555);
            System.out.println("获取枚举的私有构造方法："+enumText2);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        reflectPrivateConstructor();
    }
}

运行结果：
在这里插入图片描述
异常信息是： java.lang.NoSuchMethodException: TestEnum.(java.lang.String, int) ,意思是：就是没有对应的构造方法，所有的枚举类，都是默认继承与 java.lang.Enum ，继承了父类除构造函数外的所有东西，并且子类要帮助父类进行构造！而我们写的类，并没有帮助父类构造，那意思是，我们要在自己的枚举类里面，提供super吗？不是的，枚举比较特殊，虽然写的是两个，但是默认他还添加了两个参数，哪两个参数呢？我们看一下Enum类的源码：

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

也就是说，自己的构造函数有两个参数一个是String一个是int，同时他默认后边还会给两个参数，一个是String一个是int，也就是说，这里我们正确给的是4个参数

//获取枚举的私有构造方法
    public static void reflectPrivateConstructor() {
        try {
            //                   获取Class对象：EnumText2
            Class<?> classEnum = Class.forName("enums.EnumText2");
            //获取私有构造方法                         提供了4个参数分别是String、int、String、int
            Constructor<?> declaredConstructorStudent=
                    classEnum.getDeclaredConstructor(String.class,int.class,String.class,int.class);
            // 设为true 修改构造方法访问权限
            declaredConstructorStudent.setAccessible(true);
            //                                                        创建类的实例
            EnumText2 enumText2 = (EnumText2)declaredConstructorStudent.newInstance("父类参数",222,"蓝色",555);

            System.out.println("获取枚举的私有构造方法："+enumText2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

运行结果：
在这里插入图片描述
此时的异常信息是：IllegalArgumentException，提示我们不能反射地创建枚举对象，即不能通过反射获取枚举类的实例

2.5 总结

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

三、lambda表达式

3.1 背景

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

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

paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由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)

2.函数式接口

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

如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接
口，这样如果有两个抽象方法，程序编译就会报错的。
定义方式：

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

但这种方式也是可以的：

@FunctionalInterface
interface NoParameterNoReturn {
   void test();
   default void test2() {
      System.out.println("函数式接口中的普通方法");
   }
}

3.2 基本使用

先准备好几个接口：

//无返回值无参数
@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 noParameterNoReturn = new NoParameterNoReturn() {
     @Override
     public void test() {
          System.out.println("实现接口中无参数无返回值的方法");
     }
};
noParameterNoReturn.test();

具体使用见以下示例代码:

public class LambdaText {
    public static void main(String[] args) {
        //无参数无返回值
        NoParameterNoReturn noParameterNoReturn = ()-> System.out.println("重写接口中无参数无返回值的方法text()");
        noParameterNoReturn.test();
        //有一个参数无返回值
        OneParameterNoReturn oneParameterNoReturn = a-> System.out.println("重写接口中 有一个参数无返回值的方法 text()"+a);
        oneParameterNoReturn.test(10);
        //有多个参数无返回值
        MoreParameterNoReturn moreParameterNoReturn = (a,b)-> System.out.println("重写接口中 有多个参数无返回值的方法 text()"+(a+b));
        moreParameterNoReturn.test(10,15);

        //无参数有返回值
        NoParameterReturn noParameterReturn = ()-> {System.out.println("重写接口中 无参数有返回值的方法text()");return 1;};
        noParameterReturn.test();
        //有一个参数有返回值
        OneParameterReturn oneParameterReturn = a -> {System.out.println("重写接口中 有一个参数有返回值的方法text()"+a);return 2;};
        oneParameterReturn.test(10);
        //有多个参数有返回值
        MoreParameterReturn moreParameterReturn = (a,b)-> {System.out.println("重写接口中 有多个参数有返回值的方法text()"+(a+b));return 3;};
        moreParameterReturn.test(10,15);
    }
}

总结：

参数类型可以省略，如果需要省略，每个参数的类型都要省略
参数的小括号里面只有一个参数，那么小括号可以省略
如果方法体当中只有一句代码（非return语句），那么大括号可以省略
如果方法体中只有一条语句，且是return语句，那么大括号可以省略，且去掉return关键字。方法体中只要有return语句，都需要大括号。

3.3 变量捕获

Lambda 表达式中存在变量捕获，了解了变量捕获之后，我们才能更好的理解Lambda 表达式的作用域。Java当
中的匿名类中，会存在变量捕获。
1.匿名内部类
匿名内部类就是没有名字的内部类，这里只是为了说明变量捕获，故匿名内部类只要会使用就好，那么下面我们来简单的看看匿名内部类的使用就好了。
匿名内部类详解

class Text{
    public void  func(){
        System.out.println("func()");
    }
}
public class AnonymityText {
    public static void main(String[] args) {
        new Text(){
            @Override
            public void func() {
                System.out.println("创建内部类，重写Text中的普通方法func()");
            }
        };
    }
}

在上述代码当中的main函数当中，就是一个匿名内部类的简单的使用。
2.匿名内部类的变量捕获

class Text{
    public void  func(){
        System.out.println("func()");
    }
}
public class AnonymityText {
    public static void main(String[] args) {
        int a = 100;
        new Text(){
            @Override
            public void func() {
                System.out.println("创建内部类，重写Text中的普通方法func()");
                System.out.println("内部类捕获到一个变量a："+a);
            }
        };
    }
}

在上述代码中的变量a就是捕获的变量，这个变量要么是被final修饰，要么是没有改变过值的变量。如下代码就是错误的代码：

public class AnonymityText {
    public static void main(String[] args) {
        int a = 100;
        new Text(){
            @Override
            public void func() {
                a = 90;
                System.out.println("创建内部类，重写Text中的普通方法func()");
                System.out.println("内部类捕获到一个变量a："+a);
            }
        };
    }
}

public class AnonymityText {
    public static void main(String[] args) {
        int a = 100;
        new Text(){
            @Override
            public void func() {
                System.out.println("创建内部类，重写Text中的普通方法func()");
                System.out.println("内部类捕获到一个变量a："+a);
                 a = 90;
            }
        };
    }
}

上述代码编译报错
3.Lambda的变量捕获
在Lambda当中也可以进行变量的捕获

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
public static void main(String[] args) {
        int a = 100;
        NoParameterNoReturn noParameterNoReturn = ()-> {
            // int a = 90; error
            System.out.println("捕获变量a："+a);
        };
        noParameterNoReturn.test();
    }

3.4 在集合当中的使用

为了能够让Lambda和Java的集合类集更好的一起使用，集合当中也新增部分接口，以便与Lambda表达式对
接。
在这里插入图片描述
注意：Collection的forEach()方法是从接口 java.lang.Iterable 拿过来的。
1.Collection接口

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("lambda");
   list.forEach(new Consumer<String>(){
      @Override
      public void accept(String str){
          //简单遍历集合中的元素
         System.out.print(str+" ");
      }
   });
}

输出结果：Hello lambda
可以修改为如下代码：

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

2.List接口

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("lambda");
   list.sort(new Comparator<String>() {
      @Override
      public int compare(String str1, String str2){
         //注意这里比较长度
         return str1.length()-str2.length();
      }
   });
   System.out.println(list);
}

输出结果： Hello, lambda
修改为lambda表达式：

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

输出结果：Hello,lambda

3.5 总结

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

代码简洁，开发迅速
方便函数式编程
非常容易进行并行计算
Java 引入 Lambda，改善集合操作
缺点：
代码可读性变差
在非并行计算中，很多计算未必有传统的 for 性能高
不容易进行调试

羽翼~

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
2
评论
反射、枚举及lambda表达式

定义：Java的反射机制是在运行状态中对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。用途在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。反射最重要的用途就是开发各种通用框架。
复制链接

扫一扫