小石潭记丶
小石潭记丶

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,开发语言)






    

  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）
华为OD题库
华为od链表java

    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
    

    • 

  • 学习JavaEE的日子 Day32 线程池
A 北枝
学习JavaEE学习java-eejava线程池

    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
    

    • 

  • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？
AaronWang94
shirojavajava安全开发语言

    请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
    

    • 

  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？
大龄下岗程序员
mysqljavamysqlspring

    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
    

    • 

  • 3、JavaWeb-Ajax/Axios-前端工程化-Element
所谓远行Misnearch
#JavaWeb前端ajaxelementuijava前端框架

    P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
    

    • 

  • 枚举使用笔记
万变不离其宗_8
项目笔记笔记

    1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
    

    • 

  • Python dict字符串转json对象，小数精度丢失问题
朝如青丝 暮成雪
jsonpython

    一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
    

    • 

  • java实体中返回前端的double类型四舍五入（格式化）
婲落ヽ紅顏誶
java

    根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
    

    • 

  • Java中HashMap底层数据结构及主要参数?
山间漫步人生路
java数据结构开发语言

    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
    

    • 

  • Java学习笔记01
.wsy.
日常java学习笔记

    1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
    

    • 

  • Java回溯知识点（含面试大厂题和源码）
一成码农
java面试开发语言

    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
    

    • 

  • Azkaban各种类型的Job编写
__元昊__

    一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
    

    • 

  • java基础相关面试题详细总结
。。。。。96
java开发语言

    1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
    

    • 

  • javascript 日期转换为时间戳，时间戳转换为日期的函数
cdcdhj
javascript学习日记javascript开发语言ecmascript

    日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
    

    • 

  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法
杰哥在此
Java系列javajvm算法面试

    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
    

    • 

  • COMP315 JavaScript Cloud Computing for E Commerce
zhuyu0206girl
javascript开发语言ecmascript

    Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
    

    • 

  • JSON与AJAX：网页交互的利器
入冉心
jsonajax前端

    在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
    

    • 

  • 程序员开发技术整理
laizhixue
学习前端框架

    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
    

    • 

  • javascript的数据类型及转换
田小田txt

    一、JavaScript数据类型：共有string，number，boolean，object，function五种数据类型；其中Object，Date，Array为对象型；2个不包含任何值的数据类型：null，undefined。二、Typeof查看数据类型：typeof"John"//返回stringtypeof3.14//返回numbertypeofNaN//返回numbertypeoffa
    

    • 

  • java线程之Lock的使用
