小石潭记丶
小石潭记丶

Java知识总结（持续更新）

一、JDK、JRE、JVM三者之间的关系？

1. **JDK (Java Development Kit)**：
   JDK 是 Java 开发工具包，它包含了用于开发 Java 应用程序的所有必要工具和库。这包括 Java 编译器（javac）、Java 核心类库、开发工具（如调试器和监视器工具）以及其他一些实用工具。如果您希望编写、编译和运行 Java 程序，您需要安装 JDK。
2. **JRE (Java Runtime Environment)**：
   JRE 是 Java 运行时环境，它包括 Java 虚拟机（JVM）和 Java 核心类库。JRE 的主要作用是使您能够运行已经编译好的 Java 应用程序。如果您只想运行 Java 应用程序而不进行开发，那么安装 JRE 就足够了。
3. **JVM (Java Virtual Machine)**：
   JVM 是 Java 虚拟机，它是 Java 应用程序的运行环境。JVM 负责将 Java 字节码翻译成特定计算机架构的机器代码，并执行 Java 程序。每个 Java 应用程序在 JVM 中运行，它提供了跨平台的能力，使得相同的 Java 应用程序可以在不同操作系统上运行。
        简而言之，JDK 包含了开发 Java 应用程序所需的工具，JRE 包含了运行 Java 应用程序所需的环境，而 JVM 是 Java 应用程序的执行引擎。这三者之间的关系是 JDK 包含 JRE，而 JRE 包含 JVM。

Java知识总结（持续更新）_第1张图片

 二、Java中创建对象的几种方式？

1. **使用 `new` 关键字**：
   这是最常见的创建对象的方式。使用new关键字后跟构造函数来创建一个新的对象实例。例如：

 MyClass obj = new MyClass();

2. **使用工厂方法**：
   某些类提供了静态工厂方法，用于创建对象。这种方法可以隐藏对象的创建细节。例如：

 Calendar cal = Calendar.getInstance(); // 使用工厂方法创建 Calendar 对象

3. **使用反射**：
   Java 反射允许在运行时动态地创建对象，即使您不知道对象的确切类型。您可以使用 `Class` 类的 `newInstance` 方法来创建对象。但请注意，反射可能会导致性能下降和安全性问题，因此应谨慎使用。

Class myClass = Class.forName("com.example.MyClass");
   Object obj = myClass.newInstance();

4. **使用克隆**：
   如果一个类实现了 `Cloneable` 接口，您可以使用 `clone` 方法创建对象的副本。这被称为浅拷贝，因为它只复制对象的字段，而不会复制字段引用的对象。

 MyClass originalObj = new MyClass();
   MyClass clonedObj = (MyClass) originalObj.clone();

5. **使用序列化和反序列化**：
   您可以通过将对象序列化为字节流，然后反序列化来创建对象的副本。这种方法允许在不同的 Java 虚拟机之间传输对象，或者将对象保存到文件中并从文件中还原。

// 序列化对象
   ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.ser"));
   oos.writeObject(originalObj);
   oos.close();

   // 反序列化对象
   ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.ser"));
   MyClass newObj = (MyClass) ois.readObject();
   ois.close();

三、 final、finally、finalize的区别

1. **final**关键字：用于修饰类、方法、变量、入参和对象

  •  应用于类时，表示该类是最终类，不能被其他类继承。
  •  应用于方法时，表示该方法时最终方法，不能被其他类继承。
  •  应用于变量时，表示该变量时一个常量，只能赋值一次。
  •  应用于入参时，表示该入参在方法内无法被修改。
  •  应用于对象时，该对象的引用不能被修改，但对象本身的状态是可以改变的。

   示例：

final class FinalClass {
       // ...
   }
   
   class SubClass extends FinalClass { // 这是非法的，无法继承 final 类
       // ...
   }
   
   public void exampleMethod(final int value) {
       // value 是一个常量，不能在方法内部修改
   }

2. **finally**关键字：异常处理机制中的一部分，用于定义在try-catch-finally块中的finally块
   - 无论是否发生异常，`finally` 块中的代码都会被执行，通常用于释放资源或执行清理操作。

   示例：

 try {
       // 可能会引发异常的代码
   } catch (Exception e) {
       // 处理异常
   } finally {
       // 无论是否发生异常，都会执行这里的代码
       // 通常用于关闭文件、释放资源等操作
   }

3. **finalize**：是一个方法，它是 `java.lang.Object` 类中定义的一个方法。

  • 在垃圾回收器将对象回首之前调用。
  • 可以重写finalize方法，在其中编写对象在被回收钱需要进行的清理操作，如释放资源等。
  • 请注意，不推荐使用finalize方法进行内存资源的释放，它没有被及时执行的保证，也可能导致性能问题。

Java知识总结（持续更新）_第2张图片

总结：
- `final` 用于声明不可变的类、方法或变量。
- `finally` 用于与异常处理 (`try-catch`) 结构一起，确保代码块中的代码无论是否发生异常都会被执行。
- `finalize` 是一个过时的方法，用于在垃圾回收前执行对象的清理操作，不建议使用，现代 Java 有更好的垃圾回收方式。

 四、==和equals的区别？

在 Java 中，`==` 和 `equals` 是两个用于比较对象的操作符，它们具有不同的作用和用途：

1. **`==` 操作符**：

  •    `==` 用于比较两个对象的引用是否相同，即它们是否指向内存中的同一对象。
  •    当使用 `==` 来比较基本数据类型（如 `int`、`double`）时，它比较的是值是否相等。
  •    对于引用类型（对象），`==` 比较的是两个引用变量是否指向同一个对象，而不考虑对象的内容。

   示例：

String str1 = new String("Hello");
   String str2 = new String("Hello");
   
   System.out.println(str1 == str2); // false，因为它们是不同的对象

2. **`equals` 方法**：比较是否是同一个对象，equals方法存在于object类中，而object类时所有类直接或者间接的父类，在没有重写equals方法的类中，和==一样比较引用类型所只想的对象地址是否相等。重写equals方法就看各个类重写后的逻辑，比如String类，虽然是引用类型，但是String类重写了equals方法，方法内部比较的是字符串中的各个字符是否去哪不相等。

  •    `equals` 是一个方法，通常需要被重写以实现自定义的对象比较逻辑。在 `java.lang.Object` 类中，`equals` 方法默认行为与 `==` 相同，即比较对象的引用。
  •    通常，您应该在自定义类中重写 `equals` 方法，以根据对象的内容（属性值）来比较它们是否相等。

   示例：

 class Person {
       private String name;
       private int age;

       // 自定义 equals 方法，比较对象的属性值
       @Override
       public boolean equals(Object obj) {
           if (this == obj) {
               return true; // 同一对象
           }
           if (obj == null || getClass() != obj.getClass()) {
               return false; // 类型不同
           }
           Person person = (Person) obj;
           return age == person.age && Objects.equals(name, person.name);
       }
   }
   
   Person person1 = new Person("Alice", 30);
   Person person2 = new Person("Alice", 30);
   
   System.out.println(person1.equals(person2)); // true，因为属性值相同

总结：

  • `==` 操作符用于比较对象的引用，检查它们是否指向同一个内存位置。
  • `equals` 方法用于比较对象的内容，通常需要在自定义类中重写以实现属性值的比较。默认情况下，`equals` 方法在 `java.lang.Object` 中的行为与 `==` 相同。

五、两个对象的hashCode相同，则equals也一定为true吗？

 两个对象的hashCode相同，equals不一定为true；

两个对象的equals相同，则两个对象的hashCode一定为true；

Java知识总结（持续更新）_第3张图片

Java知识总结（持续更新）_第4张图片

六、&和&& 、 | 和 || 的区别？

1. **`&` 和 `&&`（逻辑与）**：

  •    `&` 和 `&&` 都用于执行逻辑与操作，即在两个条件都为 `true` 时返回 `true`。
  •    主要区别在于短路性（short-circuiting behavior）：
  •      `&` 是非短路操作，它会对两个条件都进行求值，无论第一个条件的结果如何。
  •      `&&` 是短路操作，它只在第一个条件为 `true` 时才会继续求值第二个条件，如果第一个条件为 `false`，则不会继续求值第二个条件。

   示例：

 boolean condition1 = false;
   boolean condition2 = true;
   
   // 对于 &，两个条件都会被求值，然后返回 false
   boolean result1 = condition1 & condition2; // result1 为 false
   
   // 对于 &&，由于第一个条件为 false，第二个条件不会被求值，直接返回 false
   boolean result2 = condition1 && condition2; // result2 为 false

2. **`|` 和 `||`（逻辑或）**：

  •    `|` 和 `||` 都用于执行逻辑或操作，即在两个条件中至少一个为 `true` 时返回 `true`。
  •    主要区别同样在于短路性：
  •      `|` 是非短路操作，它会对两个条件都进行求值，无论第一个条件的结果如何。
  •      `||` 是短路操作，它只在第一个条件为 `true` 时才会继续求值第二个条件，如果第一个条件为 `true`，则不会继续求值第二个条件。

   示例：

 boolean condition1 = true;
   boolean condition2 = false;
   
   // 对于 |，两个条件都会被求值，然后返回 true
   boolean result1 = condition1 | condition2; // result1 为 true
   
   // 对于 ||，由于第一个条件为 true，第二个条件不会被求值，直接返回 true
   boolean result2 = condition1 || condition2; // result2 为 true

