String、int、Integer在内存中的表现

最新推荐文章于 2022-04-08 07:30:00 发布

会飞的皮卡丘EI

最新推荐文章于 2022-04-08 07:30:00 发布

阅读量1k

点赞数 1

本文链接：https://blog.csdn.net/H_Q_Li/article/details/105207412

版权

String、int、Integer在内存中的表现

一、String

首先需要知道String的两种创建方式：

String s1 = “hello”; // 直接赋值
String s2 = new String(“hello”); // 通过 new 来创建

观察下面的代码，先猜猜应该输出什么吧？

public class StringTest1 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        String s3 = s1;
        String s4 = new String("hello");
        String s5 = new String("hello");
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s1 == s4);
        System.out.println(s5 == s4);
        System.out.println("====================================");
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println(s1.equals(s4));
        System.out.println(s5.equals(s2));
    }
}

执行结果：

true
true
false
false
====================================
true
true
true
true

想想这是为什莫，为什么 “==” 的时候会出现 false 而equals()的时候，全返回true呢？

首先我们先聊聊“==” 和equals()的区别？

1、先看看“==”

在基本数据类型中使用 “==” 判断的是值相等

在引用类型的时候使用 ‘’‘==’‘ 判断的是地址值是否相等

2、equals()方法：不管基本数据类型还是引用数据类型判断的是值是否相等

知道了上面“==” 和equals()方法的区别后我们在看看上面代码输出结果的原因！

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zfKQ9mY2-1585570236780)(C:\Users\惠秋丽\AppData\Roaming\Typora\typora-user-images\1585141344373.png)]$

具体分析

在执行String s1 = "hello"的时候，JVM首先会检查字符串常量池中是否存在该字符串，如果已经存在，那么就不会在字符串常量池中创建了，直接返回该字符串在常量池中的地址，如果该字符串在字符串常量池中不存在，那么就会在字符串常量池中先创建该字符串的对象，然后再返回。所以在执行String s2 = "hello"的时候，因为字符串常量池中已经存在“hello”了，所以就不会在字符串常量池中创建了，所以s1 和s2 的内存地址都是指向“hello”在字符串常量池的位置。
在执行 String s3 = s1后，s3也指向了s1所指向的地址。
在执行String s4 = new String(“hello”)创建字符串的时候， jvm首先会检查字符串常量池中是否存在 “hello”，如果已经存在，则不会在字符串常量池中创建了，但是如果不存在，那么就会在字符串常量池中创建“hello”，然后还会到堆内存中再创建一份字符串对象，把字符串常量池中的“hello”字符串拷贝到堆内存中的字符串对象，然后返回堆内存中字符串对象在堆内存中的地址

因为equals()比较的是两个对象的内容是否相等（不是地址值）

看看源码：String类对equals()进行了重写
先看看Object类中的equals()方法：

public boolean equals(Object obj) {
    return (this == obj);
}

在看看String类对equals()

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

String类中的equals()方法首先会判断两个对象的地址是否相等，如果相等直接返回true，如果不相等，在判断传过来的对象是否为字符串类型或者是字符串类型的子类，如果是的化，就将连个字符串转换为两个字符数组，一个一个的字符进行比较，如果全都相等，返回true，否则返回false。

所以我们如果判断的是自定义类型的不是String类型的，我们就需要重写hashCode()和equals()方法。

这个具体可以看我之前的博客

扯的有点远了，额，现在，我们已经知道了前面代码执行结果的原因了，那么，看看下面的代码，思考应该输出什么呢？

public class StringTest2 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hel";
        String s3 = "lo";
        String s4 = s2 + s3;
        System.out.println(s1 == s4);
        System.out.println("===================");
        
        String s5 = new String("hello");
        String s6 = s1.intern();
        System.out.println(s1 == s6);
        System.out.println(s5 == s6);
        System.out.println(s4 .equals( s5));
    }
}

执行的结果：

false
===================
true
false
true

是不是和想的结果不太一样呀？这是为社么呢？下面我们来看看原因？

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-odNLDSaX-1585570236785)(C:\Users\惠秋丽\AppData\Roaming\Typora\typora-user-images\1585145471501.png)]$

