Java篇（四）

已于 2023-08-31 22:29:55 修改
阅读量55 收藏
点赞数 1
分类专栏： JAVA及相关基础 文章标签： java 开发语言
于 2023-07-27 22:26:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45913657/article/details/131969733
版权

1、Java8的新特性有哪些？

Java 8是Java语言的一个重要版本，引入了许多新特性和改进。以下是Java 8中的一些主要新特性：

  1. Lambda表达式：Lambda表达式是一种新的函数式编程方式，可以简化代码，使得Java可以更加灵活地支持函数式编程风格。

  2. 函数式接口：Java 8引入了函数式接口的概念，即只包含一个抽象方法的接口，可以使用@FunctionalInterface注解来声明函数式接口。

  3. Stream API：Stream API是一种处理集合数据的新方式，可以使用函数式风格对集合进行过滤、映射、排序等操作。

  4. 新的日期和时间API：Java 8引入了新的日期和时间API，解决了旧的Date和Calendar类的诸多问题，使日期和时间的处理更加简单和安全。

  5. 接口的默认方法和静态方法：Java 8允许在接口中定义默认方法和静态方法，使得接口可以包含具体的方法实现。

  6. Optional类：Optional类是一种容器类，用于处理可能为空的值，可以有效避免NullPointerException。

  7. 方法引用：方法引用是一种更简洁的Lambda表达式的写法，可以直接引用已有的方法。

  8. 重复注解：Java 8允许在同一个地方多次使用相同的注解，通过@Repeatable注解来实现。

  9. CompletableFuture：CompletableFuture是一种支持异步编程的新API，可以更方便地处理异步任务和回调。

  10. 新的并发API：Java 8引入了一系列新的并发API，如StampedLock、LongAdder等，提供更高效和更易用的并发编程方式。

这些新特性使得Java 8成为了一个更加现代化和功能强大的版本，为Java语言带来了更多的可能性和便利性。

2、序列化和反序列化

序列化（Serialization）和反序列化（Deserialization）是将对象转换为字节流或从字节流恢复对象的过程，用于在网络传输或持久化存储对象数据。

  1. 序列化：

    • 序列化是将对象转换为字节流的过程，可以将对象保存到文件中或通过网络传输。
    • 在Java中，对象的序列化通过实现Serializable接口来完成。该接口是一个标记接口，没有任何方法，只是用于标识类是可序列化的。
    • 当一个类实现了Serializable接口后，对象的状态信息（即成员变量的值）可以被转换为字节流，可以使用ObjectOutputStream类将对象写入输出流中。

  2. 反序列化：

    • 反序列化是将字节流恢复为对象的过程，可以从文件或网络中读取字节流，并还原为原始的Java对象。
    • 在Java中，反序列化通过ObjectInputStream类来实现，它可以从输入流中读取字节流并将其还原为原始对象。
    • 反序列化的过程需要确保字节流的格式与序列化时的格式保持一致，否则会抛出InvalidClassException等异常。

示例代码如下：

import java.io.*;

