自动装箱和拆箱

装箱就是自动将基本数据类型转换为包装器类型(int–>Integer);调用方法:Integer的valueOf(int) 方法

拆箱就是自动将包装器类型转换为基本数据类型(Integer–>int);调用方法:Integer的intValue方法

在Java SE5之前，如果要生成一个数值为10的Integer对象，必须这样进行:

Integer i = new Integer(10)

而在从Java SE5开始就提供了自动装箱的特性，如果要生成一个数值为10的Integer对象，只需要这样就可以了:

Integer i = 10;

面试题1

public class Main{
	public static void main(String[] args){
		Integer i1 = 100;
		Integer i2 = 100;
		Integer i3 = 200;
		Integer i4 = 200;
		
		System.out.println(i1 == i2);
		System.out.println(i3 == i4); 
	}
}

运行结果

true
false

为什么会出现这样的结果?

输出结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对象。

此时只需一看源码便知究竟，下面这段代码是Integer的valueOf方法的具体实现:

public static Integer valueOf(int i){
  if(i >= -128 && i <= IntegerCache.high){
    return IntegerCache.cache[i + 128];
  }else {
    return new Integer(i)
  }
}

private static class IntegerCache{
  static final int high;
  static final Integer cache[];
  
  static{
    final int low = -128;
    
    // high value may be configured by property
    // high 可以按照属性来配置
    int h = 127;
    if(integerCacheHighPropValue != null){
      // Use Long.decode here to avoid invoking methods that
      // 在此处使用 Long.decode 以避免调用以下方法
      // require Integer's autoboxing cache to be initialized
      // 需要初始化整数的自动装箱缓存
      int i = Long.decode(integerCacheHighPropValue).intValue();
      i = Math.max(i, 127);
      // Maximum array size is Integer.MAX_VALUE
      // 最大数组大小为 Integer.MAX_VALUE
      h = Math.min(i, Integer.MAX_VALUE - -low);
    }
    high = h;
    
    cache = new Integer[(high - low) + 1];
    int j = low;
    for(int k = 0; k < cache.length; k++){
      cache[k] = new Integer(j++);
    }
  }
  private IntegerCache(){}
}

结论：

从这2段代码可以看出，在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用;否则创建一个新的Integer对象。

上面的代码中i1和i2的数值为100，因此会直接从cache中取已经存在的对象，所以i1和i2指向的是同一个对象，而i3和i4则是分别指向不同的对象。

面试题2

public class Main {
    public static void main(String[] args) {
        Double i1 = 100.0;
        Double i2 = 100.0;
        Double i3 = 200.0;
        Double i4 = 200.0;
        System.out.println(i1==i2); // false
        System.out.println(i3==i4); // false
    }
}

运行结果

false
false

原因: 在某个范围内的整型数值的个数是有限的，而浮点数却不是。

二分查找

题目：搜索二维矩阵

难度：🌟🌟🌟

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/search-a-2d-matrix-ii

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：

每行的元素从左到右升序排列。
每列的元素从上到下升序排列。

输入：matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
输出：true

1	4	7	11	15
2	5	8	12	19
3	6	9	16	22
10	13	14	17	24
18	21	23	26	28

请先思考！！！！

｜｜｜｜｜｜｜｜｜｜｜

答答答答答答答答答答答

案案案案案案案案案案案

往往往往往往往往往往往

下下下下下下下下下下下

翻翻翻翻翻翻翻翻翻翻翻

｜｜｜｜｜｜｜｜｜｜｜

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        boolean flag = false;
        for(int i = 0 ; i < matrix.length ; i++){
            int l = 0;
            int r = matrix[i].length - 1;
            while(l <= r){
                int middle = (l + r) >> 1;
                if(target == matrix[i][middle]){
                    flag = true;
                }
                if(target > matrix[i][middle]){
                    l = middle + 1;
                }else {
                    r = middle - 1;
                }
            }
        }

        return flag;
    }
}

题解：

记得老师说过，二维数组就是多个一维数组组成的，所以在第一层for循环中就相当于最简单的二分查找啦

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int l = matrix.length;
        int n = matrix[0].length;
        int a = 0;
        int b = n - 1;
        boolean flag = false;
        while(a < l && b >= 0){
            if(matrix[a][b] == target){
                flag = true;
            }
            if(matrix[a][b] > target){
                b--;
            }else {
                a++;
            }
        }
        return flag;
    }
}