详细的看看上面的过程：

在执行String s1 = "hello"的时候，JVM首先会检查字符串常量池中是否存在该字符串，如果已经存在，那么就不会在字符串常量池中创建了，直接返回该字符串在常量池中的地址，如果该字符串在字符串常量池中不存在，那么就会在字符串常量池中先创建该字符串的对象，然后再返回。
在执行String s2 = “hel” 和String s3 = "lo"的时候，JVM…(和上面所描述的一样)
在执行String s4 = s2 + s3的时候，因为变量相加的操作编译器不能优化成常量值，所以相加的时候相当于new String()对象，所以s4 != s1,那么大家肯定很想看看s5,equals(s4)返回什么？答案是true
s1.intern()方法的时候会返回”hello”，但是这个方法会首先检查字符串池中是否有”hello”这个字符串，如果存在则返回这个字符串的引用，否则就将这个字符串添加到字符串池中，然会返回这个字符串的引用。（后面还会详细介绍）

看看下面这个代码：

 public void test1(){
        String s1 = "hello";
        String s2 = "hel";
        String s3 = "lo";
        String s4 = s2 + s3;
        System.out.println(s1 == s4);
    }
    public void test2(){
        String s1 = "hello";
        String s2 = "hel"+"lo";
        System.out.println(s1 == s2);
    }

运行结果：

false
true

为什么呢？

test1()方法的原因上面已经介绍过了，因为变量相加的操作编译器不能优化成常量值，所以相加的时候相当于new String()对象

test2()执行会输出true，因为 JVM在编译期间会进行优化：s2为字面量拼接的字符串"hello"，存在常量池

我们下面来详细看看intern方法：

调用intern()方法时，如果池中已经包含与equels(Object)方法确定的，相当于此String对象的字符串，则返回来自池的字符串。否则此String对象将添加到池中，并且返回此String对象的引用。

从上面的介绍可以看出，对于任何两个字符串s和t，s.intern() == t.intern()是true，则s.equals(t)返回的为true

看看下面这段代码：

public void test4(){// 测试通过
    String s1 = "hello";
    String s2 = new String("hello");
    System.out.println(s1 == s2.intern());
}

猜猜结果：

true

为什么会返回true？？？因为再执行第一条语句String s1 = "hello"的时候，会在常量池中创建hello，再执行String s2 = new String("hello")会再堆中创建对象，它的value会执行常量池中的“hello”，在执行s2 = intren的时候，因为常量池中已经存在“hello”了，所以会直接返回常量池中的“hello”，所以执行为true。

再看看下面这两段代码对比一下

public void test1(){//true
    String s = new StringBuilder("计算机").append("软件").toString();
    // s.intern()在字符串常量池生成一个引用，指向s，"计算机软件"这个字符串是s
   	System.out.println(s.intern() == "计算机软件");
    System.out.println(s.intern() == s);
    System.out.println(s == "计算机软件");
}
public void test2(){//false
    String s = new StringBuilder("计算机").append("软件").toString();
    // 先执行"计算机软件"，会字符串常量池生成一个字符串对象，之后intern返回是字符串对象的引用
    System.out.println("计算机软件" == s.intern());//true
    System.out.println(s.intern() == s);//false
    System.out.println(s == "计算机软件");// false
}

为什么会这个样子呢？

两段代码再执行完第一句后，都会再常量池中创建两个对象"计算机"和“软件”，在执行test1()中的s.intern()时，首先会在常量池中找是否存在“计算机软件”，没有找到，这个时候就会在池中创建“计算机软件”（其实就是字符串常量池生成一个引用，指向堆中生成的对象），当执行到 “==” 后面的“计算机软件”的时候，常量池中已经存在这个对象了，就会直接返回，所以返回为true，s.intern()就是指向的堆中的“计算机软件”,s也是指向的“计算机软件”对象，所以相等。