总结：

  • `&` 和 `|` 是非短路逻辑操作符，它们会对两个条件都进行求值。
  • `&&` 和 `||` 是短路逻辑操作符，它们在满足条件的情况下不会继续求值第二个条件。
  • 通常情况下，建议使用 `&&` 和 `||` 来执行逻辑操作，因为它们具有短路性，可以提高性能并避免不必要的计算。

七、Java中的参数传递时传值呢？还是传引用？

        在 Java 中，参数传递是按值传递（pass-by-value），而不是按引用传递（pass-by-reference）。这意味着在方法调用时，将参数的值（也就是参数引用的副本）传递给方法，而不是传递参数的实际引用。

        当你将一个原始数据类型（如 `int`、`double`、`char` 等）作为参数传递给方法时，你传递的是该数据的值的副本。任何对参数值的修改都不会影响原始值。

public void modifyValue(int x) {
    x = 10; // 修改局部变量 x 的值，不会影响原始值
}

public static void main(String[] args) {
    int num = 5;
    modifyValue(num);
    System.out.println(num); // 输出 5，原始值不变
}

        当你将一个对象作为参数传递给方法时，你传递的是对象的引用的副本，而不是对象本身。这意味着你可以通过引用访问和修改对象的状态，但不能通过修改引用来改变原始对象引用的对象。

Java知识总结（持续更新）_第5张图片

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }
}

public void modifyPersonName(Person person) {
    person.name = "Alice"; // 修改对象的状态，会影响原始对象
}

public static void main(String[] args) {
    Person person = new Person("Bob");
    modifyPersonName(person);
    System.out.println(person.name); // 输出 "Alice"，原始对象状态被修改
}

        虽然传递的是引用的副本，但原始引用和方法中的引用指向的是同一个对象。所以，通过方法修改对象的状态会影响原始对象。但如果在方法中重新分配引用，原始引用不会受到影响。

        总结：Java 中的参数传递是按值传递，原始数据类型传递值的副本，而对象类型传递引用的副本，允许修改对象的状态，但不允许修改原始引用。

八、什么是Java的序列化，如何实现Java的序列化？

        Java 的序列化是一种将对象转换为字节流的过程，以便将其保存到文件、传输到网络或在不同 Java 虚拟机之间进行通信。序列化的主要目的是将对象的状态持久化或传输，以便在需要时能够还原对象。反序列化是序列化的逆过程，它将字节流重新转换为对象。

要实现 Java 的序列化，需要满足以下条件和步骤：

1. **实现 `Serializable` 接口**：
   要使一个类可序列化，它必须实现 `Serializable` 接口。这是一个标记接口，没有需要实现的方法。只要类声明实现了这个接口，编译器就知道这个类可以被序列化。   

 import java.io.Serializable;

   public class MyClass implements Serializable {
       // 类的成员和方法
   }

2. **使用 `ObjectOutputStream` 进行序列化**：
   要将对象序列化为字节流，您可以使用 `ObjectOutputStream` 类。首先，创建一个 `FileOutputStream` 或 `ByteArrayOutputStream` 来写入字节流，然后将其传递给 `ObjectOutputStream`。

import java.io.*;

   public class SerializationExample {
       public static void main(String[] args) {
           try {
               MyClass obj = new MyClass();
               FileOutputStream fileOut = new FileOutputStream("myObject.ser");
               ObjectOutputStream out = new ObjectOutputStream(fileOut);
               out.writeObject(obj);
               out.close();
               fileOut.close();
               System.out.println("Object serialized successfully.");
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
   }

3. **使用 `ObjectInputStream` 进行反序列化**：
   要从字节流中反序列化对象，您可以使用 `ObjectInputStream` 类。首先，创建一个 `FileInputStream` 或 `ByteArrayInputStream` 来读取字节流，然后将其传递给 `ObjectInputStream`。

 import java.io.*;

   public class DeserializationExample {
       public static void main(String[] args) {
           try {
               FileInputStream fileIn = new FileInputStream("myObject.ser");
               ObjectInputStream in = new ObjectInputStream(fileIn);
               MyClass obj = (MyClass) in.readObject();
               in.close();
               fileIn.close();
               System.out.println("Object deserialized successfully.");
           } catch (IOException | ClassNotFoundException e) {
               e.printStackTrace();
           }
       }
   }

Java知识总结（持续更新）_第6张图片4. **自定义序列化和反序列化**（可选）：
   如果您需要更精细的控制序列化和反序列化过程，您可以在类中定义特殊方法 `writeObject` 和 `readObject`。这允许您在序列化和反序列化期间执行自定义逻辑。

private void writeObject(ObjectOutputStream out) throws IOException {
       // 自定义序列化逻辑
       out.defaultWriteObject(); // 调用默认序列化
   }

   private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
       // 自定义反序列化逻辑
       in.defaultReadObject(); // 调用默认反序列化
   }

        需要注意的是，不是所有的对象都可以序列化，例如，如果对象包含不可序列化的成员变量，那么它也不能被序列化，或者需要采取额外的措施来处理这些成员。此外，序列化可能会涉及到版本控制，以确保反序列化的兼容性。

        总之，Java 的序列化是将对象转换为字节流以实现持久化或传输的重要机制，通过实现 `Serializable` 接口并使用 `ObjectOutputStream` 和 `ObjectInputStream`，您可以轻松实现对象的序列化和反序列化。

九、Java中的反射怎么理解？

        Java的反射机制是指在运行状态中，对于一个类都能够知道这个类所有的属性和方法；并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象方法的功能成为Java语言的反射机制。

        简单的说：在运行时动态的获取、操作和修改类或对象的属性、方法、构造函数等信息的能力，而不需要在编译时预先知道类的具体信息。

Java知识总结（持续更新）_第7张图片

1、如何利用反射机制获取class对象？

a、使用Class.forName静态方法

b、使用类型.class

c、使用实例对象的getClass方法

2、利用反射创造对象

a.使用class.newInstance()

b.使用constructor.newInstance()

// 方法1：获取class
        Class aClass = Class.forName("com.cxb.java.face.MyUser");
        System.out.println(aClass);
        // 方法1：创造对象
        MyUser o = (MyUser) aClass.newInstance();
        System.out.println(o);

        // 方法2：获取class
        Class bClass = MyUser.class;
        System.out.println(bClass);
        // 方法2：创造对象
        Constructor con = bClass.getConstructor();
        MyUser o1 = (MyUser) con.newInstance();
        System.out.println(o1);

        // 方法3：获取class
        Class cClass = new MyUser().getClass();
        System.out.println(cClass);
        System.out.println("******************");
        // 利用反射获取构造方法
        Class dClass = Class.forName("com.cxb.java.face.MyUser");
        Constructor[] declaredConstructors = dClass.getDeclaredConstructors();
        for (Constructor c : declaredConstructors) {
            System.out.println(c);
        }
        // 获取所有的public的方法
        Method[] methods = dClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("********getDeclaredMethods**********");
        // 获取类的所有方法
        Method[] declaredMethods = dClass.getDeclaredMethods();
        for (Method method : declaredMethods) {
            System.out.println(method);
        }
        System.out.println("**********getDeclaredFields********");
        Field[] declaredFields = dClass.getDeclaredFields();
        for (Field field: declaredFields) {
            System.out.println(field);
        }
        System.out.println("********getFields**********");
        Field[] fields = dClass.getFields();
        for (Field field: fields) {
            System.out.println(field);
        }

十、反射的应用场景有哪些？反射有什么优缺点？

反射在Java中有许多应用场景，它提供了一种在运行时检查和操作类、对象、方法和字段等信息的机制。以下是反射的一些常见应用场景：

1. **框架和库**：许多框架和库使用反射来处理各种类型的对象和配置，以提供更灵活的功能。例如，Spring框架使用反射来实现依赖注入和AOP（面向切面编程）。

2. **插件系统**：反射允许动态加载和卸载插件，这在应用程序需要扩展性时非常有用。您可以在运行时加载未知类，实现插件的动态添加。

3. **对象序列化**：反射用于对象的序列化和反序列化，允许将对象转换为字节流以进行持久化或网络传输，然后重新还原对象。

4. **单元测试**：在单元测试中，反射可以用于访问私有方法和字段，以便测试私有实现细节。

5. **动态代理**：反射用于创建动态代理对象，允许在运行时生成代理类，以实现AOP等功能。

6. **注解处理器**：反射用于处理自定义注解，例如在编写自定义注解处理器时，可以使用反射来检查和处理注解。

尽管反射提供了上述的灵活性和应用场景，但它也具有一些优点和缺点：

**优点**：

1. **动态性**：反射允许在运行时动态地操作类和对象，这在某些情况下非常有用，尤其是当您不知道类的类型或结构时。

2. **灵活性**：反射可以用于处理各种类型的对象，无需提前了解其类型。

3. **插件和扩展性**：反射允许实现插件系统和动态加载模块，从而增加了应用程序的可扩展性。

**缺点**：

1. **性能开销**：反射通常比直接调用代码的性能要差，因为它涉及到运行时的动态查找和解析。这可能会对性能敏感的应用程序产生影响。

2. **类型安全性**：反射可以绕过编译时类型检查，因此可能导致类型安全问题，如类转型异常。

3. **代码可读性和维护性**：反射代码通常较复杂，难以理解和维护，因此应该谨慎使用，避免滥用。

        总之，反射是一项强大的功能，但它应该谨慎使用，只在必要时使用，以避免性能问题和类型安全问题。在大多数情况下，最好使用编译时的类型安全性，只有在确实需要在运行时动态处理未知类或对象时才使用反射。

十一、如何实现动态代理？

在 Java 中，可以使用动态代理实现代理模式，动态代理允许你在运行时创建一个代理类，该代理类实现了一个或多个接口，并且可以代理实际对象的方法调用。动态代理通常用于实现日志记录、性能监测、事务管理等方面。

Java 提供了两种方式来实现动态代理：

1. **基于接口的动态代理（JDK 动态代理）**：

        JDK 动态代理是通过 Java 标准库中的 `java.lang.reflect.Proxy` 类来实现的。要使用 JDK 动态代理，需要满足以下条件：

  •    代理目标类必须实现一个或多个接口。
  •    创建一个 `InvocationHandler` 接口的实现类，该实现类定义了代理对象的行为。
  •    使用 `Proxy.newProxyInstance()` 方法创建代理对象。

   下面是一个示例： 

  import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   import java.lang.reflect.Proxy;

   interface MyInterface {
       void doSomething();
   }

   class RealObject implements MyInterface {
       public void doSomething() {
           System.out.println("RealObject is doing something.");
       }
   }

   class MyInvocationHandler implements InvocationHandler {
       private Object realObject;

       public MyInvocationHandler(Object realObject) {
           this.realObject = realObject;
       }

       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           System.out.println("Before invoking method.");
           Object result = method.invoke(realObject, args);
           System.out.println("After invoking method.");
           return result;
       }
   }

   public class DynamicProxyExample {
       public static void main(String[] args) {
           MyInterface realObject = new RealObject();
           MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
               DynamicProxyExample.class.getClassLoader(),
               new Class[]{MyInterface.class},
               new MyInvocationHandler(realObject)
           );

           proxy.doSomething();
       }
   }