dimdark

    目标:大致介绍一下java.util.concurrent.locks包下的类,接口及其常用方法1.Lock接口Lock接口使用Lock接口的最佳模式:publicvoidmethod()throwInterruptedException{try{lock.lock();//lock.lockUninterruptibly();}finally{lock.unlock();}}用户必须手动释放Lo
    

    • 

  • 第六届蓝桥杯大赛软件赛省赛Java 大学C组题解
爱跑步的程序员~
刷题蓝桥杯省赛

    文章目录A隔行变色思路解题方法复杂度CodeB立方尾不变思路解题方法复杂度CodeC无穷分数思路解题方法复杂度CodeD奇妙的数字思路解题方法复杂度CodeE移动距离思路解题方法复杂度CodeF垒骰子思路解题方法复杂度CodeA隔行变色思路这是一个简单的计数问题。我们需要找出21到50之间的奇数数量。奇数行将被染成蓝色，偶数行将被染成白色。解题方法我们可以使用一个for循环从21遍历到50，然后使
    

    • 

  • Java学习笔记04：Java_数组
JasonYangQ
Javajava

    文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
    

    • 

  • 【设计模式】Java 设计模式之桥接模式（Bridge）
新手村长
Java设计模式设计模式java桥接模式

    桥接模式（BridgePattern）是结构型设计模式的一种，它主要解决的是抽象部分与实现部分的解耦问题，使得两者可以独立变化。这种类型的设计模式属于结构型模式，因为该模式涉及如何组合接口和它们的实现。将抽象部分与实现部分分离，使它们都可以独立地变化。一、桥接模式概述桥接模式的主要思想是将抽象与实现进行解耦，使得二者可以独立进行变化。在桥接模式中，抽象部分和实现部分被分离出来，抽象部分定义了一个抽
    

    • 

  • 基于SSM+Vue企业销售培训系统 企业人才培训系统 企业课程培训管理系统 企业文化培训班系统Java
计算机程序老哥

    作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆.png前端页面功能：首页、培训班、在线学习、企业文化、交流论坛、试卷列表、系统公告、留言反馈、个
    

    • 

  • java selenium 元素点击不了
马达马达达
selenium测试工具

    最近做了一个页面爬取，很有意思被机缘巧合下解决了。这个元素很奇怪，用xpath可以定位元素，但是就是click()不了。试过了网上搜的一些办法：//尝试一WebElementa_tag=driver.findElement(By.xpath("xxx"));a_tag.click();//点击不了，卡住//尝试二WebDriverWaitwait=newWebDriverWait(driver,1
    

    • 

  • 【Java初阶（三）】方法的使用
PU-YUHAN
Java从入门到精通java开发语言递归方法

    ❣博主主页:33的博客❣▶文章专栏分类:Java从入门到精通◀我的代码仓库:33的代码仓库目录1.前言2.方法的概念2.1方法定义2.2实参和形参的关系3.方法的重载3.1方法重载的概念4.递归4.1递归的概念4.2递归过程分析4.3递归练习5.总结1.前言在前面的学习中，我们已经学习了Java的部分知识，包括数据类型与变量，运算符，分支与循环以及输入和输出这些基础知识，我们继续对Java的学习进
    

    • 

  • 解析XML文件的几种方式？
人生在勤，不索何获
xml

    在Java中解析XML文件可以通过多种方式完成，其中最常用的有DOM（DocumentObjectModel）、SAX（SimpleAPIforXML）和StAX（StreamingAPIforXML）。每种方式有其特点和适用场景。1.DOM解析DOM解析是一种将整个XML文档加载到内存中，构造成一个树形结构，然后你可以很方便地访问任何数据节点的方法。这种方法适用于需要频繁读写操作的场景。impo
    

    • 

  • javascript实现SM2加密解密
人生在勤，不索何获
javascript前端jquery

    前提JavaWeb环境前端代码window.sm2=function(t){functioni(e){if(r[e])returnr[e].exports;varn=r[e]={i:e,l:!1,exports:{}};returnt[e].call(n.exports,n,n.exports,i),n.l=!0,n.exports}varr={};returni.m=t,i.c=r,i.d=fu
    

    • 

  • Vue：为什么要使用v-cloak
刻刻帝的海角
vue.js前端javascript

    Vue.js是一种流行的JavaScript框架，它使我们能够构建交互性强大的用户界面。在Vue.js中，v-cloak是一个指令，用于解决在页面加载时出现的闪烁问题。本文将介绍如何使用v-cloak及代码来优化Vue.js应用程序的渲染效果。引言当我们使用Vue.js构建应用程序时，有时会遇到一个问题：在页面加载时，由于Vue.js需要一定的时间来解析和渲染模板，会导致页面上显示出未经处理的Mu
    

    • 

  • Github 2024-03-26 开源项目日报 Top10
老孙正经胡说
github开源Github趋势分析开源项目PythonGolang

    根据GithubTrendings的统计，今日(2024-03-26统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下：开发语言项目数量Python项目3TypeScript项目3JupyterNotebook项目2C++项目1GDScript项目1Lua项目1Solidity项目1OpenInterpreter:本地代码运行和自然语言界面创建周期：254天开发语言：Python协议
    

    • 

  • 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为{}的情
    

    •