1、字符串常量java内部加载

image.png

  1. intern()方法：字符串常量池中已经移到java堆中，记录首次出现的实例；返回的引用和有StringBuilder创建的那个字符串实例就是同一个。

  2. 为什么”java”比较是false：因为“java”这个字符串在执行StringBuilder之前就已经出现过了，字符串常量池中已经有它的引用，不符合intern()方法要求“首次遇到”原则。（sun.misc.Version类会在JDK类库的初始化过程中被加载并初始化，而在初始化时需要对静态变量字段根据指定的常量值(ConstantValue)做默认初始化，此时被sun.misc.Version.launcher静态常量字段所引用“java”字符串字面量就被intern到HotSpot VM的字符串常量池—StringTable里了。）

    2、leetcode算法

    两数之和(https://leetcode-cn.com/problems/two-sum/)

  3. 两次for循环O(N)的平方

    1. public static int[] twoSum(int[] nums, int target) {
    2.      //遍历
    3.      for (int i = 0; i < nums.length; i++) {
    4.          int n1=nums[i];
    5.          for (int j = i+1; j < nums.length; j++) {
    6.              int n2=nums[j];
    7.              if(n1+n2==target){
    8.                  return new int[] {i,j};
    9.              }
    10.          }
    11.      }
    12.      return null;
    13.  }

  4. 哈希复杂度O(N)

    1. //哈希
    2.  public static int[] twoSumbest(int[] nums, int target) {
    3.      Map<Integer,Integer> map=new HashMap<>();
    4.      for (int i = 0; i < nums.length; i++) {
    5.          int n=target-nums[i];
    6.          if(map.containsKey(n)){
    7.              return new int[]{map.get(n),i};
    8.          }
    9.          map.put(nums[i],i);
    10.      }
    11.      return null;
    12.  }

    3、可重入锁(又名递归锁)

    是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提，锁对象得是同一对象），不会因为之前已经获取过还没有释放而阻塞。
    java中ReentrantLock和synchronized都是可重入锁，可重入锁的一点是可一定程度上避免死锁。
    可重入锁种类：

  5. 隐式锁（即synchronized关键字使用的锁）默认是可重入锁（同步块、同步方法）

  6. 显式锁（即Lock）也有RenntrantLock这样的可重入锁（同一把锁）

（lock和unlock）由于加锁次数和释放次数不一样，第二个线程始终无法获取到锁，导致一直等待
正常情况，加锁几次就要释放几次。

4、Spring

IOC+AOP+TX（事务）
1、spring的aop顺序

  1. AOP的常用注解

@Before 前置通知：目标方法之前执行
@After 后置通知：目标方法之后执行
@AfterReturning 返回后通知：执行方法
@AfterThrowing 异常通知：出现异常时执行
@Around 环绕 环绕通知：环绕目标方法执行
spring4执行顺序：（springboot1.5.9）
正常执行：@Before（前置通知）@After（后置通知）@AfterReturning（正常返回）
异常执行：@Before（前置通知）@After（后置通知）@AfterThrowing（返回异常）
spring5执行顺序：（springboot2.5.5）
正常执行：@Before（前置通知）@AfterReturning（正常返回）@After（后置通知）
异常执行：@Before（前置通知）@AfterThrowing（返回异常）@After（后置通知）

2、spring的循环依赖

1，循环依赖：多个bean之间相互依赖，形成了一个闭环
通常来说，如果问Spring容器内部如何解决循环依赖，一定是指默认的单例bean，属性互相引用的场景。
1，spring中国的三级缓存