2. **基于类的动态代理（CGLIB 动态代理）**：

        CGLIB（Code Generation Library）动态代理是通过创建目标类的子类来实现的，它不要求目标类实现接口。要使用 CGLIB 动态代理，需要引入 CGLIB 库，并使用 CGLIB 提供的工具来创建代理对象。

Java知识总结（持续更新）_第8张图片

   下面是一个示例：  

 import net.sf.cglib.proxy.Enhancer;
   import net.sf.cglib.proxy.MethodInterceptor;
   import net.sf.cglib.proxy.MethodProxy;

   class RealObject {
       public void doSomething() {
           System.out.println("RealObject is doing something.");
       }
   }

   class MyMethodInterceptor implements MethodInterceptor {
       public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
           System.out.println("Before invoking method.");
           Object result = proxy.invokeSuper(obj, args);
           System.out.println("After invoking method.");
           return result;
       }
   }

   public class DynamicProxyExample {
       public static void main(String[] args) {
           Enhancer enhancer = new Enhancer();
           enhancer.setSuperclass(RealObject.class);
           enhancer.setCallback(new MyMethodInterceptor());

           RealObject proxy = (RealObject) enhancer.create();

           proxy.doSomething();
       }
   }

        无论使用哪种动态代理方式，都可以在方法调用前后添加额外的逻辑，实现代理的功能。选择动态代理方式取决于您的需求和目标类的实现方式。如果目标类已实现接口，JDK 动态代理是一个不错的选择。如果目标类没有实现接口，可以考虑使用 CGLIB 动态代理。

Java知识总结（持续更新）_第9张图片

 十二、String为什么设计为不可变类？

Java 中的字符串（`String` 类）被设计为不可变类，这是出于一些重要的考虑和优点：

1. **安全性**：字符串常常用于存储敏感信息，如密码。如果字符串是可变的，那么它的值可以在创建后被修改，这可能会导致安全漏洞。通过设计字符串为不可变类，可以确保字符串的内容在创建后不会被修改，增强了安全性。

2. **线程安全**：不可变类天生是线程安全的，因为它的值无法在多个线程之间更改。这降低了多线程编程中的并发问题的复杂性，无需额外的同步措施。

3. **缓存**：由于字符串是不可变的，可以安全地进行缓存。字符串池（`String Pool`）是 Java 中的一个典型示例，它存储了字符串字面量的唯一实例。这减少了内存占用，提高了性能，因为相同的字符串只需要在内存中存储一次。

4. **性能优化**：不可变字符串在某些操作上可以提供性能优势。例如，字符串拼接操作（`concatenation`）可以通过创建新字符串来实现，而不必修改原始字符串，这可以减少内存分配和复制的开销。

5. **哈希码缓存**：不可变字符串可以缓存其哈希码（`hashCode`），以提高散列（`hashing`）性能。由于字符串的内容不会更改，其哈希码可以在首次计算后保持不变。

6. **参数传递安全**：由于字符串是不可变的，将其传递给方法或其他对象时不必担心它被修改，这增加了代码的可靠性。

总之，将字符串设计为不可变类带来了许多优点，包括安全性、线程安全性、性能优化和代码可靠性。这使得字符串在 Java 中成为一个重要且广泛使用的数据类型。如果需要对字符串进行修改操作，可以使用可变字符串类如 `StringBuilder` 或 `StringBuffer`，它们专门用于构建和修改字符串。但在大多数情况下，使用不可变字符串是一个良好的实践。

 十三、String、StringBuilder、StringBuffer的区别？

在 Java 中，`String`、`StringBuilder` 和 `StringBuffer` 都是用于处理字符串的类，但它们之间有一些重要的区别，主要涉及到不可变性、线程安全性和性能：

1. **String（不可变字符串）**：

  •    `String` 类是不可变的。一旦创建了一个 `String` 对象，它的值就不能被修改。
  •    任何对 `String` 的操作都会创建一个新的 `String` 对象，原始的 `String` 对象保持不变。这包括字符串连接、剪切、替换等操作。
  •    不可变性使得 `String` 可以被安全地共享，因此可以放心地将 `String` 对象作为参数传递给方法，而不担心其内容被修改。
  •    由于不可变性，`String` 对象的哈希码（`hashCode`）可以在首次计算后缓存，提高了哈希性能。

2. **StringBuilder（可变字符串，非线程安全）**：

  •    `StringBuilder` 是可变的，适用于需要频繁进行字符串操作的情况，如在循环中构建字符串。
  •    `StringBuilder` 的方法允许在现有对象上进行修改，而不会创建新的对象，从而提高了性能。
  •    由于 `StringBuilder` 不是线程安全的，因此在多线程环境下使用时需要额外的同步措施。

   示例：
 

 StringBuilder sb = new StringBuilder();
   sb.append("Hello");
   sb.append(" ");
   sb.append("World");
   String result = sb.toString(); // 构建最终字符串

3. **StringBuffer（可变字符串，线程安全）**：

  •    `StringBuffer` 与 `StringBuilder` 类似，也是可变的，但具备线程安全性。
  •    在多线程环境中，`StringBuffer` 是一个安全的选择，因为它的方法是同步的，可以防止多个线程同时修改字符串。

   示例：

 StringBuffer buffer = new StringBuffer();
   buffer.append("Hello");
   buffer.append(" ");
   buffer.append("World");
   String result = buffer.toString(); // 构建最终字符串

总结：

  • 如果字符串不需要更改（不可变），则使用 `String` 类。
  • 如果字符串需要频繁更改，并且在单线程环境下运行，使用 `StringBuilder` 可以提高性能。
  • 如果字符串需要频繁更改，并且在多线程环境下运行，使用 `StringBuffer` 来确保线程安全。Java知识总结（持续更新）_第10张图片

 十四、String str = "i" 与 String str = new String("i")一样吗？

不一样

因为内存的分配方式不一样。string str =“i”的方式，Jvm会将其分配到常量池中；而string str = new string(“i”)方式，则会分配到堆内存中。

Java知识总结（持续更新）_第11张图片

Java知识总结（持续更新）_第12张图片

 十五、接口和抽象类有什么区别？

接口（Interface）和抽象类（Abstract Class）是 Java 中两种不同的机制，用于实现抽象类型和多态性，它们之间有以下主要区别：

1. **定义**：
   - **接口**：接口是一种纯粹的抽象类型，它只包含抽象方法的声明（从 Java 8 开始，接口也可以包含默认方法和静态方法的实现）。接口不允许包含非抽象方法的实现。
   - **抽象类**：抽象类是一个类，它可以包含抽象方法的声明和非抽象方法的实现。抽象类允许在其中定义一些共享的行为。

2. **继承**：
   - **接口**：一个类可以实现多个接口，即一个类可以具有多个接口的特征和行为。接口之间的关系是多继承。
   - **抽象类**：一个类只能继承一个抽象类，这意味着类只能从一个抽象类中继承特征和行为。Java 不支持多继承。

3. **构造函数**：
   - **接口**：接口不能包含构造函数，因为接口不能被实例化。
   - **抽象类**：抽象类可以包含构造函数，它可以在实例化抽象类时执行一些初始化操作。

4. **成员变量**：
   - **接口**：接口中的变量默认为 `public`、`static`、`final`，也就是常量，不能包含实例变量。
   - **抽象类**：抽象类可以包含实例变量、静态变量和常量，它们的可见性可以根据访问修饰符进行控制。

5. **方法实现**：
   - **接口**：接口中的方法只有方法声明，不包含方法实现。实现类必须提供方法的具体实现。
   - **抽象类**：抽象类中可以包含抽象方法的声明和非抽象方法的实现。子类可以选择性地覆盖抽象方法。

6. **用途**：
   - **接口**：通常用于定义契约、规范或一组相关的抽象方法，以便不同的类可以实现这些方法来达到一定的共享行为。
   - **抽象类**：通常用于表示一类对象的通用特征和行为，以便多个子类可以继承和共享这些特征和行为。

