Resumen propenso a errores: la persistencia de int y Integer

¿Sueles encontrar este tipo de preguntas al hacer preguntas?

• int i1 = 128;
  Entero i2 = 128;
  Assert.assertTrue (i1 == i2);

Pero ustedes no tienen tan clara la diferencia entre int e Integer
, amigos míos, su bienestar está aquí, describiré la diferencia entre los dos en detalle a continuación:

1. La asignación de int y Integer en la memoria:

• 1. Int type Asignar un valor entero, no importa el tamaño, se busca en el pool de constantes, si lo hay, devuelve la referencia, si no, crea y luego devuelve la referencia.
• 2. Tipo de entero Asigne un valor entero. Los valores en el rango de -128 a 127 se buscan primero para el grupo de constantes; si lo hay, devuelva esta referencia directamente, si no, créelo en el grupo de constantes y luego regrese esta referencia. Fuera del rango, se crea un objeto Integer en el montón y el valor de atributo del objeto apunta a una constante en el grupo de constantes.
• 3. La comparación de tipo Integer e int desempaquetará automáticamente el objeto de tipo Integer, que en realidad es la comparación entre el atributo value en Integer e int, por lo que no importa si está en el rango de -128 a 127, siempre que los valores Son iguales, son iguales.
• 4. La comparación entre Integer y Integer depende de si los dos Integers apuntan a objetos de grupo constante u objetos en el montón. Entonces, siempre que uno sea asignado por new Integer (), definitivamente no es igual. Y si todos se asignan usando constantes, como Integer i = 10; porque en el rango de -128 a 127, todos apuntan a objetos de grupo constante, por lo que son iguales. Si se asignan fuera del rango, no son igual.

2. En el código:

// 基本数据类型==比较都是比较字面量
    @Test
    public void test1_1(){
    
    // 测试通过
        int i1 = 10;
        int i2 = 10;
        Assert.assertTrue(i1 == i2);
    }
    @Test
    public void test1_2(){
    
    // 测试通过
        int i1 = 128;
        int i2 = 128;
        Assert.assertTrue(i1 == i2);
    }
    @Test
    public void test1_3(){
    
    // 测试通过
        int i1 = 128;
        char c = (char) 128;
        Assert.assertTrue(i1 == c);
    }
    @Test
    public void test1_4(){
    
    // 测试通过
        int i1 = 128;
        double d = 128.0;
        Assert.assertTrue(i1 == d);
    }

    // Integer与int比较，都会进行自动拆装箱，实际是Integer中
    // 的value与int进行比较，所以不管大小，只要值相等，这两个变量就相等。
    @Test
    public void test2_1(){
    
    // 测试通过
        int i1 = 10;
        Integer i2 = 10;
        Assert.assertTrue(i1 == i2);
    }
    @Test
    public void test2_2(){
    
    // 测试通过
        int i1 = 128;
        Integer i2 = 128;
        Assert.assertTrue(i1 == i2);
    }

    // Integer与Integer比较，如果都是常量赋值的，那么在-128到127范围内的比较，就是常量池对象的比较，如果在范围外，
    // 就是堆里边对象的比较。
    @Test
    public void test3_1(){
    
    // 测试通过
        Integer i1 = 10;
        Integer i2 = 10;
        Assert.assertTrue(i1 == i2);
    }
    @Test
    public void test3_2(){
    
    // 测试不能通过
        Integer i1 = 128;
        Integer i2 = 128;
        Assert.assertTrue(i1 == i2);
    }

    // Integer与Integer比较，不管大小，如果有一个是new Integer()的方式
    // 创建的，那肯定就不相等。
    @Test
    public void test4_1(){
    
    // 测试不能通过
        Integer i1 = 10;
        Integer i2 = new Integer(10);
        Assert.assertTrue(i1 == i2);
    }
    @Test
    public void test4_2(){
    
    // 测试不能通过
        Integer i1 = 128;
        Integer i2 = new Integer(128);
        Assert.assertTrue(i1 == i2);
    }