深入了解Java开发之Integer和String

转载

黑板报呀 2021-07-12 14:20:57

文章标签 Java 文章分类 JavaScript 前端开发

前言

对Java开发的知识点进行深入的学习，并打算做成系列，先从基础常用的重点(面试点)知识开始，后续会陆续扩展，加油！

涉及到底层的可能代码块会多点，但要学习底层不看代码看啥？代码说明一切！！！放心，基本上每句代码都会写上注释。若有不对或侵权行为请联系指出！

int相关

问题

声明一个int类型的时候可以使用int、Integer、new Integer，那它们的底层原理是怎么样的呢？(涉及到存储的内存和Integer的缓存方面)

下面是一个有意思的现象，可以思考一下

Integer a = new Integer(100);int b = 100;System.out.println(a == b); // 结果为 true// 这里是java的自动拆装箱，会把包装类Integer拆成int进行比较。
Integer a1 = new Integer(100);Integer b1 = 100;System.out.println(a1 == b1); // 猜一下？结果为false// 为什么呢？要先明白Integer b1 = 100其实是调用了Integer类静态的valueOf方法，咱们

先看看它的实现

Integer.valueOf实现    public static Integer valueOf(int i) {        if (i >= IntegerCache.low && i <= IntegerCache.high)            // Cache！缓存！用了缓存            return IntegerCache.cache[i + (-IntegerCache.low)];        return new Integer(i);    }// 看代码，这里使用到了缓存(值存储在内存中，能够快速的读取)// ------------ 一条有灵魂的分割线 ------------// 咱们就直接看IntegerCache（是Integer的一个内部类），看看它是个啥东东private static class IntegerCache {    static final int low = -128;    static final int high;    static final Integer cache[];
    static {        // 事先声明一个默认的值        int h = 127;        // 读取配置的属性值        String integerCacheHighPropValue = sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");        if (integerCacheHighPropValue != null) {            try {                // 下面三句代码是为了取得high值                 // 若读取的值少于127，就取127；                // 若读取值超过最大允许值，就取Integer.MAX_VALUE - (-low) -1 (为了限制cache[]的长度不超过Integer.MAX_VALUE)                int i = parseInt(integerCacheHighPropValue);                i = Math.max(i, 127);                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);// 2^31 - 128 - 1             } catch( NumberFormatException nfe) {                // 发生异常无操作            }        }        high = h;
        cache = new Integer[(high - low) + 1];// 长度要求不超过Integer.MAX_VALUE        int j = low;        for(int k = 0; k < cache.length; k++)             cache[k] = new Integer(j++);// 从最低值开始缓存到cache长度大小的值
        // range [-128, 127] must be interned (JLS7 5.1.7)        assert IntegerCache.high >= 127; // 断言，必须大于等于127}

复制代码

上面我们基本讲明了底层了，就是说，Integer会自动缓存[-128,127]的值，若直接用Integer声明的并在这个范围的将会指向于常量池中。

接下来回顾上面的以及还有几个对比也是要注意一下的，通过原理咱们可以分析出来是true还是false

Integer a1 = new Integer(100);Integer b1 = 100;System.out.println(a1 == b1); //false, 一个在常量池，一个是new出来的(java堆中)Integer a2 = 100;Integer b2 = 100;System.out.println(a2 == b2); //true, 都是缓存在常量池中Integer a3 = 128;Integer b3 = 128;System.out.println(a3 == b3); //false，这里是new出两个对象，故为false

总结

使用==对比的时候要注意，区分是int、Integer、new Integer。

若是和int对比，不管是常量池还是堆的都会拆分成int，得到为true。

若是和Integer对比，则要注意是否在缓存的范围之内即可。

String相关

问题

为什么说String是不可修改的？为什么要这样设置
String能够改变吗？(违反语言设计原理的，考虑使用反射)
它的最大最小容量是多少？(待定)
为啥StringBuilder适合单线程？StringBuffer适合多线程？

解惑

第一问

为什么说String是不可修改的？为什么要这样设置？

直接查看String的源码就知道，其实底层是一个private final char value[]; ，使用private final修饰，使用private说明只能是内部调用，使用final说明value指向不可变。
在Java中，String是非常频繁使用的，若不设计成不可变对象，将会大量的增删改查，每次jvm都要确定是否安全，故设计成不可变的，使用hash来保障每次的都是唯一的。

第二问

String能够改变吗？

对这种违反语言设计原则的问题，可以考虑使用反射，这里咱们就用到反射去实现

public static void main(String[] args) {    String str = "老王";    System.out.println(str);    try {        // 获得String类的value属性        Field value = String.class.getDeclaredField("value");        // setAccessible(true)表示取消Java语言访问检查，将提高性能以及能对private的进行访问        value.setAccessible(true);        char[] charValue;        charValue = (char[]) value.get(str);        charValue[1] = '李';        System.out.println(str);    } catch (NoSuchFieldException | IllegalAccessException e) {        e.printStackTrace();    }}
复制代码

第三问

大致记得是int的最大值，后续补充

第四问

为啥StringBuilder适合单线程？StringBuffer适合多线程？

看看StringBuffer的源码，就可以知道，基本上继承AbstractStringBuilder的方法(append、delete、insert等)都进行了加锁（synchronized )，所以StringBuffer适合多线程。
StringBuilder和StringBuffer都继承了AbstractStringBuilder，AbstractStringBuilder提供了许多常用的方法(append、delete、insert等),咱们看看具体代码
```
// 这个是StringBuilder的append函数
```

@Overridepublic StringBuilder append(Object obj) {    return append(String.valueOf(obj));}
// 这个是StringBuffer的append函数(加着锁)@Overridepublic synchronized StringBuffer append(Object obj) {    toStringCache = null;    super.append(String.valueOf(obj));    return this;}
// 看了上面两个就知道，主要还是调用了父类的函数：AbstractStringBuilder的append函数public AbstractStringBuilder append(String str) {    // 判断参数是否为空，为空就添加null    if (str == null)        return appendNull();    int len = str.length();    // 这个是为了检查char[] value是否足够长度存储新的字符串，不够将进行扩容    ensureCapacityInternal(count + len);    // 读取得到一个String，刷新当前类的value    str.getChars(0, len, value, count);    // 长度增加(这个操作就不是原子的，故多线程不加锁不安全)    count += len;    return this;}

其他知识点

final意义

final意义：最终的，不可改变的。

修饰变量，为常量,值不可变；　　
修饰对象，值可变,引用不变；　　
修饰方法，方法不可重写；　　
修饰类，无子类，不可以被继承,更不可能被重写。

String类的内存原理

这里涉及到了JVM内存模型基础，栈、堆、运行时常量池。大致来说，

平时运行的函数就是在(虚拟机)栈内的，符合栈的特性，先入后出；
new的类是运行在堆上的，是Java虚拟机所管理的内存中最大一块，用来存放对象的实例；
运行时常量池是在方法区(永久代、元空间)里的，用于存储已被虚拟机加载的类信息、常量、静态变量等数据。

说明：以下几个点和图片皆是引用了参考中的String类型内存原理文章

"双引号"创建

对于：String str = "abc"; 这句话，会不会好奇底层原理？

咱们先进行分析，左边是一个String类声明，右边又没有new关键字，说明是什么？说明不是构造对象，故"abc"，不应该存放在堆上，实际上也是如此。那它在哪？答案是在运行常量池中。

那使用new是怎么样的？

new String()创建

对于：String str = new String("abcd");

咱们还是先分析一波，经过上面也大致猜到是存放在堆上的，那和栈又有什么联系？

直接上图：

可以看出对象确实是存储在堆上，但是底层存储的还是在常量池对应的内容。

+号机制

分两种情况

第一种：

String s = "旭"+"java";
// 编译后的文件是String s = "旭java"

第二种：

//.java文件
String s1 = new String("a");
String s2 = "cd";
String s3 = s1 + s2;
String s4 = s1 + "cd";
String s5 = new String("a") + new String("cd");

//.编译后的文件（.class反编译为.java的显示结果）
String s1 = new String("a");
String s2 = "cd";
String s3 = (new StringBuilder()).append(s1).append(s2).toString();
String s4 = (new StringBuilder()).append(s1).append("cd").toString();
String s5 = (new StringBuilder()).append(new String("a")).append(new String("cd")).toString();
复制代码

由这里可以看出是借助了StringBuilder进行增加，为了减少频繁进行new String()，最后再转回String，(频繁进行new对象是很浪费性能的)

查看toString的源代码可以知道，底层其实是new String(c1,c2,c3); 这的结果是取String，底层是一个copyOfRange()，

将新的数组的地址给到了String类中的value中

，并进行返回

concat方法

作用是合并多个字符串

public String concat(String str) {        // 待新增长度        int otherLen = str.length();        if (otherLen == 0) {            return this;        }        // 原有长度        int len = value.length;    // 输入value数组，以及新的长度，返回一个新数组给我。        char buf[] = Arrays.copyOf(value, len + otherLen);        // 底层是调用了System中的arraycopy，总结将会说到这个函数；这里是进行增加的操作。        str.getChars(buf, len);        return new String(buf, true);    }

可以发现，本质是字符数组的扩容和复制操作，最后新建一个String类对象返回，内存机制与“+”类似，新建的字符串对象实例在堆，但是比 + 操作省去了一个新建对象步骤。

intern方法

就是为了把堆上的和常量池产生关系。

Intern()方法，会将堆中的字符串对象的引用放到常量池，而实例依然在堆中。此时对比两者结果为 true。

直接将常量池中的字符串引用返回，给s4，此时内存有两个“ab”。此时结果为 false。

总结

若想明白String底层，要掌握下面这个函数的作用

// 是在System类中的一个函数，底层是调用了本地的(c、c++等概念)函数
public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);
// 直接总结说明函数作用和参数的意义：1为原数组，2为原数组开始索引位，3为输出的数组，4为输出数组的开始索引位，5是长度；
// 作用就是把原数组索引(参1、2)后面的数值移动到输出数组新索引(参3、4)后面去，参5是长度，控制旧数组索引后几位移动。

// 另外还有一个是对上面这个函数进一波封装的，位于Arrays类下，作用是输入一个数组，以及新长度，返回一个包含原内容新长度的数组(就是说若要得到一个内容不变，存储空间加大的数组就调用这个方法)

public static char[] copyOf(char[] original, int newLength) {        // 声明一个输出数组，长度使用        char[] copy = new char[newLength];        // 这里就是调用了上面说到的arraycopy        System.arraycopy(original, 0, copy, 0,           Math.min(original.length, newLength));        return copy;    }