Java数据结构与算法第十一课---反射、枚举以及lambda表达式

news2024/11/24 13:01:55

一 : 反射

1.定义

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

2.用途

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

3.反射相关的类

在这里插入图片描述

4.Class类(反射机制的起源)

4.1简介

Class类代表类的实体,在运行的Java应用程序中表示类和接口 .

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

4.2Class类的相关方法

4.2.1常用获得类相关的方法

在这里插入图片描述

4.2.2常用获得类中属性相关的方法

在这里插入图片描述

4.2.3获得类中注解相关的方法

在这里插入图片描述

4.2.4获得类中构造器相关的方法

在这里插入图片描述

4.2.5获得类中方法相关的方法

在这里插入图片描述

5.反射示例

5.1获得Class对象的三种方式

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

在这里插入图片描述

package reflectdemo;


class Student {
    //私有属性name
    private String name = "zhangsan";
    //公有属性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 Test {
    public static void main(String[] args) {
        Student student = new Student();

        Class<?> c1 = student.getClass();// 使用类对象的getClass方法

        Class<?> c2 = Student.class;// 使用.class方法
        
        Class<?> c3 = null;
        try {
            c3 = Class.forName("reflectdemo.Student");// 使用Class.forName("类的全路径名")
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        System.out.println(c1.equals(c2));
        System.out.println(c1.equals(c3));
        System.out.println(c3 .equals(c2));
        
        /*
        * 三个class对象都相等,说明一个类对应一个class对象
        * */
    }
}

在这里插入图片描述

5.2反射的使用

package reflectdemo;

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

public class ReflectClassDemo {