总结：

  • 接口强调规范和契约，允许多继承，没有方法实现。
  • 抽象类允许共享通用行为和状态，允许单一继承，可以包含方法实现。
  • 选择接口还是抽象类取决于设计需求，通常需要根据具体情况来决定使用哪种方式。

 十六、什么是浅拷贝和深拷贝？

浅拷贝（Shallow Copy）和深拷贝（Deep Copy）是两种不同的对象复制方式，它们涉及到如何复制对象以及复制后对象之间的引用关系。

1. **浅拷贝（Shallow Copy）**：
   - 浅拷贝是一种对象复制方式，它创建一个新的对象，但只复制了原始对象的基本数据类型字段的值和引用类型字段的引用（内存地址），而不复制引用类型字段所引用的对象本身。
   - 结果是，浅拷贝后的对象和原始对象共享某些引用类型字段所引用的对象。如果其中一个对象修改了共享的引用类型对象，另一个对象也会受到影响。   示例：

@Data
@NoArgsConstructor
public class Address implements Serializable {
    private String city;

    public Address(String city) {
        this.city = city;
    }
}


@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person implements Serializable {
    private String name;
    private Address address;
}


浅拷贝：
public static void main(String[] args) {
        Person original = new Person("Alice", new Address("New York"));
        Person copy = new Person(original.getName(), original.getAddress());
        // 修改拷贝后的对象的地址
        copy.getAddress().setCity("Los Angeles");
        // 输出 "Los Angeles"，因为拷贝和原始对象共享同一个 Address 对象
        System.out.println(original.getAddress().getCity());
}



深拷贝：
public static void main(String[] args) {
        Person original = new Person("Alice", new Address("New York"));
        // 使用 Java 中的深拷贝库，例如 Apache Commons Lang 库中的 SerializationUtils
        Person copy = SerializationUtils.clone(original);
        // 修改拷贝后的对象的地址
        copy.getAddress().setCity("Los Angeles");
        // 输出 "Los Angeles"，因为拷贝和原始对象共享同一个 Address 对象
        System.out.println(original.getAddress().getCity());
    }

2. **深拷贝（Deep Copy）**：
   - 深拷贝是一种对象复制方式，它创建一个新的对象，并递归复制原始对象以及原始对象引用的所有对象。这意味着深拷贝后的对象和原始对象完全独立，不共享任何对象。
   - 深拷贝通常需要额外的代码来实现，以确保所有引用类型字段都被复制，包括它们引用的对象。   示例（使用 Java 中的深拷贝库或手动实现）：

 // 使用 Java 中的深拷贝库，例如 Apache Commons Lang 库中的 SerializationUtils
   Person original = new Person("Alice", new Address("New York"));
   Person copy = SerializationUtils.clone(original); // 深拷贝

   // 修改拷贝后的对象的地址
   copy.address.city = "Los Angeles";

   System.out.println(original.address.city); // 输出 "New York"，因为深拷贝后的对象和原始对象不共享对象

总结：

  • 浅拷贝只复制对象的引用，导致拷贝后的对象和原始对象可能共享某些对象。它通常使用默认的对象复制方式实现。
  • 深拷贝复制对象及其引用的所有对象，确保拷贝后的对象完全独立于原始对象。深拷贝通常需要额外的代码来实现，或使用深拷贝库。选择哪种方式取决于您的需求和对象结构。

 十七、Overload、Override、Overwrite的区别？

"Overload"、"Override" 和 "Overwrite" 是与方法和函数相关的术语，它们在 Java 和其他编程语言中有特定的含义和用途：

1. **Overload（重载）**：
   - "Overload" 是指在同一个类中定义多个具有相同名称的方法，但这些方法的参数列表不同（参数数量或参数类型不同）。编译器会根据方法调用的参数类型来选择调用哪个重载方法。
   - 重载方法可以具有不同的返回类型，但不能仅依据返回类型来区分方法。因为编译器不仅根据方法的名称和参数类型，还会考虑方法的返回类型来决定调用哪个方法。   示例：

 class MathUtils {
       int add(int a, int b) {
           return a + b;
       }

       double add(double a, double b) {
           return a + b;
       }
   }

2. **Override（重写）**：
   - "Override" 是指子类重写（覆盖）了父类中的方法，子类的方法具有相同的名称、参数列表和返回类型。重写方法通常用 `@Override` 注解来标记，以确保正确性。
   - 重写方法必须满足一定的规则，例如访问修饰符不能更严格（不能缩小访问范围）、不能抛出比父类更多的异常，等等。   示例：

class Animal {
       void makeSound() {
           System.out.println("Animal makes a sound");
       }
   }

   class Dog extends Animal {
       @Override
       void makeSound() {
           System.out.println("Dog barks");
       }
   }

3. **Overwrite（覆盖）**：
   - "Overwrite" 在文件操作中，覆盖通常是指将已有的文件内容替换新的内容。

总结：
- "Overload" 重载：意味着在同一个类中定义了多个同名方法，但参数列表不同。
- "Override" 重写：表示子类重写了父类中的方法，方法名称、参数列表和返回类型都相同。
- "Overwrite" 覆盖：指在文件操作中，将文件内容替换为新的内容。

十八、Exception和Error有什么区别？

`Exception` 和 `Error` 是 Java 中的两种不同的异常类，它们之间有以下主要区别：

1. **继承关系**：

  •    `Exception` 类属于 Java 异常层次结构中的一部分，它是 `Throwable` 类的子类。
  •    `Error` 类也属于 Java 异常层次结构，但它是 `Throwable` 类的子类的子类。换句话说，`Error` 和 `Exception` 都是可以被抛出的可检查异常，但它们在层次结构中的位置不同。

2. **异常的用途**：

  •    `Exception` 用于表示程序可能能够处理的异常情况。这些异常通常是由程序错误、用户输入错误或外部环境因素引起的，程序可以通过捕获和处理这些异常来继续执行。
  •    `Error` 用于表示严重的系统问题，通常是由虚拟机（JVM）或其他底层资源出现的问题，例如内存不足、栈溢出、类加载问题等。`Error` 通常表示程序无法恢复的情况，不应该捕获和处理它们，而应该让程序崩溃。

3. **检查和非检查异常**：
   a.`Exception` 分为两种：检查异常（Checked Exception）和非检查异常（Unchecked Exception）。

  •    检查异常是编译器要求必须处理的异常，即必须使用 `try-catch` 块或在方法签名中使用 `throws` 声明来处理它们。通常是继承自 `Exception` 类的子类。
  •    非检查异常是不受编译器检查的异常，通常是继承自 `RuntimeException` 类的子类。这些异常通常表示程序错误，如空指针异常（`NullPointerException`）和数组越界异常（`ArrayIndexOutOfBoundsException`）等。

   b.`Error` 是非检查异常，它通常不需要在代码中进行显式处理。程序员不应该捕获和处理 `Error`，因为它们表示严重的系统问题，处理它们通常是不恰当的。

总结：

  1. `Exception` 是用于表示程序可能能够处理的异常情况的类，它分为检查异常和非检查异常。
  2. `Error` 是用于表示严重系统问题的类，通常表示程序无法恢复的情况，不应该捕获和处理。Java知识总结（持续更新）_第13张图片

 十九、Java中的IO流的分类？说出几个熟悉的实现类？

在JAVA中，IO流可以根据其功能和作用进行分类。主要分为四种类型：字节流、字符流、缓冲流和对象流。

Java知识总结（持续更新）_第14张图片

 1、字节流（Byte Stream）：以字节为单位进行读写操作的流。字节流通常用于处理二进制数据或字节形式的文本数据。

Java知识总结（持续更新）_第15张图片

2、字符流（Character Stream）：以字符为单位进行读写操作的流。字符流通常用于处理字符数据，支持Unicode编码。

Java知识总结（持续更新）_第16张图片

 3、缓冲流（Buffered Stream）：提供了缓冲功能，可以减少实际IO操作的次数，提高读写效率。

Java知识总结（持续更新）_第17张图片

4、对象流（Object Stream）：用于读写Java对象的流。可以方便地将对象序列化和发序列化到文件或网络中。

Java知识总结（持续更新）_第18张图片

 二十、常见的异常类有哪些？

Java知识总结（持续更新）_第19张图片

Java知识总结（持续更新）_第20张图片

二十一、并行和并发有什么区别？

"并行"（Parallelism）和 "并发"（Concurrency）是计算机科学中两个重要的概念，它们描述了程序中任务执行的方式，但它们有不同的含义和应用场景：

1. **并行（Parallelism）**：

  •    并行指的是同时执行多个任务，通常是在多个处理单元（如多核处理器、多线程或多进程）上执行。在并行计算中，多个任务真正同时运行，每个任务都有自己的执行线程或进程。
  •    并行通常用于提高程序的性能，特别是在需要大量计算或处理的情况下。通过将任务分配给多个处理单元，可以加速任务的完成。
  •    并行编程的一个挑战是处理竞争条件和同步问题，因为多个任务可能会同时访问共享资源。

2. **并发（Concurrency）**：

  •    并发指的是在一个时间段内执行多个任务，但不一定是同时执行。在并发计算中，多个任务可能交替执行，每个任务执行一小段时间，然后切换到另一个任务。
  •    并发通常用于处理多个独立的任务或响应多个请求，使程序可以更高效地利用资源。例如，一个网络服务器可以同时处理多个客户端请求。
  •    并发编程的一个主要挑战是协调任务的执行，以确保正确性和避免竞争条件。

