Java中String、Integer常量池

迈不过友情╰ 2022-05-14 04:22 234阅读 0赞

## Integer常量池        ##

当我们创建两个Integer对象的时候，有可能会出现它们指向的内存地址一致的情况，下面就来详细的讲一下什么时候会出现这个情况。首先来看一下程序实例：

public static void main(String[] args) {
    
        Integer aInt = 1;
        Integer bInt = 1;
        System.out.print("1.");
        System.out.println(aInt == bInt);
    
        Integer cInt = 127;
        Integer dInt = 127;
        System.out.print("2.");
        System.out.println(cInt == dInt);
    
        Integer eInt = 128;
        Integer fInt = 128;
        System.out.print("3.");
        System.out.println(eInt == fInt);
    
        Integer gInt = new Integer(1);
        Integer hInt = new Integer(1);
        System.out.print("4.");
        System.out.println(gInt == hInt);
    
        Integer iInt = new Integer(127);
        Integer jInt = new Integer(127);
        System.out.print("5.");
        System.out.println(iInt == jInt);
    
    }

运行结果：

1.true
    2.true
    3.false
    4.false
    5.false

我们先把上面的源代码反编译一下，好做分析，下面是反编译的结果：

public static void main(String[] paramArrayOfString)
    {
        Integer localInteger1 = Integer.valueOf(1);
        Integer localInteger2 = Integer.valueOf(1);
        System.out.print("1.");
        System.out.println(localInteger1 == localInteger2);
    
        Integer localInteger3 = Integer.valueOf(127);
        Integer localInteger4 = Integer.valueOf(127);
        System.out.print("2.");
        System.out.println(localInteger3 == localInteger4);
    
        Integer localInteger5 = Integer.valueOf(128);
        Integer localInteger6 = Integer.valueOf(128);
        System.out.print("3.");
        System.out.println(localInteger5 == localInteger6);
    
        Integer localInteger7 = new Integer(1);
        Integer localInteger8 = new Integer(1);
        System.out.print("4.");
        System.out.println(localInteger7 == localInteger8);
    
        Integer localInteger9 = new Integer(127);
        Integer localInteger10 = new Integer(127);
        System.out.print("5.");
        System.out.println(localInteger9 == localInteger10);
    }

程序分析：

Integer aInt = 1;反编译的出来的结果是：Integer localInteger1 = Integer.valueOf(1);说明我们用字面量创建一个Integer对象的时候调用的是valueOf(int i)方法。下面我们来看一下valueOf(int i)这个方法的源码：

* This method will always cache values in the range -128 to 127,
      * inclusive, and may cache other values outside of this range.
      *
      * @param i an {@code int} value.
      * @return an {@code Integer} instance representing {@code i}.
      * @since 1.5
      */
      public static Integer valueOf(int i) {
      if (i >= IntegerCache.low && i <= IntegerCache.high)
      return IntegerCache.cache[i + (-IntegerCache.low)];
      return new Integer(i);
      }

注释的第一行代码已经说得很清楚了：此方法将始终缓存-128到127范围内的值。所以通过字面量创建-128到127这个范围的Integer时，相同的值的情况下，他们指向的内存地址是相同的，都是从缓存中取的。

我们再来看一下new Integer(int value)；

public Integer(int value) {
      this.value = value;
      }

总结一下：1.通过字面量创建-128到127这个范围的Integer对象时，会直接从缓存中取对象，如果他们的值相同，那么指向的内存地址也会一致。2.如果是直接通过new创建Integer对象 ，无论数值的范围是多少，都会在堆中新建一个对象，它们指向的内存地址都是不一样的。

## String常量池 ##

Java中字符串对象创建有两种形式：字面量形式和创建对象形式

1.字面量形式：String str = “Hello”，简单理解为去字符串常量池中拿对象的引用。

当代码中出现字面量形式创建对象时，JVM首先会对这个字面量常量进行检查，如果字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回，否则新的字符串对象被创建，然后将这个引用放入字符串常量池，并返回该引用。

2.创建对象形式：String str = new String("Hello");简单理解为直接在堆内存空间中创建新的对象。

当代码中出现了new来构造字符串对象的时候，不管字符串常量池中有没有相同内容的对象的引用，首先它都会去创建这个字符串对象，这里字符串对象指的是String对象，String对象存放在堆当中。然后它会去字符串常量池寻找Hello这个字符串，其处理的结果同字面量形式。最终引用执行String对象的引用。

下面看程序实例：

public static void main(String[] args) {
    
        String aStr = "Hello";
        String bStr = "Hello";
        System.out.print("1.");
        System.out.println(aStr == bStr);
        System.out.print("2.");
        System.out.println(aStr == "Hello");
    
        String cStr = new String("Hello");
        String dStr = new String("Hello");
        System.out.print("3.");
        System.out.println(cStr == dStr);
        System.out.print("4.");
        System.out.println(cStr == "Hello");
    
    }

运行结果：

1.true
    2.true
    3.false
    4.false

程序分析：aStr与bStr都是通过字面量形式创建的，都是从字符串常量池拿的引用，所以他们指向同一个内存地址。cStr与dStr都是通过创建对象的形式创建的，都是直接在堆内存中创建新的对象，所以他们指向的不同的内存地址。

Java中不止String与Integer会使用常量池（缓存）策略。包装类中的整形类Byte、Short、Long都会缓存-128到127这个范围中的对象。