反射、枚举、lambda表达式

于 2024-07-15 21:09:19 发布
阅读量782 收藏 16
点赞数 19
分类专栏： Java数据结构 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79890350/article/details/140446253
版权

反射

定义

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

用途(了解)

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

反射基本信息

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

反射相关的类（重要）

在这里插入图片描述

Class类(反射机制的起源)

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

Class类中的相关方法

  • 常用获得类相关的方法
    在这里插入图片描述
  • 常用获得类中属性相关的方法(以下方法返回值为Field相关)
    在这里插入图片描述
  • 获得类中注解相关的方法
    在这里插入图片描述
  • 获得类中构造器相关的方法（以下方法返回值为Constructor相关）
    在这里插入图片描述
  • 获得类中方法相关的方法（以下方法返回值为Method相关）
    在这里插入图片描述

反射示例

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

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

获得Class对象的三种方式

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

反射的使用

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

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

枚举

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

定义

public enum TestEnum {
	RED,BLACK,GREEN;
}

使用

  1. switch语句
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;
		}
	}
}
  1. 常用方法
    Enum类的常用方法
    在这里插入图片描述

示例一

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

示例二

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当中枚举实际上就是一个类。所以在定义枚举的时候，还可以这样定义和使用枚举：

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

枚举和反射

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)

异常信息为java.lang.NoSuchMethodException: TestEnum.<init>(java.lang.String, int)
意思是：没有对应的构造方法，但我们提供的枚举的构造方法就是两个参数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<?> classStudent = Class.forName("TestEnum");
            //注意传入对应的参数,获得对应的构造方法来构造对象,当前枚举类是提供了两个参数分别是String和int。
            Constructor<?> declaredConstructorStudent = 
classStudent.getDeclaredConstructor(String.class,int.class,String.class,int.class);
            //设置为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: 异常?
看源码：
在这里插入图片描述
枚举在这里被过滤了，我们不能通过反射获取枚举类的实例。

总结

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

Lambda表达式

背景

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

Lambda表达式的语法

基本语法: (parameters) -> expression 或 (parameters) -> { statements; }
Lambda表达式由三部分组成：

  1. paramaters ：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明，也可不声明而由JVM隐含的推断。当只有一个推断类型时可以省略掉圆括号。
    2.-> ：可理解为“被用于”的意思
  2. 方法体 ：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不返回 ，这里的代码块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不返回。
// 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. 如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要保证接口中只有一个抽象方法，就可以不加这个注解。加上就会自动进行检测的。
    定义方式：
@FunctionalInterface
interface NoParameterNoReturn {
	//注意：只能有一个方法
	void test();
}

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

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

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

具体使用：

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

语法精简

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

变量捕获

Lambda 表达式中存在变量捕获 ，了解了变量捕获之后，我们才能更好的理解Lambda 表达式的作用域 。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这个方法！");
           }
       };
   }
}

匿名内部类的变量捕获

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修饰的，就要保证在使用之前没有修改。如下代码就是错误的代码：

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
                        +" 我是一个常量，或者是一个没有改变过值的变量！");
            }
       };
   }
}

该代码直接编译报错。

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

Lambda在集合当中的使用

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