总结：

  • 并行是真正同时执行多个任务，通常用于提高性能。
  • 并发是在一个时间段内执行多个任务，任务可能交替执行，通常用于多任务处理和资源共享。
  • 并行和并发都是重要的概念，根据问题的性质和硬件资源来选择合适的策略。有时，它们也可以结合使用，即并发任务中的每个任务可以使用并行处理来提高性能。

 二十二、什么是进程和线程？

Java知识总结（持续更新）_第21张图片

 二十三、线程有几种创建方式？

Java知识总结（持续更新）_第22张图片

二十四、为什么调用start方法时会执行run方法，那怎么不直接调用run方法？

        在Java中，当你调用`start()`方法时，会启动一个新的线程，这个新线程会执行`run()`方法中的代码。这是因为`start()`方法负责启动一个新的线程，而`run()`方法是新线程的入口点，包含了新线程要执行的代码。

        如果你直接调用`run()`方法，那么实际上并不会启动新线程，而只会在当前线程中执行`run()`方法的代码。这就失去了多线程的优势，因为所有的代码都在同一个线程中执行，不能充分利用多核处理器等多线程的好处。

        通过调用`start()`方法来启动新线程，可以让操作系统调度新线程并分配处理器时间片，从而实现并发执行。这样可以充分利用多核处理器，提高程序的性能和响应能力。

总结：

  • `start()`方法负责启动新线程，新线程会执行`run()`方法中的代码。
  • 直接调用`run()`方法只会在当前线程中执行代码，不会启动新线程，不具备多线程的并发性能优势。

 二十五、线程有哪些常用的调度方法

Java知识总结（持续更新）_第23张图片

二十六、线程有几种状态？

Java知识总结（持续更新）_第24张图片

Java知识总结（持续更新）_第25张图片 二十七、什么是线程上下文切换？

        线程上下文切换（Thread Context Switching）是指操作系统在多线程环境下，由于多个线程之间轮流运行，需要将当前线程的执行上下文（包括寄存器内容、程序计数器、堆栈指针等）保存到内存中，同时加载下一个要执行的线程的上下文到处理器寄存器中的过程。

线程上下文切换通常在以下情况发生：

1. **时间片用完**：操作系统为每个线程分配一小段时间片（通常几毫秒），当一个线程的时间片用完后，操作系统会进行上下文切换，切换到另一个线程执行，以实现多线程并发。

2. **等待资源**：如果一个线程请求某些资源（如锁、IO操作等）而无法立即获得，它可能会被挂起（阻塞状态），并进行上下文切换，以允许其他线程继续执行。

3. **线程优先级**：线程调度器可能根据线程的优先级来决定哪个线程应该获得执行时间，这也可能导致上下文切换。

        线程上下文切换的开销相对较高，因为它涉及到将寄存器内容写入内存并加载新线程的寄存器内容，这需要时间和计算资源。因此，在高度并发的系统中，频繁的上下文切换可能会导致性能下降。

为了减少线程上下文切换的开销，操作系统和编程语言运行时库通常采用了以下策略：

  • 使用更少的线程：精心选择线程数量，避免创建过多的线程。
  • 使用线程池：重复使用线程而不是频繁地创建和销毁线程。
  • 避免阻塞操作：采用非阻塞的算法和IO操作，以减少线程挂起的机会。
  • 使用协程或轻量级线程：这些机制允许更灵活地切换上下文，减少开销。

        理解和管理线程上下文切换对于编写高效的多线程程序非常重要，因为它可以减少性能瓶颈和资源浪费。

二十八、线程间有哪些通信方式？

在多线程编程中，线程之间需要进行通信以实现协作和数据交换。以下是常见的线程间通信方式：

1. **共享内存**：

  •    多个线程共享同一块内存区域，通过读写共享内存来进行通信。
  •    优点：速度快，适用于数据共享。
  •    缺点：需要显式的同步机制来避免竞争条件（如锁），容易引发线程安全问题。

2. **管道（Pipe）**：

  •    一种单向通信机制，通常用于父子进程间或兄弟进程间的通信。
  •    优点：简单易用。
  •    缺点：只能实现单向通信。

3. **消息队列（Message Queue）**：

  •    线程通过将消息发送到队列，然后另一个线程从队列中接收消息来进行通信。
  •    优点：解耦了线程之间的依赖，适用于异步通信。
  •    缺点：实现较为复杂，需要消息队列的支持。

4. **信号量（Semaphore）**：

  •    一种用于线程间同步的计数器，通常用于控制同时访问共享资源的线程数量。
  •    优点：用于限制并发度，可以用于解决资源管理问题。
  •    缺点：使用复杂，容易引发死锁。

5. **条件变量（Condition Variable）**：

  •    用于线程之间的协作，允许线程等待某个条件成立时被唤醒。
  •    优点：可用于线程的精细控制和协作。
  •    缺点：需要与互斥锁结合使用。

6. **屏障（Barrier）**：
   - 用于同步多个线程，要求所有线程达到某个点后才能继续执行。
   - 优点：适用于多个线程之间的协同工作。
   - 缺点：使用复杂，需要考虑线程数量和屏障的位置。

7. **分布式通信方式**：
   - 用于多台计算机或多个进程之间的通信，如远程过程调用（RPC）、消息传递接口（MPI）等。

这些通信方式可根据具体需求和场景来选择。线程之间的通信通常需要谨慎设计，以避免竞争条件、死锁等问题，同时提高多线程程序的性能和可维护性。

二十九、ThreadLocal是什么？

        `ThreadLocal` 是 Java 中的一个类，用于在多线程环境下存储线程本地（Thread-Local）变量。线程本地变量是指每个线程都拥有自己独立的变量副本，这些副本在不同线程中互不干扰。`ThreadLocal` 提供了一种在多线程环境下访问线程本地变量的机制。

`ThreadLocal` 主要具有以下特点和用途：

1. **独立性**：每个线程都可以通过 `ThreadLocal` 创建自己的局部变量，这些变量不会被其他线程访问或修改。这样可以避免多线程环境下的竞争条件和同步问题。

2. **线程封闭性**：`ThreadLocal` 可以用于实现线程封闭性，即将某个对象限定在单个线程内部访问，不被其他线程访问，从而保护对象的安全性。

3. **避免参数传递**：使用 `ThreadLocal` 可以避免在方法之间传递参数，因为每个线程都可以直接访问自己的局部变量，简化了代码和方法之间的耦合度。

4. **线程池中的应用**：`ThreadLocal` 在线程池中的应用较为常见。线程池中的多个线程可以共享一些资源，但同时也需要各自保持独立的状态，这时可以使用 `ThreadLocal` 来存储每个线程的状态信息。

使用 `ThreadLocal` 的基本操作包括：

  • `set(T value)`：将一个值存储到当前线程的 `ThreadLocal` 变量中。
  • `get()`：获取当前线程的 `ThreadLocal` 变量的值。
  • `remove()`：移除当前线程的 `ThreadLocal` 变量。

示例：

public class ThreadLocalExample {
    private static ThreadLocal threadLocal = ThreadLocal.withInitial(() -> 0);

    public static void main(String[] args) {
        threadLocal.set(42);

        Runnable task = () -> {
            int value = threadLocal.get();
            System.out.println("Thread-local value: " + value);
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

        thread1.start();
        thread2.start();
    }
}

        需要注意的是，使用 `ThreadLocal` 时应注意内存泄漏问题，因为线程本地变量的生命周期通常与线程相同，如果不及时清理或移除，可能会导致对象无法被垃圾回收。因此，一般建议在不再需要使用 `ThreadLocal` 变量时，手动调用 `remove()` 方法来清理。

Java知识总结（持续更新）_第26张图片

Java知识总结（持续更新）_第27张图片

从代码可以看出，每个线程都是独立的threadlocal。

三十、ThreadLocal是怎么实现的？

 ThreadLocal是Java中所提供的线程本地存储机制，可以利用该机制将数据缓存在某个线程内部，该线程可以在任意时刻、任意方法中获取缓存的数据。

ThreadLocal底层是通过ThreadLocalMap来实现的，每个Thread对象（注意不是ThreadLocal对象）中都存在一个ThreadLocalMap，Map的key为ThreadLocal对象，Map的value为需要缓存的值。

Java知识总结（持续更新）_第28张图片

Java知识总结（持续更新）_第29张图片

Java知识总结（持续更新）_第30张图片 三十一、ThreadLocal内存泄漏是怎么回事？

如果在线程池中使用ThreadLocal会造成内存泄漏，因为当ThreadLocal对象使用完之后，应该要把设置的key，value也就是entry对象进行回收，但线程池中的线程不会回收，而线程对象是通过强引用指向ThreadLocalMap，ThreadLocalMap也是通过强引用指向entry对象，线程不被回收，entry对象也就不会被回收，从而出现内存泄漏。

解决方法：使用了ThreadLocal对象之后，手动调用ThreadLocal的remove方法，手动清除entry对象。

Java知识总结（持续更新）_第31张图片

三十二、ThreadLocalMap的结构

ThreadLocalMap虽然被称为Map，但是它其实是没有实现Map接口的，不够结构还是和HashMap比较类似的。

Java知识总结（持续更新）_第32张图片

1. **数组表格（Table）**：
   - `ThreadLocalMap` 实际上是一个数组表格，通常是一个固定大小的数组，每个元素都是一个 `Entry` 对象。
   - 每个 `Entry` 对象包含了两个字段，一个是 `ThreadLocal` 对象作为键，另一个是线程本地变量的值。

2. **散列算法**：
   - `ThreadLocalMap` 使用散列算法来确定线程本地变量的存储位置。它根据 `ThreadLocal` 对象的哈希码计算出一个索引，然后将 `Entry` 对象存储在该索引位置的数组元素中。
   - 不同的 `ThreadLocal` 对象可以具有相同的哈希码，因此在数组的同一索引位置可能存在多个 `Entry` 对象，但每个 `ThreadLocal` 对象只关联一个 `Entry`。