在test2()方法中，在执行“计算机软件”时，这个时候常量池中还不存在“计算机软件”，所以就会在常量池中先创建“计算机软件”这个对象，在执行s.intern的时候，直接在常量池中取，所以相等，s.intern()是从常量池中的对象，s是指向堆中的“计算机软件”，所以不相等，s==“计算机软件”也是不相等的，s是堆中的对象，“计算机软件”是常量池中的对象。

下面这个是一个特别特殊的情况

public void test1(){
    String s = new StringBuilder("ja").append("va").toString();
    System.out.println(s.intern() == s);

}
public void test2(){
    String s = new StringBuilder("计算机").append("软件").toString();
    // s.intern()在字符串常量池生成一个引用，指向s，"计算机软件"这个字符串是s
    System.out.println(s.intern() == s);
}

执行结果

false
true

原因

JVM 在初始化，会默认加载一些资源，这些资源中包含一些字符串，如“Java”，会加载到常量池中。

s.intern()会返回常量池中的字符串对象，s为堆中的new String(“java”);

二、int和Integer与内存

public class IntTest {
    public static void main(String[] args) {
        int i1 = 10;
        int i2 = 128;
        Integer i3 = 10;
        Integer i4 = 128;
        Integer i5 = new Integer(10);
    }
}

在内存中的表现：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LiTLIt62-1585570236787)(C:\Users\惠秋丽\AppData\Roaming\Typora\typora-user-images\1585146560269.png)]$

为何？为何会这样？原因如下

int 类型赋一个整数类型，不管大小，都是在常量池中查找，如果有，返回引用，如果没有，在常量池中先创建，然后再返回引用。
Integer类型赋一个整数值，-128~127范围内都是先在常量池中查找，如果有，直接返回这个引用，如果没有，在常量池中先创建，然后再返回引用。在这个范围之外，则在堆中创建一个Integer对象，对象的value值指向常量池中的常量。
Integer和int类型比较，会将Integer类型进行自动拆箱，实际上是Integer中的value属性和int比较，所以不管是否在-128~127范围内，只要值相等就相等

public class IntTest {
    public static void main(String[] args) {
        int i1 = 10;
        Integer i2 = 128;
        Integer i3 = 10;
        System.out.println(i2==i4);// true
        System.out.println(i2==128);// true
    }
}

Integer和Integer比较，要看这两个Integer是指向的常量池的对象还是堆中的对象。所以只要是有一个通过new Integer()的方式赋值的，那就肯定不相等，而如果都是使用常量赋值的，如Integer i = 10，因为在-128~127范围内，都是指向常量池对象，所以相等，如果超出范围赋值，就不想等。

public class IntTest {
    public static void main(String[] args) {
        Integer i1 = 10;
        Integer i11 = 10;
        Integer i2 = 128;
        Integer i21 = 128;
        Integer i3 = new Integer(10);
        Integer i4 = new Integer(128);
        System.out.println(i1 == i11); 
        System.out.println(i2 == i21); 
        System.out.println("==========================="); 
        System.out.println(i1 == i3); 
        System.out.println(i2 == i4); 
    }
}

运行结果：

true
false
===========================
false
false

根据上面第4条很容易的出结论。

三、总结

String

采用直接赋值的方法就是在常量池中；采用new String()的方式，就是在堆中，value指向常量池

int

不管int值大小，全都是在线程池中。

Integer

直接赋值的时候：赋的这个值在-128_{127之间，则在常量池中；没在这个范围之间则在堆中。和int类型比较是否相等的时候，因为Integer会自动拆箱，所以相当于比较的是里面的值（不管是否在-128}127的范围内，都是这种方式进行比较的）。

new Integer()的时候：肯定在堆中，value指向常量池中的值，判断是否相等的时候肯定不相等，只要有一个是采用这种方式，就可定不线程，因为比较的是引用呀！！！

会飞的皮卡丘EI

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
String、int、Integer在内存中的表现

String、int、Integer在内存中的表现一、String首先需要知道String的两种创建方式：String s1 = “hello”; // 直接赋值String s2 = new String(“hello”); // 通过 new 来创建观察下面的代码，先猜猜应该输出什么吧？public class StringTest1 { public stat...
复制链接

扫一扫