    /**
     * 反射获取对象
     */
    public static void reflectNewInstance() {
        Class<?> c3 = null;
        try {
            c3 = Class.forName("reflectdemo.Student");
            Student student = (Student)c3.newInstance();
            System.out.println(student);
            student.sleep();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    /**
     * 通过反射,调用构造方法[公开和私有的都可以]
     */
    public static void reflectPrivateConstructor() {
        Class<?> c3 = null;
        try {
            c3 = Class.forName("reflectdemo.Student");

            Constructor<?> constructor =
                    c3.getDeclaredConstructor(String.class,int.class);

            //因为构造方法是私有的,所以将该属性设置为true,就认为可以调用私有的方法
            constructor.setAccessible(true);

            Student student = (Student)constructor.newInstance("laobai",20);

            System.out.println(student);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    /**
     * 通过反射,调用属性
     */
    public static void reflectPrivateField() {
        Class<?> c3 = null;
        try {
            c3 = Class.forName("reflectdemo.Student");
            Student student = (Student) c3.newInstance();

            Field field = c3.getDeclaredField("name");
            field.setAccessible(true);
            field.set(student,"laojin");
            System.out.println(student);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }

    /**
     * 通过反射,调用私有方法
     */
    public static void reflectPrivateMethod() {
        Class<?> c3 = null;
        try {
            c3 = Class.forName("reflectdemo.Student");
            Student student = (Student) c3.newInstance();
            Method method = c3.getDeclaredMethod("function", String.class);// 方法名,方法参数
            method.setAccessible(true);
            method.invoke(student,"我传一个参数试试!");// 调用的实例,参数
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        //reflectNewInstance();
        //reflectPrivateConstructor();
        //reflectPrivateField();
        reflectPrivateMethod();
    }

}

6.反射优缺点

优点:

  1. 对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法 ;
  2. 增加程序的灵活性和扩展性,降低耦合性,提高自适应能力 ;
  3. 反射已经运用在了很多流行框架如:Struts、Hibernate、Spring 等等。

缺点:

  1. 使用反射会有效率问题。会导致程序效率降低。具体参考
  2. 反射技术绕过了源代码的技术,因而会带来维护问题。反射代码比相应的直接代码更复杂 。

重点总结 :

  1. 反射的意义
  2. 反射重要的几个类: Class类 、Field类、 Method类、 Constructor类
  3. 学会合理利用反射,一定要在安全环境下使用

二 : 枚举

1 背景及定义

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

public static final int YANLONG = 1;
public static final int FENGYING = 2;
public static final int XUEAO = 3;

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

public enum TestEnum {
	YANLOGN,FENGYING,HEIXI,XUEAO;
}

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

场景:错误状态码,消息类型,颜色的划分,状态机等等…

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

2.枚举的使用

2.1switch语句

package enumdemo;


public enum TestEnum {
    //枚举对象
    YANLONG("炎龙侠",0),
    FENGYING("风鹰侠",1),
    HEIXI("黑犀侠",2),
    XUEAO("雪獒侠",3);

    public String armour;
    public int ordinal;

    //枚举的构造方法默认是私有的
    private TestEnum() {

    } 

    private TestEnum(String armour,int ordinal) {
        this.armour = armour;
        this.ordinal = ordinal;
    }

    public static void main(String[] args) {
        TestEnum testEnum = TestEnum.YANLONG;
        switch (testEnum) {
            case YANLONG:
                System.out.println("炎龙侠 升腾炎上就是焰火的力量");
                break;
            case FENGYING:
                System.out.println("风鹰侠 曲直屈伸就是巨木的力量");
                break;
            case HEIXI:
                System.out.println("黑犀侠 滋润掩藏但发出狂啸的力量");
                break;
            case XUEAO:
                System.out.println("雪獒侠 他有能刚能柔之金的力量");
                break;
            default:
                break;
        }
    }
}

在这里插入图片描述

2.2常用方法

Enum类的常用方法 :

在这里插入图片描述

示例一 :

package enumdemo;

public enum TestEnum {
    //枚举对象
    YANLONG("炎龙侠",0),
    FENGYING("风鹰侠",1),
    HEIXI("黑犀侠",2),
    XUEAO("雪獒侠",3);

    public String armour;
    public int ordinal;

    //枚举的构造方法默认是私有的
    TestEnum() {

    } 

    private TestEnum(String armour,int ordinal) {
        this.armour = armour;
        this.ordinal = ordinal;
    } 

    public static void main(String[] args) {
        TestEnum[] testEnums = TestEnum.values();
        for (int i = 0; i < testEnums.length; i++) {
            System.out.println(testEnums[i]+" -> "+ testEnums[i].ordinal());
            //testEnums[i].ordinal()输出枚举对象的序号,默认从0开始
        }
    }
}

在这里插入图片描述

Enum枚举类没有values()方法,却可以在枚举类中使用,为什么?

示例二 :

在这里插入图片描述

package enumdemo;

public enum TestEnum {
    //枚举对象
    YANLONG("炎龙侠",0),
    FENGYING("风鹰侠",1),
    HEIXI("黑犀侠",2),
    XUEAO("雪獒侠",3);

    public String armour;
    public int ordinal;

    //枚举的构造方法默认是私有的
    private TestEnum() {

    } 

    private TestEnum(String armour,int ordinal) {
        this.armour = armour;
        this.ordinal = ordinal;
    }

    public static void main(String[] args) {
        TestEnum test = TestEnum.valueOf("YANLONG");
        System.out.println(test);
        System.out.println(YANLONG.compareTo(FENGYING));// 比较的是序号
    }
}

在这里插入图片描述

3.枚举优缺点

在这里插入图片描述

4.枚举和反射

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

我们刚刚在反射里面看到,任何一个类,哪怕其构造方法是私有的,我们也可以通过反射拿到他的实例对象,那么枚举的构造方法也是私有的,我们是否可以拿到呢?接下来,我们来实验一下:

package enumdemo;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Test {
    public static void main(String[] args) {
        Class<?> c = null;
        try {
            c = Class.forName("enumdemo.TestEnum");
            Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class);
            constructor.setAccessible(true);

            TestEnum testEnum = (TestEnum)constructor.newInstance("DIHU",23);
            System.out.println(testEnum);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}


在这里插入图片描述

异常信息是: java.lang.NoSuchMethodException: enumdemo.TestEnum.(java.lang.String, int) ,什么意思 , 就是没有对应的构造方法 . 我的天呐!我们提供的枚举的构造方法就是两个参数分别是String 和int啊 ? 问题出现在哪里呢 ?

我们所有的枚举类,都是默认继承于java.lang.Enum ,说到继承,继承了什么?继承了父类除构造函数外的所有东西,并且子类要帮助父类进行构造!而我们写的类,并没有帮助父类构造!那意思是,我们要在自己的枚举类里面,提供super吗?不是的,枚举比较特殊,虽然我们写的是两个,但是默认他还添加了两个参数,哪两个参数呢?我们看一下Enum类的源码:

在这里插入图片描述

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

package enumdemo;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Test {
    public static void main(String[] args) {
        Class<?> c = null;
        try {
            c = Class.forName("enumdemo.TestEnum");
            Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class,
                    String.class, int.class);
            constructor.setAccessible(true);

            TestEnum testEnum = (TestEnum)constructor.newInstance("DIHU",23);
            System.out.println(testEnum);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}


在这里插入图片描述

此时又又又报错了 ! 不过异常信息发生了变化 , 此时的异常信息显示,是我的一个方法newInstance() 报错了!没错,问题就是这里,我们来看一下这个方法的源码,为什么会抛出java.lang.IllegalArgumentException: 异常呢?

源码 :

在这里插入图片描述

引申问题 : 为什么枚举实现单例模式是安全的 ?

总结:

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

拓展 : 写一个单例模式 .

三 : Lambda表达式

1.背景

Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。

2.基本语法

在这里插入图片描述

3.函数式接口

要了解lambda表达式 , 就要知道什么是函数式接口 . 函数式接口定义:一个接口有且只有一个抽象方法 .

注意:

  1. 如果一个接口只有一个抽象方法,那么该接口就是一个函数式接口 ;
  2. 如果我们在某个接口上声明了 @FunctionalInterface 注解,那么编译器就会按照函数式接口的定义来要求该接口,这样如果有两个抽象方法,程序编译就会报错的 . 所以,从某种意义上来说,只要你保证你的接口中只有一个抽象方法,你可以不加这个注解 . 加上就会自动进行检测 .
@FunctionalInterface // 声明该接口为函数式接口,有且只有一个抽象方法
interface NoParameterNoReturn {
    void test();
}

4.Lambda表达式的基本使用

1.在使用比较器时 , 可以使用lambda表达式简化代码 .

    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
    }

使用lambda表示式简化后 :

    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue2 = new PriorityQueue<>(((o1, o2) -> o1-o2));
    }

2.演示有/无返回值 , 无参/一个参数/两个参数的Lambda表达式的用法 :

2.1无返回值

package lambdademo;
import java.util.Comparator;
import java.util.PriorityQueue;


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

public class Test {

    public static void main3(String[] args) {
        //NoParameterReturn noParameterReturn = ()-> {return 10;};
        NoParameterReturn noParameterReturn = ()->10;
        int ret = noParameterReturn.test();
        System.out.println(ret);

        OneParameterReturn oneParameterReturn = a -> a;
        ret = oneParameterReturn.test(99);
        System.out.println(ret);

        MoreParameterReturn moreParameterReturn = (a,b)->a+b;
        ret = moreParameterReturn.test(99,1);
        System.out.println(ret);
    }


    public static void main2(String[] args) {
    //1无参
       //1.1常规写法
       NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
            @Override
            public void test() {
                System.out.println("无参 + 不带返回值 常规写法");
            }
        };
        noParameterNoReturn.test();

        //1.2写法优化:使用lambda表达式
        NoParameterNoReturn noParameterNoReturn2 = () -> {
            System.out.println("无参 + 不带返回值 使用lambda表达式");
        };
        noParameterNoReturn2.test();

        //1.3写法优化:省略花括号
        NoParameterNoReturn noParameterNoReturn3 = () -> System.out.println("无参 + 不带返回值 使用lambda表达式 省略花括号");
        noParameterNoReturn3.test();

    //2.有1个参数 + 不带返回值
        //如果有1个参数 那么小括号可以省略  如果方法体只有一行代码 那么花括号可以省略
        OneParameterNoReturn oneParameterNoReturn = a -> System.out.println("有1个参数 + 不带返回值"+a);
        oneParameterNoReturn.test(10);

    //3.有2个参数 + 不带返回值
        MoreParameterNoReturn moreParameterNoReturn = (int a,int b) -> {System.out.println("有2个参数 + 不带返回值"+a+b);};
        moreParameterNoReturn.test(1,2);

        //参数类型如果都要省略 请同时省略
        MoreParameterNoReturn moreParameterNoReturn1 = (a,b) -> System.out.println("有2个参数 + 不带返回值 + 省略参数类型"+a+b);
        moreParameterNoReturn1.test(1,2);
    }

}

在这里插入图片描述

2.2有返回值

    public static void main(String[] args) {
        //有返回值,在->后填写返回值
        //NoParameterReturn noParameterReturn = ()-> {return 10;};
        NoParameterReturn noParameterReturn = ()->10;
        int ret = noParameterReturn.test();
        System.out.println("无参 " + ret);

        OneParameterReturn oneParameterReturn = a -> a;
        ret = oneParameterReturn.test(99);
        System.out.println("一个参数 " + ret);

        MoreParameterReturn moreParameterReturn = (a,b)->a+b;
        ret = moreParameterReturn.test(99,1);
        System.out.println("两个返回值 " + ret);
    }

在这里插入图片描述

5.变量捕获

5.1匿名内部类中的变量捕获

Lambda 表达式中存在变量捕获 . Java当中的匿名类中,会存在变量捕获 .

package InnerClass;
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函数当中,我们看到的就是一个匿名内部类的简单的使用 .

package InnerClass;
class Test {
    public void func() {
        System.out.println("func()");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        new Test(){
            @Override
            public void func() {
                System.out.println("我是内部类,且重写了func这个方法!");
                System.out.println("捕获了变量a = " + a);
            }
        };
    }
}

在上述代码当中的变量a就是捕获的变量 . 这个变量要么是被final修饰,如果不是被final修饰的 你要保证在使用之前,没有修改 .

在这里插入图片描述

在这里插入图片描述

5.2Lambda中的变量捕获

在这里插入图片描述
不能修改变量a的值 , 否则会报错 ; 建议将a变量使用final进行修饰 .

6.Lambda在集合中的应用

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

在这里插入图片描述

Collection接口的forEach() 方法演示 , 该方法在接口Iterable 当中,原型如下:

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

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

List接口的sort源码 :

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("yes");
        list.add("no");
        list.add("double");
        list.add("lambda");

        /*list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        list.forEach(str->System.out.println(str));
        System.out.println("排序:");

        /*list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });*/

        list.sort((o1,o2)->o1.compareTo(o2));

        list.forEach(str->System.out.println(str));

    }

在这里插入图片描述

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

使用Lambda表达式 :

    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "yes");
        map.put(2, "no");
        map.put(3, "hello");
        map.put(4, "lambda");
       /* map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer integer, String s) {
                System.out.println("key:"+integer+" val: "+s);
            }
        });
*/
        map.forEach((key,val)->System.out.println("key:"+key+" val: "+val));
    }

在这里插入图片描述

7.总结

在这里插入图片描述

本文到此结束 !

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/365674.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

k8s1.23.0+ubuntu20.04+docker23+hyperv

问题 k8s node节点加入到集群时卡住 “[preflight] Running pre-flight checks” # master节点重新生成加入命令 kubeadm token create --ttl 0 --print-join-command参考 注意 k8s1.24使用containerd而不再使用docker&#xff0c;因此使用k8s1.23版本 环境 k8s: 1.23.0 u…

【Python入门第十五天】Python字典

字典&#xff08;Dictionary&#xff09; 字典是一个无序、可变和有索引的集合。在 Python 中&#xff0c;字典用花括号编写&#xff0c;拥有键和值。 实例 创建并打印字典&#xff1a; thisdict {"brand": "Porsche","model": "911&q…

2023年湖北施工员怎么报考?甘建二告诉你

湖北施工员怎么报考&#xff1f;考施工员需要了解哪些知识呢&#xff1f;跟甘建二一起来看下 一、湖北施工员报名条件&#xff1a; 甘建二告诉你&#xff0c;施工员报名条件基本没有限制&#xff0c;年满18岁即可。个人名义都可以报考&#xff0c;限制不多&#xff0c;不是跟安…

20230223-EF6用原生的命令执行SQL命令

目录:一、环境说明二、背景三、示例代码四、思考总结一、环境说明本机环境&#xff1a;windows10 操作系统 使用工具&#xff1a;Visual Studio 2022 Net版本&#xff1a;Net6.0二、背景在使用winform EF 开发过程中&#xff0c;需要用到类似 QueryList QueryScalar 等功能的时…

MySQL中MVCC如何解决不可重复读以及幻读?

了解MVCC之前&#xff0c;我们首先需要了解以下两个概念&#xff1a;一致性非锁定读和锁定读&#xff0c;了解这两个概念之后我们在逐步分析MVCC。 一致性非锁定读和锁定读 一致性非锁定读(快照读) 对于 一致性非锁定读的实现&#xff0c;通常做法是加一个版本号或者时间戳字…

【12-JVM面试专题-垃圾回收器好坏评价的标准?吞吐量和响应时间?生产环境中,如何选择合适的垃圾收集器?如何判断是否使用G1垃圾收集器?】

垃圾回收器好坏评价的标准&#xff1f;吞吐量和响应时间&#xff1f;生产环境中&#xff0c;如何选择合适的垃圾收集器&#xff1f;如何判断是否使用G1垃圾收集器&#xff1f; 垃圾回收器好坏评价的标准&#xff1f;吞吐量和响应时间&#xff1f;生产环境中&#xff0c;如何选择…

python基于vue戒烟网站

可定制框架:ssm/Springboot/vue/python/PHP/小程序/安卓均可开发目录 开发语言&#xff1a;Python python框架&#xff1a;django/flask 软件版本&#xff1a;python 数据库&#xff1a;mysql 数据库工具&#xff1a;Navicat11 开发软件&#xff1a;PyCharmscode 项目介…

Java常用算法

关于时间复杂度&#xff1a; 平方阶 (O(n2)) 排序 各类简单排序&#xff1a;直接插入、直接选择和冒泡排序。线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序。O(n1)) 排序&#xff0c; 是介于 0 和 1 之间的常数。希尔排序。线性阶 (O(n)) 排序 基数排序&#xff0c…

技能提升:Python技术应用工程师职业技能提升

职业技术培训-Python技术应用工程师分为高级培训班、中级培训班及初级培训班。 Python是一种跨平台的计算机程序设计语言&#xff0c;是一个高层次的结合了解释性、编译性、互动性和面向对象的语言。最初被设计用于编写自动化脚本Shell&#xff08;适用于Linux操作系统&#xf…

2-并发篇

线程有哪些状态 java的线程状态有6种&#xff1a; 操作系统中有5状态的说明 注意java的runnable对应了就绪、运行、阻塞I/O 线程池的核心参数 主要是说线程池的一个实习类 threadPoolExecutor.class 1.corePoolSize 核心线程数据&#xff08;可以为0&#xff09; 最多保…

第一章:网络参考模型

一、专业术语 ISO---&#xff08;International Organization for Standardization&#xff09;国际标准化组织 OSI---&#xff08;Open System Interconnection Reference Model&#xff09;开放式系统互联通信参考模型 IEEE---(Institute of Electrical and Electronics Engi…

数字经济赋能乡村建设,助力乡村全面振兴

我国农村正朝着全面振兴的方向迈步发展&#xff0c;与此同时&#xff0c;我国高速发展的数字经济正在成为驱动经济社会全方位高质量发展的重要引擎&#xff0c;数字经济赋能乡村建设是乡村振兴的重要战略方向。数字经济通过将数据要素纳入农业生产、将数字产品和服务融入农民生…

3年经验,3轮技术面+1轮HR面,拿下字节30k*16薪offer,这些自动化测试面试题值得大家借鉴

面试一般分为技术面和hr面&#xff0c;形式的话很少有群面&#xff0c;少部分企业可能会有一个交叉面&#xff0c;不过总的来说&#xff0c;技术面基本就是考察你的专业技术水平的&#xff0c;hr面的话主要是看这个人的综合素质以及家庭情况符不符合公司要求&#xff0c;一般来…

K8s调度器Scheduler

当创建k8s pod的时候调度器会决定pod在哪个node上被创建且运行&#xff0c;调度器给apiserver发出了一个创建pod的api请求&#xff0c;apiserver首先将pod的基本信息保存在etcd&#xff0c;apiserver又会把这些信息给到每个node上的kubelet进程&#xff0c;kubelet一直在监听这…

Arduino UNO驱动土壤湿度传感器检测

Arduino UNO驱动土壤湿度传感器检测简介运行要求Arduino UNO与传感器接线程序展示实践效果总结简介 本次使用到是这个新款土壤湿度传感器&#xff01; 这款电容式土壤湿度传感器区别于市面上绝大部分的电阻式传感器&#xff0c;采用电容感应原理来检测土壤湿度。避免了电阻式传…

电子技术——系统性分析反馈电压放大器

电子技术——系统性分析反馈电压放大器 在本节我们提供一个系统性的分析反馈电压放大器的方法。首先我们考虑反馈网络没有负载效应理想情况&#xff0c;其次我们考虑反馈网络有限阻抗下的非理想情况。总之&#xff0c;这种方法的思路在于&#xff0c;将非理想情况转换为理想情况…

CVE-2022-22947 SpringCloud GateWay SPEL RCE 漏洞分析

漏洞概要 Spring Cloud Gateway 是Spring Cloud 生态中的API网关&#xff0c;包含限流、过滤等API治理功能。 Spring官方在2022年3月1日发布新版本修复了Spring Cloud Gateway中的一处代码注入漏洞。当actuator端点开启或暴露时&#xff0c;可以通过http请求修改路由&#xff…

Linux 平台 RTSP server项目开发总结

先看下效果 Demo版本限制了只支持两个通道 每个通道只能连接一个客户端 FULL版本 没有这个限制 需要全功能版本 请联系博主 so库和测试demo可以点击这里下载 功能说明如下&#xff1a; 视频支持H264/H265音频支持AAC只支持LIVE 不支持文件点播支持TCP/UDP不支持RTCP支持多用…

Unity之ASE实现“软溶解”

前言 软溶解是相对之前将的硬边溶解来说的&#xff0c;软溶解顾名思义&#xff0c;就是溶解的边缘会比较平滑柔和&#xff0c;不像硬边溶解那样溶解边缘是清晰的。所以在游戏中也常被人所使用。效果请看下图&#xff1a; 硬边溶解原理 我们还记得之前讲应变溶解时的节点吗&…

如何快速一次性通过pmp考试?

我们就从三个方向进行了解 1.PMP考试难不难&#xff1f; 2.PMP如何备考&#xff1f; 3.考试过程中需要注意什么&#xff1f; 一&#xff0c;PMP考试难不难&#xff1f; 首先关注的问题是&#xff0c;PMP考试难吗&#xff1f;我想全球55%的通过率和学会这边93.9%的通过率&a…