   - 就是怎么把对应的key映射到table数组的相应下标，ThreadLocalMap、用的是哈希取余法，去除key的threadLocalHashCode，然后和table数组长度减一&预算（相当于取余） 

3. **哈希冲突处理**：
   - 当多个 `ThreadLocal` 对象具有相同的哈希码，导致冲突时，`ThreadLocalMap` 使用线性探测法等方法来解决冲突，找到合适的存储位置。

  - 补充一点每创建一个ThreadLocal对象，它就会新增0x61c88647,这个值很特殊，它是斐波那契数也叫黄金分割数。这样带来的好处就是hash分布非常均匀。

4. **扩容机制**：
   - 当 `ThreadLocalMap` 中的元素数量达到一定阈值时，它会进行扩容，创建一个更大的数组，然后重新散列所有的 `Entry` 对象到新数组中。

5. **内存管理**：
   - `ThreadLocalMap` 中的 `Entry` 对象通常是弱引用，这意味着如果 `ThreadLocal` 对象不再被引用，`Entry` 对象可能会被垃圾回收，从而释放相关的线程本地变量。

总的来说，`ThreadLocalMap` 是一个用于存储线程本地变量的散列表结构，它允许每个线程在其中存储和检索与特定 `ThreadLocal` 对象关联的值，确保线程之间的隔离性。这种机制允许多个线程同时访问线程本地变量，而不会相互干扰。在多线程环境中，`ThreadLocalMap` 是确保线程本地变量正确工作的关键部分。

三十三、ThreadLocalMap怎么解决Hash冲突？

我们都知道HashMap使用了链表来解决冲突，也就是所谓的链地址法。

ThreadLocalMap内部使用的是开放地址法来解决Hash冲突的问题（线性探测法）。具体来说，当发生Hash冲突时，ThreadLocalMap会将当前插入的元素从冲突位置开始依次往后遍历，直到找到一个空闲的位置，然后把该元素放在这个空闲位置。这样即使出现了Hash冲突，不会影响到已经插入的元素，而只是会影响到新的插入操作。

Java知识总结（持续更新）_第33张图片

三十四、ThreadLocalMap扩容机制

ThreadLocalMap的扩容机制和HashMap类似，也是在元素数量达到阈值（默认为数组长度的2/3）时进行扩容。具体来说，在set方法中，如果当前元素数量已经达到了阈值，就会调用rehash方法，rehash方法会先去清理过期的entry，然后还要根据条件判断size >= threshold - threshold/4也就是size=threshold * 3/4来决定是否需要扩容。

Java知识总结（持续更新）_第34张图片

Java知识总结（持续更新）_第35张图片

 发现需要扩容时调用resize方法，resize方法首先将数组长度翻倍，然后创建一个新的数组newTab。接着遍历旧数组oldTab中的所有元素，散列方法重新计算位置，开放地址解决冲突，然后放到新的newTab，遍历完成之后，oldTab中所有的entry数据都已经放入到newTab中了，然后table引用指向newTab。

Java知识总结（持续更新）_第36张图片

需要注意的是，新数组的长度始终是2的整数次幂，并且扩容后新数组的长度始终大于旧数组的长度。这是为了保证哈希函数计算出的位置在新数组中仍然有效。

三十五、ThreadLocal怎么进行父子线程通信

        在Java多线程编程中，父子线程之间的数据传递和共享问题一直是一个非常重要的议题。如果不处理好数据的传递和共享，会导致多线程程序的性能下降或者出现线程安全问题。ThreadLocal是Java提供的一种解决方案，可以非常好的解决父子线程数据共享和传递的问题。

        那么它是如何实现通信的呢？在Thread类中存在inheritableThreadLocals变量，简单的说就是使用inheritableThreadLocals来进行传递，当父线程的inheritableThreadLocals不为空时，就会将这个值传到当前子线程的inheritableThreadLocals。

Java知识总结（持续更新）_第37张图片

public class Test1 {
    public static void main(String[] args) {
        ThreadLocal threadLocal = new ThreadLocal<>();
        threadLocal.set("threadLocal");

        InheritableThreadLocal inheritableThreadLocal = new InheritableThreadLocal<>();
        inheritableThreadLocal.set("test + inheritableThreadLocal");

        Thread t = new Thread(() -> {
            System.out.println(threadLocal.get());
            System.out.println(inheritableThreadLocal.get());
        });
        t.start();
    }
} 
  
Java知识总结（持续更新）_第38张图片
 
  
由此可见： 在子线程中可以通过inheritableThreadLocal获取主线程的值。
 
  
三十六、说一下你对Java内存模型（JMM）的理解
 
  
        Java内存模型（Java memory model）是一种规范，用于描述Java虚拟机（JVM）中多线程情况下，线程之间如何协同工作，如何共享数据，并保证多线程的操作在各个线程之间的可见性、有序性和原子性。
 
  
具体定义如下：
 
  
     
   
  • 所有的变量都存储在主内存（main memory）中。
    •  
   
  • 每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的拷贝副本。
    •  
   
  • 线程对变量的所有操作都必须在本地内存中进行，而不能直接读写主内存。
    •  
   
  • 不同的线程之间无法直接访问对方本地内存的变量；线程间共享变量时，通过主内存来实现通信、协作和传递信息。
    •  
  
 
  
Java知识总结（持续更新）_第39张图片
 
  
三十七、说说你对原子性、可见性、有序性的理解？
 
  
        原子性（Atomicity）：原子性是指一个操作是不可分割的最小执行单位。在多线程环境中，原子操作要么完全执行，要么完全不执行，不存在中间状态。原子性确保了多线程环境下的数据一致性。Java 中的 synchronized 关键字和 java.util.concurrent 包中的原子类（如 AtomicInteger）可以用来实现原子性。        
 
  
int count = 0; // 1
count++;       // 2
int a = count; // 3
 
  
 上面展示的语句中，除了语句1是原子操作，其他两个都不是原子性操作。下面看下语句2：包括了3个指令：
 
  
     
   
  • 指令1：首先，把变量count从内存加载到cpu寄存器
    •  
   
  • 指令2：然后，在寄存器中执行+1操作
    •  
   
  • 指令3：最终，将结果写入内存
    •  
  
 
  
对于上面的3条指令来说，如果线程A在指令1完成后线程切换，线程A和线程B按照下图顺序执行，此时执行的结果就不会达到预期。
 
  
Java知识总结（持续更新）_第40张图片
 
  
         可见性（Visibility）：可见性是指当一个线程修改了共享变量的值后，其他线程能够立即看到这个修改。在多核处理器和多线程环境下，由于缓存和指令重排序等优化，一个线程对共享变量的修改可能对其他线程不可见，导致数据不一致。为了确保可见性，通常需要使用同步机制（如 synchronized、volatile、java.util.concurrent 包中的锁等）来保证共享变量的可见性。
 
  
        有序性（Ordering）：有序性是指程序执行的顺序与代码中的顺序相一致。在多线程环境中，由于指令重排序等优化，线程执行的顺序可能与代码中的顺序不一致，导致意外的结果。为了确保有序性，可以使用同步机制来限制指令重排序，或者使用 volatile 关键字来禁止特定类型的重排序。 
 
  
 
   
总结：
 
   
     
    
  • 原子性确保操作是不可分割的，要么全部执行成功，要么全部不执行。
    •  
    
  • 可见性确保一个线程对共享变量的修改能够被其他线程立即看到。
    •  
    
  • 有序性确保程序执行的顺序与代码中的顺序相一致，防止指令重排序导致的问题。
    •  
    
  • 在多线程编程中，要注意这三个特性，以确保程序的正确性和可靠性。
    •  
   
 
  
 
  
 三十八、说说什么是指令重排？
 
  
        在不影响单线程程序执行结果的前提下，计算机为了最大限度的发挥机器性能，对机器指令进行重排序优化。
 
  
Java知识总结（持续更新）_第41张图片
 
  
 Java知识总结（持续更新）_第42张图片
 
  
     
   
  1.  
    编译器级别的重排：编译器也可以进行指令重排，以优化生成的机器代码。编译器会考虑到处理器的特性和架构，生成更有效率的指令序列。
     
    2.  
   
  2.  
    指令级别的重排：这种重排会重新排序计算机指令的执行顺序，以便更有效地利用处理器的流水线执行指令。例如，处理器可以在某个指令执行的同时开始执行下一条指令，从而减少指令之间的等待时间。
     
    3.  
   
  3.  
    内存访问的重排：这种重排会重新排序对内存的读取和写入操作，以减少内存访问的延迟。例如，处理器可以在一个内存读取操作执行的同时，继续执行后续指令，而不必等待读取操作完成。
     