SHtop11
关注
专栏目录
数据结构之反射与Lambda表达式
m0_58006481的博客
03-26 1445
反射：Class:反射操作的核心类（区别class，class是一个声明类的关键字）；Constructor:与构造方法相关的类；Method:与类中方法相关的类；Field:与类中属性相关的类。Lambda表达式使用：不同情况Lambda表达式使用（返回值有无，参数有无）
Java中反射、枚举及lambda表达式的使用
dddddrrrzz的博客
03-02 1365
目录一、反射1.1 定义1.2 用途1.3 反射基本信息1.4 与反射相关的类1.5 Class类(反射机制的起源 )1.6 Class类中的相关方法1.7 获得Class对象的三种方式1.8 反射的使用1.9 反射优点和缺点二、枚举2.1 Enum 类的常用方法2.2 枚举的优点和缺点三、Lambda 表达式总结 一、反射 1.1 定义 Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到，那
反射枚举及 Lambda的使用
java_yifei的博客
08-02 447
反射 定义 Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。 ** 用途(了解)** 1、在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法
反射选择器表达式
最佳 Java 编程
06-12 146
Java :: Geci是在单元测试期间运行的代码生成器。 如果生成的代码适合源代码的实际版本，则测试不会失败。 如果需要进行任何修改，则测试会修改源代码并失败。 例如，有一个新的字段需要一个setter和getter，然后访问器生成器将生成新的setter和getter，然后失败。 如果没有新字段，那么生成的代码就是已经存在的代码，没有理由触摸源代码：启动生成器的测试成功完成。 因为J...
Java反射、正则表达式
Denovo的博客
01-21 273
/* * JAVA反射机制是在运行状态中，对于任意一个类 (class文件)，都能够知道这个类的所有属性和方法； * 对于任意一个对象，都能够调用它的任意一个方法和属性； * 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 * * 动态获取类中信息，就是java反射 。 * 可以理解为对类的解剖。 * * 要想要对字节码文件进行解剖，必须要有字节码...
将一个字符串的首字母大写
m0_37846887的博客
03-04 1632
实际开发中会用到反射，通过反射会去获取对象的属性，根据属性类型可能需要获取getter serter方法，首先就要先将获 得的属性名，首字母大写 // 把一个字符串的第一个字母大写、效率是最高的、 109 private static String getMethodName(String fildeName) throws Exception{ 110 ...
反射，枚举，lambda表达式
m0_67401499的博客
06-21 369
目录一、反射1、反射2、用途3、反射相关的类（1）Class类（2）Filed类（3）Method类（4）ConStructor类4、反射示例（1）获取class类的三种方法?（2）反射的使用5、反射的优缺点二、枚举1、定义2、使用?3、枚举的优缺点4、枚举和反射三、Lambda表达式1、Lambda的语法2、函数式接口3、Lambda表达式的使用4、变量捕获5、Lambda表达式在集合中的使用(1)Collection接口的forEach()方法（2）List接口的sort()方法（3）HashMap的f
注解&&Lambda表达式
qq_43310689的博客
10-13 2289
文章目录一、注解1、注解基础知识2、内置注解2.1、@Override2.2、@Deprecated2.3、@SuppressWarnings3、自定义注解3.1、**定义格式：**3.2、**注解的本质：**3.3、注解属性3.4、元注解4、程序中使用（解析）注解5、综合案例6、后记二、Lambda 表达式1、Lambda 表达式概述语法2、Lambda 表达式实例3、变量作用域4、函数式接口5、常用技巧三、Stream1、什么是 Stream？2、生成流3、操作流3.1、forEach3.2、过滤3.3
java 多态替代switch表达式+lambda表达式
guohao_Kwok的博客
07-10 4348
精选30+云产品，助力企业轻松上云！>>> 原代码：...
C# Lambda表达式和表达式树（二）:表达式树
lionheart922的专栏
09-05 934
以编程方式构建表达式树 System.Linq.Expressions命名空间包含了代表表达式的各个类，它们都继承自Expression Expression类包含两个属性 Type属性代表表达式求值后的.NET类型，可把它视为一个返回类型，例如，如果一个表达式要获取一个字符串的Length属性，该表达式的类型是int。 NodeType属性返回所代表的表达式的种类。它是Express...
利用反射生成 MyBatisPlus中QueryWrapper动态条件
哈
08-10 1940
问题 在MyBatisPlus中经常会用到如下所示的代码来构造查询条件： QueryWrapper<User> queryWrapper = new QueryWrapper<>(); if (userQuery.getId() != null) { queryWrapper.eq("id", userQuery.getId()); } if (userQuery.getName() != null) { queryWrapper.like("name", user
EF使用反射进行 Lambda 多条件动态拼接
weixin_39381688的博客
06-02 986
下面是代码，其实主要就是用Expression生成指定的lambda， 算是抛砖引玉吧 /// <summary> /// 多条件查询 /// </summary> /// <typeparam name="TEntity">映射实体</typeparam> public class IQueryableForSearch<TEntity> where TEntity : TEntityFather .
Java 重载解析 lambda
qq_43489936的博客
11-25 491
在Java中可以重载方法，造成多个方法有相同的方法名，但签名确不一样。这在推断参数类型时会带来问题，因为系统可能会推断出多种类型。这时，javac会挑出最具体的类型。如下文中的方法调用在选择定义的重载方法时，输出String，而不是Object overloadedMethod("abc"); 对应的接口定义 private void overloadedMethod(Object o) { System.out.println("Object"); } private void o
反射方式调用enum的方法
热门推荐
进化的深山猿
11-07 1万+
代码中存在很多结构相似的枚举，需要分别调用其方法名称相同的方法，所以选择使用反射调用 枚举代码如下： package com.ruisitech.bi.enums.bireport; /** * @author：mazhen * @date：2018/9/13 11:46: * @description:用户类型枚举 */ public enum UserTypeEnum { ...
ClassForname
qq_37891064的博客
04-14 5176
1.什么是class对象     类是程序的一部分，每个类都有一个class对象。换言之，每当编写并且编译了一个新类，就会产生一个class对象（更恰当的说，是被保存在一个同名的class文件中）。为了生成这个类的对象，运行这个程序的Java虚拟机（jvm）将使用被称为“类加载器”的子系统。    所有的类都是在对其第一次使用的时候被加载到JVM中。如当程序创建对第一个静态成员的引用时，就会加载这...
利用lambda优化反射功能实现方法调用
回炉重造P的博客
06-14 1059
简单写了下lambda代替反射的demo，之前几个项目里面有用到使用代理类来实现项目中的 实现的，这种大量调用的情况如果在初始化过程中使用lambdaFactory，之后之间使用函数对象调用，能快不少，有空改写下试试。
MybatisPlus入门
weixin_41438423的博客
06-14 4153
MyBatisPlus（简称MP）是基于`MyBatis`框架基础上开发的增强型工具，旨在简化开发、提高效率
LambdaQueryWrapper与QueryWrapper的使用
不愧是暮言的博客
05-25 8023
在Mybatis-plus框架中，LambdaQueryWrapper和QueryWrapper是两个非常常用的类。它们用于快速简便地查询数据库。LambdaQueryWrapper是Mybatis-plus 3.0.7版本之后推出的一个查询工具类，它采用lambda表达式构建SQL查询语句，可以快速、简便地完成CRUD等操作。
MyBatis-Plus中LambdaQueryWrapper的探究
最新发布
XiaoMingTongXue的博客
01-10 2130
这儿主要是一个缓存的作用，关于这个缓存，值得一提的是，虽然MyBatis-Plus这儿用的是clazz.getName，但是实际测试后发现同一个class下同一个位置的Lambda表达式，即使在多线程环境中，也会复用同一个对象。先说可序列化的Lambda，回头看LambdaQueryWrapper的参数，是一个SFunction，除了实现了Function外，还实现了Serializable，确实满足可序列化的Lambda的条件。也就是说，文章最开头匿名内部类的写法是错误的，不支持的。
Java的常见面试题给我来一车
02-06
9. Java 中的 Lambda 表达式是什么？Java 中的 Lambda 表达式有什么用处？ 10. Java 中的流式 API 是什么？Java 中的流式 API 有什么用处？ 这些问题仅是 Java 面试的一小部分，具体的问题可能因公司和岗位而异。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值