ALERT

1.在一个方法里调同类的另一个transaction方法，transaction不生效；

➡️ Spring transaction

2.hashmap不要用对象作为map

https://srvaroa.github.io/jvm/java/openjdk/biased-locking/2017/01/30/hashCode.html https://www.jianshu.com/p/be943b4958f4 https://www.cnblogs.com/0201zcr/p/4810813.html?tvd

3.BigDecimal

初始化 new BigDecimal vs BigDecimal.valueOf

BigDecimal - to use new or valueOf

4.交换2个数

使用这种方法时，一定要保证`i != j`，否则会导致`nums[i]`清0

public void swap(int[] nums, int i, int j) {
    nums[i] = nums[i] ^ nums[j];
    nums[j] = nums[i] ^ nums[j];
    nums[i] = nums[i] ^ nums[j];
}

这种方法没有意义，函数里改了值返回后不影响原函数。

public void swap(int a, int b) {
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
}

这样 swap(a, a); 呢？按结果推断，应该是a传进不同的形参里，复制到2个不同的地方去了，应该也是这样，因为java对于int这种基本类型不像普通对象那样可以不同引用指向同一对象。

public static void main(String[] args) {
    int a = 8, b = 6;
    swap(a, a);
    System.out.println(a); // 8
    System.out.println(b); // 6

}

public static void swap(int a, int b) {
    System.out.println(a); // 8
    System.out.println(b); // 8
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
    System.out.println(a); // 8
    System.out.println(b); // 8
}

5.求2个数平均数

为什么不是 (l + r) / 2 而是 l + (r - l) / 2，因为这样可以防止溢出。

如果都是正数的话 l + (r - l) / 2可以，一正一负还是溢出。

private void mergeSort(int[] nums, int l, int r) {
    if (l >= r) return;
    int mid = l + (r - l) / 2;
    mergeSort(nums, l, mid);
    mergeSort(nums, mid + 1, r);
    merge(nums, l, r);
}

https://www.geeksforgeeks.org/compute-average-two-numbers-without-overflow/

static int compute_average(int a, int b) 
{ 
    return (a / 2) + (b / 2) + 
           ((a % 2 + b % 2) / 2); 
} 

https://stackoverflow.com/a/3816480/5646921

average = (a>>1) + (b>>1) + (a & b & 1)

average = a/2 + b/2 + (a%2) * (b%2)

6.finally和try里return的执行顺序

https://hollischuang.github.io/toBeTopJavaer/#/basics/java-basic/order-about-finllly-return

即使try里return了，finally里面的代码还是会执行

try() ⾥⾯有⼀个return语句， 那么后⾯的finally{}⾥⾯的code会不会被执⾏， 什么时候执⾏， 是在return前还是return后?

如果try中有return语句， 那么finally中的代码还是会执⾏。因为return表⽰的是要整个⽅法体返回， 所以，finally中的语句会在return之前执⾏。

但是return前执行的finally块内，对数据的修改效果对于引用类型和值类型会不同

// 测试 修改值类型
static int f() {
    int ret = 0;
    try {
        return ret;  // 返回 0，finally内的修改效果不起作用
    } finally {
        ret++;
        System.out.println("finally执行");
    }
}

// 测试 修改引用类型
static int[] f2(){
    int[] ret = new int[]{0};
    try {
        return ret;  // 返回 [1]，finally内的修改效果起了作用
    } finally {
        ret[0]++;
        System.out.println("finally执行");
    }
}