    4.  
  
 
  
以双重校验锁单利模式为例，Singleton instance = new Singleton();对应的JVM指令分为3步；分配内存空间-->初始化对象-->对象指向分配的内存空间，但是经过了编译器的指令重排序，第二步和第三步就可能重排序。
 
  
Java知识总结（持续更新）_第43张图片
 
  
 三十九、指令重排有限制吗？happens-before了解吗？
 
  
Java知识总结（持续更新）_第44张图片
 
  
 
  
Java知识总结（持续更新）_第45张图片Java知识总结（持续更新）_第46张图片 Java知识总结（持续更新）_第47张图片
 
  
 Java知识总结（持续更新）_第48张图片
 
  
 四十、as-if-serial又是什么？单线程的程序一定是顺序的嘛？
 
  
Java知识总结（持续更新）_第49张图片
 
  
 Java知识总结（持续更新）_第50张图片
 
  
四十一、volatile实现原来了解吗？
 
  
volatile有两个作用，保证可见性和有序性。
 
  
Java知识总结（持续更新）_第51张图片
 
  
Java知识总结（持续更新）_第52张图片
 
  
Java知识总结（持续更新）_第53张图片
 
  
 四十二、synchronized如何使用？
 
  
Java知识总结（持续更新）_第54张图片
 
  
Java知识总结（持续更新）_第55张图片
 
  
四十三、synchronized的实现原理？
 
  
Java知识总结（持续更新）_第56张图片
 
  
 Java知识总结（持续更新）_第57张图片
 
  
四十四、synchronized的可见性，有序性，可重入性是怎么实现的？
 
  
Java知识总结（持续更新）_第58张图片
 
  
Java知识总结（持续更新）_第59张图片 
 
  
 四十五、说说Synchronized和ReentrantLock的区别
 
  
Java知识总结（持续更新）_第60张图片
 
  
Java知识总结（持续更新）_第61张图片
 
  
 四十六、ReentranLock实现原理？
 
  
Java知识总结（持续更新）_第62张图片
 
  
步工具之一。
 
  
四十七、reentrantLock怎么实现公平锁？
 
  
Java知识总结（持续更新）_第63张图片
 
  
Java知识总结（持续更新）_第64张图片
 
  
四十八、什么是CAS？
 
  
Java知识总结（持续更新）_第65张图片
 
  
四十九、CAS存在什么问题？如何解决？
 
  
Java知识总结（持续更新）_第66张图片
 
  
Java知识总结（持续更新）_第67张图片
 
  
五十、Java多线程中如何保证i++的结果正确
 
  
Java知识总结（持续更新）_第68张图片
 
  
五十一、AtomicInteger的原理是什么？
 
  
Java知识总结（持续更新）_第69张图片
 
  
 五十二、什么是线程死锁？我们该如何避免线程死锁？
 
  
Java知识总结（持续更新）_第70张图片
 
  
Java知识总结（持续更新）_第71张图片
 
  
Java知识总结（持续更新）_第72张图片
 
  
五十三、如何排查死锁问题？
 
  
Java知识总结（持续更新）_第73张图片
 
  
Java知识总结（持续更新）_第74张图片
 
  
 Java知识总结（持续更新）_第75张图片
 
  
Java知识总结（持续更新）_第76张图片
 
  
Java知识总结（持续更新）_第77张图片 五十四、什么是线程池？
 
  
Java知识总结（持续更新）_第78张图片
 
  
五十五、简单说一下线程池的工作流程
 
  
Java知识总结（持续更新）_第79张图片
 
  
Java知识总结（持续更新）_第80张图片
 
  
五十六、线程池有哪些拒绝策略？
 
  
Java知识总结（持续更新）_第81张图片
 
  
五十七、线程池有哪几种工作队列？
 
  
Java知识总结（持续更新）_第82张图片
 
  
 
  
 五十八、线程池提交execute和submit有什么区别？
 
  
1、execute提交不需要返回值的任务。
 
  
Java知识总结（持续更新）_第83张图片
 
  
 2、submit用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get方法来获取返回值
 
  
Java知识总结（持续更新）_第84张图片
 
  
 五十九、怎么关闭线程池？
 
  
Java知识总结（持续更新）_第85张图片
 
  
Java知识总结（持续更新）_第86张图片
 
  
 六十、有哪几种常见的线程池？
 
  
 
  
Java知识总结（持续更新）_第87张图片
 
  
Java知识总结（持续更新）_第88张图片 Java知识总结（持续更新）_第89张图片
 
  
Java知识总结（持续更新）_第90张图片
 
  
 Java知识总结（持续更新）_第91张图片
 
  
 Java知识总结（持续更新）_第92张图片
 
  
Java知识总结（持续更新）_第93张图片
 
  
Java知识总结（持续更新）_第94张图片
 
  
六十一、线程池异常怎么处理？
 
  
Java知识总结（持续更新）_第95张图片
 
  
 六十二、线程池有哪几种状态？
 
  
Java知识总结（持续更新）_第96张图片
 
  
Java知识总结（持续更新）_第97张图片
 
  
 六十三、NIO的原理，包括哪几个组件？
 
  
Java知识总结（持续更新）_第98张图片
 
  
Java知识总结（持续更新）_第99张图片 
 
  
Java知识总结（持续更新）_第100张图片
 
  
六十四、零拷贝
 
  
Java知识总结（持续更新）_第101张图片
 
  
Java知识总结（持续更新）_第102张图片
 
  
Java知识总结（持续更新）_第103张图片
 
  
write函数返回。
 
  
Java知识总结（持续更新）_第104张图片
 
  
MMap+write实现零拷贝：
 
  
Java知识总结（持续更新）_第105张图片
 
  
Java知识总结（持续更新）_第106张图片
 
  
 Java知识总结（持续更新）_第107张图片
 
  
Java知识总结（持续更新）_第108张图片 
 
  
 
  
 
  
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,开发语言)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    
                    
    • 
                                
  • windows下源码安装golang
                                    616050468
golang安装golang环境windows
                                    
             系统： 64位win7， 开发环境：sublime text 2，  go版本： 1.4.1 
  
 1.  安装前准备(gcc, gdb, git) 
       golang在64位系
    
                                
    • 
                                
  • redis批量删除带空格的key
                                    bylijinnan
redis
                                    
    redis批量删除的通常做法： 
 
 
redis-cli keys "blacklist*" | xargs redis-cli del 
 
上面的命令在key的前后没有空格时是可以的，但有空格就不行了： 
 

$redis-cli keys "blacklist*"
1) "blacklist:12: [email protected]
    
                                
    • 
                                
  • oracle正则表达式的用法
                                    0624chenhong
oracle正则表达式
                                    
      方括号表达示 
方括号表达式 
描述 
[[:alnum:]] 
字母和数字混合的字符 
[[:alpha:]] 
字母字符 
[[:cntrl:]] 
控制字符 
[[:digit:]] 
数字字符 
[[:graph:]] 
图像字符 
[[:lower:]] 
小写字母字符 
[[:print:]] 
打印字符 
[[:punct：]] 
标点符号字符 
[[:space:]]
    
                                
    • 
                                
  • 2048源码(核心算法有，缺少几个anctionbar，以后补上)
                                    不懂事的小屁孩
2048
                                    
    2048游戏基本上有四部分组成， 
1：主activity，包含游戏块的16个方格，上面统计分数的模块 
2：底下的gridview，监听上下左右的滑动，进行事件处理， 
3：每一个卡片，里面的内容很简单，只有一个text，记录显示的数字 
4：Actionbar，是游戏用重新开始，设置等功能(这个在底下可以下载的代码里面还没有实现) 
 
写代码的流程 
1：设计游戏的布局，基本是两块，上面是分
    
                                
    • 
                                
  • jquery内部链式调用机理
                                    换个号韩国红果果
JavaScriptjquery
                                    
    只需要在调用该对象合适(比如下列的setStyles)的方法后让该方法返回该对象（通过this  因为一旦一个函数称为一个对象方法的话那么在这个方法内部this（结合下面的setStyles）指向这个对象） 