class Person implements Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 省略getter和setter

    public static void main(String[] args) {
        Person person = new Person("Alice", 30);

        // 序列化
        try {
            FileOutputStream fos = new FileOutputStream("person.ser");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(person);
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化
        try {
            FileInputStream fis = new FileInputStream("person.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Person restoredPerson = (Person) ois.readObject();
            ois.close();
            System.out.println(restoredPerson.getName()); // 输出：Alice
            System.out.println(restoredPerson.getAge());  // 输出：30
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

总结： 序列化和反序列化是将Java对象转换为字节流和将字节流恢复为Java对象的过程，用于对象的持久化存储和网络传输。在Java中，对象需要实现Serializable接口才能被序列化和反序列化。

3、什么时候需要用到序列化和反序列化呢?

序列化和反序列化通常在以下场景中需要使用：

  1. 持久化存储：将对象的状态保存到文件系统或数据库中，以便在程序重启后能够恢复对象的状态。

  2. 网络传输：在分布式系统中，需要将对象通过网络传输到其他节点或进程，以便在不同的机器之间共享数据。

  3. 缓存：在缓存中存储对象时，为了避免频繁地从数据库读取数据，可以将对象序列化后存储在缓存中，从缓存中读取时再进行反序列化。

  4. 远程调用：在远程调用过程中，可以将参数和返回值序列化后传输，以便在不同的进程或机器之间进行通信。

  5. 消息传递：在消息队列中，消息通常需要进行序列化后发送给消费者进行处理。

  6. 分布式计算：在分布式计算中，可以将任务和数据进行序列化后传输到不同的节点上进行并行计算。

需要注意的是，当涉及到序列化和反序列化时，应该保证序列化的类是稳定的，即类的结构在序列化和反序列化的过程中不能发生变化。否则，可能会导致反序列化失败或得到不正确的结果。为了确保稳定性，建议在类中添加一个serialVersionUID字段，用于指定序列化版本号，当类的结构发生变化时，可以通过修改serialVersionUID来实现版本兼容性。

4、实现序列化和反序列化为什么要实现 Serializable 接口?

实现序列化和反序列化时需要实现Serializable接口是因为Java中的序列化和反序列化机制是基于对象的二进制形式进行的，而Serializable接口是一个标记接口（Marker Interface），用于标识类的实例可以进行序列化和反序列化。

当一个类实现了Serializable接口时，Java的序列化机制就会对该类的实例进行特殊处理，将对象的状态信息转换为字节流进行持久化存储或传输。具体来说，实现Serializable接口告诉Java编译器该类的实例可以被序列化，并且在进行序列化时需要按照一定的规则将对象的成员变量转换为字节流，以便后续可以通过反序列化将字节流恢复为原始对象。

如果一个类没有实现Serializable接口，那么在进行序列化时会抛出java.io.NotSerializableException异常，表示该类的实例不能被序列化。

需要注意的是，Serializable接口是一个空接口，它没有任何方法需要实现，只需要简单地将该接口添加到类的声明中即可。示例代码如下：

import java.io.Serializable;

class Person implements Serializable {
    // 类的成员变量和方法

    // 省略getter和setter
}

总结： 实现Serializable接口是Java中进行序列化和反序列化的前提条件，它标记了类的实例可以被序列化，告诉Java编译器如何对对象进行序列化和反序列化操作。

5、实现 Serializable 接口之后，为什么还要显示指定 serialVersionUID 的值?

在实现Serializable接口后，为什么还要显示指定serialVersionUID的值是为了确保序列化和反序列化的兼容性。

serialVersionUID是一个静态常量，用于标识序列化类的版本号。在进行反序列化时，Java虚拟机会使用serialVersionUID来检查序列化类的版本与当前类的版本是否一致。如果serialVersionUID的值没有指定，Java虚拟机会根据类的结构自动生成一个版本号。

指定serialVersionUID的好处在于，即使类的结构发生了变化（例如添加、删除或修改成员变量或方法），只要serialVersionUID的值保持不变，就可以确保在进行反序列化时仍然能够成功恢复原始对象。这样可以保持序列化和反序列化的兼容性，防止因类的结构变化导致反序列化失败或得到错误的结果。

如果在类的结构发生变化后没有指定serialVersionUID，那么反序列化时可能会出现以下问题：

  • 如果类的结构发生了变化，但serialVersionUID没有变化，那么在反序列化时会忽略类的结构变化，导致得到不正确的对象。
  • 如果类的结构发生了变化，且serialVersionUID发生了变化，那么在反序列化时会因为版本不一致而导致反序列化失败。

为了保证类的版本兼容性，建议在类中显示指定serialVersionUID，并且在类的结构发生变化时及时更新serialVersionUID的值，以确保序列化和反序列化的正确性。通常，可以使用默认的serialVersionUID生成方式，也可以根据具体需求手动指定一个固定的值。示例代码如下：

import java.io.Serializable;

class Person implements Serializable {
    private static final long serialVersionUID = 123456789L;
    // 类的成员变量和方法

    // 省略getter和setter
}

总结： 指定serialVersionUID是为了确保序列化和反序列化的兼容性，在类的结构发生变化时可以保持serialVersionUID的一致性，以防止反序列化失败或得到错误的结果。建议在实现Serializable接口后显示指定serialVersionUID的值。

6、static 属性为什么不会被序列化?

在Java中，static属性不会被序列化，主要是因为static属性属于类级别的属性，而不是实例级别的属性。

序列化是将对象的状态信息转换为字节流进行持久化存储或传输，而static属性是属于类的，对于所有对象实例来说是共享的，因此不包含在对象的状态信息中。

具体原因如下：

  1. static属性属于类级别的，不属于对象实例，因此不与任何特定的对象绑定。序列化是针对对象实例的，只会将实例的状态信息进行序列化，而不会包含类的静态信息。
  2. 序列化的目的是为了将对象的状态信息保存下来，以便在反序列化时能够恢复对象的状态。而静态属性不会改变，不属于对象的状态，没有必要被序列化和保存。

由于static属性不会被序列化，反序列化后，对象的static属性会保持原来的值，而不会受到序列化的影响。如果需要在反序列化后更新static属性，可以在类中添加一个静态方法，用于在反序列化后更新静态属性的值。

示例代码如下：

import java.io.Serializable;

class Person implements Serializable {
    private static final long serialVersionUID = 123456789L;
    private String name;
    private int age;
    private static int count = 0; // 静态属性

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        count++; // 对象实例创建时，更新静态属性
    }

    public static int getCount() {
        return count;
    }

    // 省略getter和setter
}

总结： static属性不会被序列化，因为它属于类级别的属性，不属于对象实例的状态信息。静态属性在反序列化时保持原来的值，不受序列化和反序列化的影响。如果需要在反序列化后更新静态属性，可以通过静态方法来实现。

7、transient关键字的作用？

在Java中，transient是一个关键字，用于修饰成员变量。当一个成员变量被声明为transient时，它表示该成员变量不会被序列化，即在对象进行序列化时，该成员变量的值不会被保存到字节流中。

transient关键字通常用于修饰一些敏感或临时的数据，这些数据不需要被持久化存储或传输。例如，如果一个类中有一个缓存的数据结构，而该数据结构不需要被序列化，可以将该数据结构声明为transient。

需要注意的是，被transient修饰的成员变量在进行序列化时，会被赋予默认值，而不是原来的值。对于基本数据类型，transient成员变量被序列化后会被赋值为其对应的默认值（如0、0.0、false等），对于引用类型，transient成员变量会被赋值为null。

示例代码如下：

import java.io.Serializable;

class Person implements Serializable {
    private String name;
    private transient int age; // 使用transient修饰的成员变量

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 省略getter和setter
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);

        // 序列化
        try {
            FileOutputStream fos = new FileOutputStream("person.ser");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(person);
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化
        try {
            FileInputStream fis = new FileInputStream("person.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Person restoredPerson = (Person) ois.readObject();
            ois.close();
            System.out.println(restoredPerson.getName()); // 输出：Alice
            System.out.println(restoredPerson.getAge());  // 输出：0，默认值
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

总结： transient关键字用于修饰成员变量，表示该成员变量不会被序列化。被transient修饰的成员变量在进行序列化时会被赋予默认值，而不是原来的值。transient通常用于修饰敏感或临时数据，不需要被持久化存储或传输。

8、什么是反射？

反射（Reflection）是Java语言的一种特性，它允许程序在运行时动态地获取类的信息（如类的属性、方法、构造函数等），并可以在运行时调用类的方法、创建对象等。反射使得程序可以在运行时操作类和对象，而不需要在编译时就确定类的信息。

在Java中，反射是通过java.lang.reflect包提供的一组类和接口来实现的。主要涉及的类和接口包括Class类、Field类、Method类、Constructor类等。

反射的主要功能包括：

  1. 获取类的信息：可以获取类的属性、方法、构造函数等信息。
  2. 创建对象：可以通过反射在运行时动态创建对象，而不需要在编译时确定对象的类型。
  3. 调用方法：可以通过反射在运行时调用类的方法。
  4. 修改属性：可以通过反射在运行时修改类的属性值。

反射虽然提供了灵活性和动态性，但也增加了程序的复杂性和性能开销。因此，在正常情况下，应该尽量避免过度使用反射，而优先选择静态绑定的方式（即在编译时就确定类和方法的调用关系）。只有在某些特殊的场景下，如框架开发、动态代理、ORM（对象关系映射）等需要在运行时动态地操作类和对象时，才需要使用反射。

示例代码：

import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) {
        // 获取类的信息
        Class<?> clazz = String.class;
        System.out.println("类名称：" + clazz.getName());
        System.out.println("是否为接口：" + clazz.isInterface());
        System.out.println("是否为数组：" + clazz.isArray());
        System.out.println("是否为基本数据类型：" + clazz.isPrimitive());

        // 创建对象
        try {
            Object obj = clazz.newInstance();
            System.out.println("创建的对象：" + obj);
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }

        // 调用方法
        try {
            Method method = clazz.getMethod("length");
            Object result = method.invoke("Hello");
            System.out.println("调用方法的结果：" + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出结果：

类名称：java.lang.String
是否为接口：false
是否为数组：false
是否为基本数据类型：false
创建的对象：java.lang.String@7a81197d
调用方法的结果：5

总结： 反射是Java语言的一种特性，允许程序在运行时动态地获取类的信息，并在运行时操作类和对象。反射提供了灵活性和动态性，但也增加了程序的复杂性和性能开销，因此应该谨慎使用。

9、反射有哪些应用场景呢？

反射在Java中有许多应用场景，它提供了灵活性和动态性，使得程序可以在运行时动态地获取类的信息和操作类和对象。以下是反射常见的应用场景：

  1. 框架开发：许多Java框架（如Spring、Hibernate等）都使用反射来实现依赖注入、对象创建和配置等功能，从而实现框架的灵活性和可扩展性。

  2. 动态代理：反射可以用于动态创建代理对象，实现AOP（面向切面编程）等功能。

  3. ORM（对象关系映射）：ORM框架（如Hibernate）可以通过反射来将Java对象映射到数据库表，并实现对象与数据库之间的转换。

  4. 序列化和反序列化：Java中的序列化和反序列化机制是通过反射来实现的，将对象的状态信息转换为字节流进行持久化存储或传输。

  5. 单元测试：在单元测试中，可以使用反射来访问私有方法、修改私有字段的值，以便进行测试。

  6. 动态加载类：在某些情况下，程序需要根据配置或用户输入动态地加载类，反射可以帮助实现这一功能。

  7. Java反射API的学习和研究：反射是Java语言的一个重要特性，通过学习反射API可以更好地理解Java语言的底层机制和运行原理。

需要注意的是，虽然反射提供了灵活性和动态性，但也增加了程序的复杂性和性能开销。因此，在正常情况下，应该尽量避免过度使用反射，而优先选择静态绑定的方式（即在编译时就确定类和方法的调用关系）。只有在特定的场景下，如框架开发、动态代理、ORM等需要在运行时动态地操作类和对象时，才需要使用反射。

10、讲讲什么是泛型？

泛型（Generics）是Java语言的一个特性，它允许在定义类、接口和方法时使用类型参数，从而实现代码的通用性和类型安全性。通过使用泛型，可以在编译时指定类、接口或方法的类型参数，从而使其能够适用于不同类型的数据，而无需在运行时进行类型转换。

泛型的主要目的是为了解决类型安全性问题。在没有泛型的情况下，当我们从集合中获取元素时，需要进行类型转换，并且容易出现类型转换错误，导致程序在运行时出现异常。而使用泛型后，可以在编译时就进行类型检查，确保只能存储指定类型的数据，从而提高程序的稳定性和安全性。

泛型的语法格式如下：

class ClassName<T> {
    // 类的定义，可以使用类型参数T
}

interface InterfaceName<T> {
    // 接口的定义，可以使用类型参数T
}

class GenericClass<T> {
    T variable; // 使用泛型类型参数T定义成员变量

    T genericMethod(T parameter) { // 使用泛型类型参数T定义方法参数和返回值
        return parameter;
    }
}

泛型类、泛型接口和泛型方法可以使用不同的类型参数，可以是具体的类、接口或抽象类，也可以是泛型类型。

使用泛型的好处：

  1. 提高代码的通用性：使用泛型可以编写通用的代码，使其适用于不同类型的数据，提高代码的复用性和灵活性。
  2. 类型安全：通过使用泛型，在编译时就能够发现类型错误，减少在运行时出现类型转换错误的可能性。
  3. 简化代码：使用泛型可以减少类型转换的代码，使代码更加简洁和清晰。

示例代码：

class Box<T> {
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

public class Main {
    public static void main(String[] args) {
        Box<Integer> intBox = new Box<>();
        intBox.setData(10);
        int data = intBox.getData(); // 不需要进行类型转换

        Box<String> strBox = new Box<>();
        strBox.setData("Hello");
        String strData = strBox.getData(); // 不需要进行类型转换
    }
}

总结： 泛型是Java语言的一个特性，它允许在定义类、接口和方法时使用类型参数，从而实现代码的通用性和类型安全性。使用泛型可以提高代码的通用性和可读性，避免类型转换错误，使代码更加简洁和清晰。泛型是Java中重要的编程工具，广泛应用于集合类、框架开发和泛型算法等领域。

11、如何停止一个正在运行的线程？

在Java中，停止一个正在运行的线程有多种方法，但要注意线程停止的安全性和可靠性，避免造成线程资源泄漏或不稳定的问题。以下是常见的停止线程的方法：

  1. 使用标志位：可以在线程的run方法中通过检查一个标志位来决定是否停止线程。在外部需要停止线程时，设置标志位为true，线程在执行过程中检测到标志位为true时，自行终止执行。
class MyThread extends Thread {
    private volatile boolean running = true;

    public void stopRunning() {
        running = false;
    }

    @Override
    public void run() {
        while (running) {
            // 线程执行的代码
        }
    }
}

// 停止线程
MyThread thread = new MyThread();
thread.start();
// 执行一段时间后停止线程
thread.stopRunning();
  1. 使用interrupt方法：调用线程的interrupt方法会给线程设置中断标志，并触发一个中断异常（InterruptedException）。在线程的run方法中，可以使用Thread.currentThread().isInterrupted()来判断线程是否被中断，并作出相应的处理。
class MyThread extends Thread {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            // 线程执行的代码
        }
    }
}

// 停止线程
MyThread thread = new MyThread();
thread.start();
// 执行一段时间后停止线程
thread.interrupt();
  1. 使用stop方法（不推荐）：Thread类提供了stop方法用于停止线程，但不推荐使用此方法。因为stop方法会直接终止线程的执行，并可能导致线程资源泄漏或其他问题，不利于线程的优雅退出。

停止线程时，要注意线程资源的释放和清理工作，确保线程安全地退出。推荐使用标志位或interrupt方法来停止线程，因为这两种方式更安全和可靠。如果线程涉及到I/O操作或阻塞调用，使用interrupt方法可以使线程从阻塞状态中返回，并处理中断异常。

总结： 停止一个正在运行的线程需要考虑线程的安全性和可靠性，避免造成线程资源泄漏或不稳定的问题。推荐使用标志位或interrupt方法来停止线程，避免使用stop方法。同时，在线程的run方法中需要检查中断标志和标志位，并做出相应的处理，确保线程安全地退出。

12、什么是跨域？

跨域（Cross-Origin）指的是在浏览器中，当前正在访问的页面的域名、协议或端口与请求资源所在的域名、协议或端口不一致的情况。简单来说，如果网页中的 JavaScript 发起一个 HTTP 请求，而该请求的目标资源位于不同的域名、协议或端口，就会触发跨域问题。

跨域问题是由浏览器的同源策略（Same-Origin Policy）导致的。同源策略是一种安全机制，限制了一个网页上的文档或脚本如何与另一个源（域名、协议、端口）的资源进行交互。同源策略要求两个页面的协议、主机和端口号完全相同，才允许进行跨域操作。

跨域问题主要涉及以下几种情况：

  1. 不同域名之间的跨域请求。
  2. 不同子域之间的跨域请求。
  3. 不同端口之间的跨域请求。
  4. 不同协议之间的跨域请求。

跨域问题的存在是为了保护用户的信息和数据安全，防止恶意网站利用浏览器从其他网站获取敏感信息。然而，在某些情况下，确实需要进行跨域操作，例如前后端分离的应用、资源共享等。

需要注意的是，跨域问题只存在于浏览器环境中，在服务器之间的直接请求不受同源策略限制。因此，在服务器端进行数据请求或通信时，不会遇到跨域问题。

13、跨域问题怎么解决呢？

跨域问题可以通过以下几种方式来解决：

  1. JSONP（JSON with Padding）：JSONP是一种利用<script>标签的跨域技术。在跨域请求时，通过在请求URL中携带回调函数的名称，服务器返回一段JavaScript代码，并执行该代码，从而实现跨域数据的获取。JSONP只适用于GET请求，且需要服务器端支持。

  2. CORS（Cross-Origin Resource Sharing）：CORS是一种跨域资源共享的标准，通过在服务器端设置特定的响应头来允许跨域请求。服务器端在响应中添加Access-Control-Allow-Origin头，指定允许跨域的域名或通配符*，从而使得浏览器可以安全地处理跨域请求。

  3. 代理服务器：在同一域名下设置一个代理服务器，将跨域请求转发到目标域名，然后将响应返回给浏览器。这样浏览器不会触发跨域问题，因为请求和响应都是在同一域名下进行的。

  4. WebSocket：WebSocket是一种双向通信协议，它可以在浏览器和服务器之间建立持久性的连接，从而实现实时通信。WebSocket不受同源策略的限制，因此可以用于解决跨域通信的问题。

  5. 服务器端设置代理：如果是同一域名下的不同子域或端口之间的跨域请求，可以在服务器端进行配置，使得请求被转发到目标资源的正确地址，从而实现跨域访问。

需要根据具体的跨域场景选择合适的解决方案。在使用CORS解决跨域问题时，还需要注意设置适当的响应头，确保服务器端对跨域请求进行了正确的处理。同时，对于一些老旧的浏览器，不支持CORS，需要考虑使用其他跨域解决方案。总之，跨域问题的解决方法多种多样，开发者需要根据实际情况选择最合适的方式来解决跨域问题。

大大应届生
关注
专栏目录
Java实习周报通用25篇
03-07
【Java实习周报通用25篇】记录了一个实习生在五个礼拜内的学习和成长历程，涵盖了从适应新环境、熟悉基础语法到深入理解高级概念的过程。 第一周，实习生主要适应了公司环境，意识到实习不仅仅是学习新知识，而是...
java开发实习周记12篇.doc
11-23
"java开发实习周记12篇" java开发实习周记12篇是关于java开发实习的周记文章，共有12篇文章，从实习第一周到实习第十二周，每篇文章都记录了实习生的实习经历和java开发知识点。下面是每篇文章的知识点总结： 实习...
java基础学习第四章
04-09
循环结构 循环语句顾名思义就是当满足循环条件的情况下，反复执行某一段代码，这段被 重复执行的代码被称为循环体语句，当反复把循环判断执行这个循环体时，需要 在合适的时条件修改为 false，从而结束循环，否则...
java offer来了原理篇.pdf
05-09
原理篇》是一本针对Java程序员的技术面试用书，它详尽地总结了Java面试中常见的核心技术知识点，包括但不限于JVM原理、多线程编程、数据结构与算法、分布式系统设计等。在IT行业求职竞争激烈的背景下，本书为读者...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 466
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 963
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 1002
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 1034
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
spring循环依赖解决方式
qq_36400213的博客
11-04 547
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 339
默认对常规Session的理解和使用，如何使用Set-Cookie。
Android 13 解决 Settings 首页矢量图修改颜色不生效
人生只是一种体验，不必用来演绎完美。
10-30 337
从Android 12 开始, 推出了Material You 设计，并在 Android 13 中得到了改进。导致了修改svg颜色不生效的问题。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 190
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
JavaScript的第十一天
全栈学习ing
10-31 756
在使用offset系列时需注意该属性为css属性，一般用于和javascript结合使用来获取信息，所以在使用该属性时只能获取值而不能改变值。最近的具有定位属性的祖先元素顶部边缘左侧边缘。
Java学习Day54：初遇萍萍(权限控制)
weixin_51721783的博客
10-29 1294
web.xml：在health_backend工程的web.xml文件中配置用于整合Spring Security框架的过滤器DelegatingFilterProxy。
Java爬虫的京东“寻宝记”：揭秘商品类目信息
2401_87849308的博客
10-30 932
在这个数据驱动的时代，我们就像一群特工，穿梭在数字的海洋中，寻找着隐藏的宝藏——商品类目信息。今天，我们将带领你一起，用Java这把精密的瑞士军刀，深入京东的神秘领域，揭开商品类目的神秘面纱。为了避免被京东的反爬虫机制发现，我们需要设置合理的请求间隔，并且可能需要模拟浏览器的User-Agent。经过一系列的特工任务和挑战，我们终于成功获取了商品的类目信息，并且安全返回。我们需要找到京东商品类目信息的API接口，这将是我们特工任务的起点。在代码的世界里，我们不仅要追求技术的高度，更要追求道德的底线。
Qt自定义控件：汽车速度表
weixin_44788175的博客
11-02 284
从外到内进行绘制，初始化画布，画渐变色外圈，画刻度，写刻度文字，画指针，画扇形，画内圈渐变色，画黑色内圈，写当前值。这里难点使用正弦和余弦计算绘制刻度字。
JAVA学习-练习试用Java实现“数组排序”
weixin_69763181的博客
11-03 211
这个程序首先导入了'java.util.Arrays'和'java.util.Scanner'，然后定义了一个'main'方法。程序使用'Scanner'类来读取用户的输入，并将其分割成一个字符串数组。然后，它将字符串数组转换成整数数组，并使用'Arrays.sort'方法对整数数组进行排序。以下是一个Java程序，它使用内置的'Arrays.sort'方法对用户输入的整数数组进行排序。编写一个Java程序，对用户输入的整数数组进行排序（可以使用内置的Arrays.sort方法，也可以自己实现排序算法）。
Spring学习笔记_16——@Inject
LuckyLay的博客
10-30 1037
Inject注解是JSR330规范中提供的注解，在@Inject注解中不提供任何属性，可以配合@Qualifier注解使用。存在多个类型相同的Bean时，通过@Qualifier注解可以明确指定注入哪个Bean。兼容性@Inject是标准的一部分，因此更通用，可以在多种环境中使用。@Resource主要用于Java EE环境。@Autowired仅适用于Spring框架。查找策略@Inject默认按类型查找。@Resource默认按名称查找，没有找到时再按类型查找。@Autowired。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值