function  create(type){
var element=document.createElement(type);
    //this=element;

    
                                
    • 
                                
  • 你订酒店时的每一次点击 背后都是NoSQL和云计算
                                    蓝儿唯美
NoSQL
                                    
    全球最大的在线旅游公司Expedia旗下的酒店预订公司，它运营着89个网站，跨越68个国家，三年前开始实验公有云，以求让客户在预订网站上查询假期酒店时得到更快的信息获取体验。 
云端本身是用于驱动网站的部分小功能的，如搜索框的自动推荐功能，还能保证处理Hotels.com服务的季节性需求高峰整体储能。 
Hotels.com的首席技术官Thierry Bedos上个月在伦敦参加“2015 Clou
    
                                
    • 
                                
  • java笔记1
                                    a-john
java
                                    
    1，面向对象程序设计（Object-oriented Propramming，OOP）：java就是一种面向对象程序设计。 
2，对象：我们将问题空间中的元素及其在解空间中的表示称为“对象”。简单来说，对象是某个类型的实例。比如狗是一个类型，哈士奇可以是狗的一个实例，也就是对象。 
3，面向对象程序设计方式的特性： 
    3.1 万物皆为对象。 
   
    
                                
    • 
                                
  • C语言 sizeof和strlen之间的那些事 C/C++软件开发求职面试题 必备考点（一）
                                    aijuans
C/C++求职面试必备考点
                                    
            找工作在即，以后决定每天至少写一个知识点，主要是记录，逼迫自己动手、总结加深印象。当然如果能有一言半语让他人收益，后学幸运之至也。如有错误，还希望大家帮忙指出来。感激不尽。 
       后学保证每个写出来的结果都是自己在电脑上亲自跑过的，咱人笨，以前学的也半吊子。很多时候只能靠运行出来的结果再反过来
    
                                
    • 
                                
  • 程序员写代码时就不要管需求了吗？
                                    asia007
程序员不能一味跟需求走
                                    
          编程也有2年了，刚开始不懂的什么都跟需求走，需求是怎样就用代码实现就行，也不管这个需求是否合理，是否为较好的用户体验。当然刚开始编程都会这样，但是如果有了2年以上的工作经验的程序员只知道一味写代码，而不在写的过程中思考一下这个需求是否合理，那么，我想这个程序员就只能一辈写敲敲代码了。 
      我的技术不是很好，但是就不代
    
                                
    • 
                                
  • Activity的四种启动模式
                                    百合不是茶
android栈模式启动Activity的标准模式启动栈顶模式启动单例模式启动
                                    
    android界面的操作就是很多个activity之间的切换,启动模式决定启动的activity的生命周期 ; 
  
启动模式xml中配置 
    <activity android:name=".MainActivity" android:launchMode="standard&quo
    
                                
    • 
                                
  • Spring中@Autowired标签与@Resource标签的区别
                                    bijian1013
javaspring@Resource@Autowired@Qualifier
                                    
    Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，如：@Resource、 @PostConstruct及@PreDestroy。 
  
1. @Autowired    @Autowired是Spring 提供的，需导入    Package:org.springframewo
    
                                
    • 
                                
  • Changes Between SOAP 1.1 and SOAP 1.2
                                    sunjing
ChangesEnableSOAP 1.1SOAP 1.2
                                    
    JAX-WS 
SOAP Version 1.2 Part 0: Primer (Second Edition) 
SOAP Version 1.2 Part 1: Messaging Framework (Second Edition) 
SOAP Version 1.2 Part 2: Adjuncts (Second Edition) 
  
Which style of WSDL
    
                                
    • 
                                
  • 【Hadoop二】Hadoop常用命令
                                    bit1129
hadoop
                                    
    以Hadoop运行Hadoop自带的wordcount为例， 
  
hadoop脚本位于/home/hadoop/hadoop-2.5.2/bin/hadoop，需要说明的是，这些命令的使用必须在Hadoop已经运行的情况下才能执行 
  Hadoop HDFS相关命令 
 
  hadoop fs -ls 
 
 列出HDFS文件系统的第一级文件和第一级
    
                                
    • 
                                
  • java异常处理（初级）
                                    白糖_
javaDAOspring虚拟机Ajax
                                    
    从学习到现在从事java开发一年多了，个人觉得对java只了解皮毛，很多东西都是用到再去慢慢学习，编程真的是一项艺术，要完成一段好的代码，需要懂得很多。 
最近项目经理让我负责一个组件开发，框架都由自己搭建，最让我头疼的是异常处理，我看了一些网上的源码，发现他们对异常的处理不是很重视，研究了很久都没有找到很好的解决方案。后来有幸看到一个200W美元的项目部分源码，通过他们对异常处理的解决方案，我终
    
                                
    • 
                                
  • 记录整理-工作问题
                                    braveCS
工作
                                    
    1）那位同学还是CSV文件默认Excel打开看不到全部结果。以为是没写进去。同学甲说文件应该不分大小。后来log一下原来是有写进去。只是Excel有行数限制。那位同学进步好快啊。 
2）今天同学说写文件的时候提示jvm的内存溢出。我马上反应说那就改一下jvm的内存大小。同学说改用分批处理了。果然想问题还是有局限性。改jvm内存大小只能暂时地解决问题，以后要是写更大的文件还是得改内存。想问题要长远啊
    
                                
    • 
                                
  • org.apache.tools.zip实现文件的压缩和解压，支持中文
                                    bylijinnan
apache
                                    
    刚开始用java.util.Zip，发现不支持中文（网上有修改的方法，但比较麻烦） 
后改用org.apache.tools.zip 
org.apache.tools.zip的使用网上有更简单的例子 
下面的程序根据实际需求，实现了压缩指定目录下指定文件的方法 
 



import java.io.BufferedReader;
import java.io.BufferedWrit
    
                                
    • 
                                
  • 读书笔记-4
                                    chengxuyuancsdn
读书笔记
                                    
    1、JSTL 核心标签库标签 
2、避免SQL注入 
3、字符串逆转方法 
4、字符串比较compareTo 
5、字符串替换replace 
6、分拆字符串 
 
 
1、JSTL 核心标签库标签共有13个，
学习资料：http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html
功能上分为4类：
(1)表达式控制标签：out
    
                                
    • 
                                
  • [物理与电子]半导体教材的一个小问题
                                    comsci
问题
                                    
     
 
      各种模拟电子和数字电子教材中都有这个词汇-空穴 
 
      书中对这个词汇的解释是; 当电子脱离共价键的束缚成为自由电子之后,共价键中就留下一个空位,这个空位叫做空穴 
 
      我现在回过头翻大学时候的教材,觉得这个
    
                                
    • 
                                
  • Flashback Database --闪回数据库
                                    daizj
oracle闪回数据库
                                    
    Flashback 技术是以Undo segment中的内容为基础的， 因此受限于UNDO_RETENTON参数。要使用flashback 的特性，必须启用自动撤销管理表空间。 
在Oracle 10g中， Flash back家族分为以下成员： Flashback Database， Flashback Drop，Flashback Query(分Flashback Query,Flashbac
    
                                
    • 
                                
  • 简单排序:插入排序
                                    dieslrae
插入排序
                                    
    
    public void insertSort(int[] array){
        int temp;
        
        for(int i=1;i<array.length;i++){
            temp = array[i];
            
            for(int k=i-1;k>=0;k--)
    
                                
    • 
                                
  • C语言学习六指针小示例、一维数组名含义，定义一个函数输出数组的内容
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int main(void)
{
	int * p; //等价于 int *p 也等价于 int* p;
	int i = 5;
	char ch = 'A';

	//p = 5;	//error
	//p = &ch;	//error
	//p = ch;	//error

	p = &i;		// 
    
                                
    • 
                                
  • centos下php redis扩展的安装配置3种方法
                                    dcj3sjt126com
redis
                                    
    方法一 
1.下载php redis扩展包     代码如下 复制代码    
#wget http://redis.googlecode.com/files/redis-2.4.4.tar.gz     
2 tar -zxvf 解压压缩包，cd /扩展包 （进入扩展包然后 运行phpize 一下是我环境中phpize的目录，/usr/local/php/bin/phpize (一定要
    
                                
    • 
                                
  • 线程池(Executors)
                                    shuizhaosi888
线程池
                                    
    在java类库中，任务执行的主要抽象不是Thread，而是Executor，将任务的提交过程和执行过程解耦 
	public interface Executor {

	    void execute(Runnable command);
	}
 
  
public class RunMain implements Executor{

	@Override
	pub
    
                                
    • 
                                
  • openstack 快速安装笔记
                                    haoningabc
openstack
                                    
    前提是要配置好yum源 
版本icehouse，操作系统redhat6.5 
最简化安装，不要cinder和swift 
三个节点 
172 control节点keystone glance horizon 
173 compute节点nova 
173 network节点neutron 
 

control
/etc/sysctl.conf

net.ipv4.ip_forward =
    
                                
    • 
                                
  • 从c面向对象的实现理解c++的对象（二）
                                    jimmee
C++面向对象虚函数
                                    
    1. 类就可以看作一个struct，类的方法，可以理解为通过函数指针的方式实现的，类对象分配内存时，只分配成员变量的，函数指针并不需要分配额外的内存保存地址。 
2. c++中类的构造函数，就是进行内存分配(malloc)，调用构造函数 
3. c++中类的析构函数，就时回收内存(free) 
4. c++是基于栈和全局数据分配内存的，如果是一个方法内创建的对象，就直接在栈上分配内存了。 
专门在
    
                                
    • 
                                
  • 如何让那个一个div可以拖动
                                    lingfeng520240
html
                                    
    
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml
    
                                
    • 
                                
  • 第10章 高级事件（中）
                                    onestopweb
事件
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • 计算两个经纬度之间的距离
                                    roadrunners
计算纬度LBS经度距离
                                    
    要解决这个问题的时候，到网上查了很多方案，最后计算出来的都与百度计算出来的有出入。下面这个公式计算出来的距离和百度计算出来的距离是一致的。 
	/**
	 * 
	 * @param longitudeA
	 *            经度A点
	 * @param latitudeA
	 *            纬度A点
	 * @param longitudeB
	 *    
    
                                
    • 
                                
  • 最具争议的10个Java话题
                                    tomcat_oracle
java
                                    
    1、Java8已经到来。什么！？ Java8 支持lambda。哇哦，RIP Scala！   　　随着Java8 的发布，出现很多关于新发布的Java8是否有潜力干掉Scala的争论，最终的结论是远远没有那么简单。Java8可能已经在Scala的lambda的包围中突围，但Java并非是函数式编程王位的真正觊觎者。   　 
　2、Java 9 即将到来   　　 
Oracle早在8月份就发布
    
                                
    • 
                                
  • zoj 3826 Hierarchical Notation(模拟)
                                    阿尔萨斯
rar
                                    
     题目链接：zoj 3826 Hierarchical Notation 
 题目大意：给定一些结构体，结构体有value值和key值，Q次询问，输出每个key值对应的value值。 
 解题思路：思路很简单，写个类词法的递归函数，每次将key值映射成一个hash值，用map映射每个key的value起始终止位置，预处理完了查询就很简单了。 这题是最后10分钟出的，因为没有考虑value为{}的情
    
                                
    •