java基础总结（类型、缓存池、string、运算）

冷不防 2022-04-23 11:58 140阅读 0赞

# 一、数据类型 #

## 基本类型 ##

*  byte/8
 *  char/16
 *  short/16
 *  int/32
 *  float/32
 *  long/64
 *  double/64
 *  boolean/~
 *  boolean 只有两个值：true、false，可以使用 1 bit 来存储，但是具体大小没有明确规定。JVM （java虚拟机）会在编译时期将 boolean 类型的数据转换为 int，使用 1 来表示 true，0 表示 false。JVM 并不支持 boolean 数组，而是使用 byte 数组来表示 int 数组来表示。

数据类型：[https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html][https_docs.oracle.com_javase_tutorial_java_nutsandbolts_datatypes.html]

## 包装类型 ##

基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。

** 1）包装类把基本类型数据转换为对象 ,****包装类有何作用**:1、提供了一系列实用的方法；2、集合不允许存放基本数据类型数据，存放数字时，要用包装类型。

**2）包装类的构造方法**

1、所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例

public  Type（type  value）

如：Integer i=new Integer(1);

2、除Character类外，其他包装类可将一个字符串作为参数构造它们的实例

public  Type（String  value）

如：Integer i=new Integer("123");

3、注意事项：

（1）Boolean类构造方法参数为String类型时，若该字符串内容为true(不考虑大小写)，则该Boolean对象表示true，否则表示false。

（2）当Number包装类构造方法参数为String 类型时，字符串不能为null，且该字符串必须可解析为相应的基本数据类型的数据，否则编译通过，运行时NumberFormatException异常。

Integer x = 2;     // 装箱
    int y = x;         // 拆箱

## 缓存池 ##

new Integer(123) 与 Integer.valueOf(123) 的区别在于：

*  new Integer(123) 每次都会新建一个对象；
 *  Integer.valueOf(123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。

Integer x = new Integer(123);
    Integer y = new Integer(123);
    System.out.println(x == y);    // false
    Integer z = Integer.valueOf(123);
    Integer k = Integer.valueOf(123);
    System.out.println(z == k);   // true

valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。

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

在 Java 8 中，Integer 缓存池的大小默认为 -128~127。

static final int low = -128;
 static final int high;
 static final Integer cache[];
 static {
 // high value may be configured by property
 int h = 127;
 String integerCacheHighPropValue =
 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
 if (integerCacheHighPropValue != null) {
 try {
 int i = parseInt(integerCacheHighPropValue);
 i = Math.max(i, 127);
 // Maximum array size is Integer.MAX_VALUE
 h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
 } catch( NumberFormatException nfe) {
 // If the property cannot be parsed into an int, ignore it.
 }
 }
 high = h;
 cache = new Integer[(high - low) + 1];
 int j = low;
 for(int k = 0; k < cache.length; k++)
 cache[k] = new Integer(j++);
 // range [-128, 127] must be interned (JLS7 5.1.7)
 assert IntegerCache.high >= 127;
 }

编译器会在自动装箱过程调用 valueOf() 方法，因此多个 Integer 实例使用自动装箱来创建并且值相同，那么就会引用相同的对象。

Integer m = 123;
    Integer n = 123;
    System.out.println(m == n); // true

基本类型对应的缓冲池如下：

*  boolean values true and false
 *  all byte values
 *  short values between -128 and 127
 *  int values between -128 and 127
 *  char in the range \\u0000 to \\u007F

在使用这些基本类型对应的包装类型时，就可以直接使用缓冲池中的对象。

[深入剖析Java中的装箱和拆箱（缓存池技术）：][Java][https://www.cnblogs.com/Pjson/p/8777940.html][Java]

一.什么是装箱？什么是拆箱？

**　　简单一点说，装箱就是：自动将基本数据类型转换为包装器类型；拆箱就是：自动将包装器类型转换为基本数据类型。**

二.装箱和拆箱是如何实现的

**　　1:反编译class文件：javap -c 类名**

**　　2:装箱过程是通过调用包装器（Integer)的valueOf方法实现的，而拆箱过程是通过调用包装器的 xxxValue方法实现的。（xxx代表对应的基本数据类型）。**

**　　3:****注意，Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。**

**　　　　Double、Float的valueOf方法的实现是类似的。**

三.面试中相关的问题

1:**Integer a=1时发生装箱过程中使用valueOf方法，Integer.valueOf()中有个静态内部类IntegerCache，里面有个常量cache\[\],也就是Integer常量池（其实就是缓存池技术，利用空间换时间的策略，也叫对象池），在常量池（对象池）中Integer已经默认创建了数值【-128-127】的Integer缓存数据。所以使用Integer a=1时，JVM会直接在该在对象池找到该值的引用**。也就是说这种方式声明一个Integer对象时，JVM首先会在Integer对象的缓存池中查找有木有值为1的对象，如果有直接返回该对象的引用；**如果没有，则使用New Integer(在jvm的堆中new一个)**创建一个对象,并返回该对象的引用地址。

**注意：最大值 127 可以通过 JVM 的启动参数 -XX:AutoBoxCacheMax=size 修改**

2：int与Integer比较时，会自动装箱

3:谈谈Integer i = new Integer(xxx)和Integer i =xxx;这两种方式的区别。

当然，这个题目属于比较宽泛类型的。但是要点一定要答上，我总结一下主要有以下这两点区别：

1）第一种方式不会触发自动装箱的过程；而第二种方式会触发；

2）在执行效率和资源占用上的区别。第二种方式的执行效率和资源占用在一般性情况下要优于第一种情况，当值不在（-128-127）之间时（注意这并不是绝对的）。

下表是基本数据类型对应的包装器类型：

<table> 
 <tbody> 
 <tr> 
 <td>int（4字节）</td> 
 <td>Integer</td> 
 </tr> 
 <tr> 
 <td>byte（1字节）</td> 
 <td>Byte</td> 
 </tr> 
 <tr> 
 <td>short（2字节）</td> 
 <td>Short</td> 
 </tr> 
 <tr> 
 <td>long（8字节）</td> 
 <td>Long</td> 
 </tr> 
 <tr> 
 <td>float（4字节）</td> 
 <td>Float</td> 
 </tr> 
 <tr> 
 <td>double（8字节）</td> 
 <td>Double</td> 
 </tr> 
 <tr> 
 <td>char（2字节）</td> 
 <td>Character</td> 
 </tr> 
 <tr> 
 <td>boolean（未定）</td> 
 <td>Boolean</td> 
 </tr> 
 </tbody> 
</table>

在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。其他的也类似，比如Double、Character，不相信的朋友可以自己手动尝试一下。

因此可以用一句话总结装箱和拆箱的实现过程：

装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 xxxValue方法实现的。（xxx代表对应的基本数据类型）。

## 三.面试中相关的问题 ##

虽然大多数人对装箱和拆箱的概念都清楚，但是在面试和笔试中遇到了与装箱和拆箱的问题却不一定会答得上来。下面列举一些常见的与装箱/拆箱有关的面试题。

1;先看一个问题，对于下面定义的四个变量进行==比较：

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 </td> 
 <td> Integer a=1; Integer b=1; Integer c=200; Integer d=200; System.out.println(a==b);//true System.out.println(c==d);//false </td> 
 </tr> 
 </tbody> 
</table>

我们都知道==在JAVA里面是比较对象引用的，如果两个对象引用指向堆中的同一块内存就返回true，否则返回false。根据自动装箱规则我们知道Integer a = 1 <==> Integer a = Integer.valueOf(1);，但是在valueOf方法上，查看源码：

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 </td> 
 <td> public static Integer valueOf(int i) { &nbsp;&nbsp;&nbsp;&nbsp;final int offset = 128; &nbsp;&nbsp;&nbsp;&nbsp;if (i &gt;= -128 &amp;&amp; i &lt;= 127) { // must cache &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return IntegerCache.cache[i + offset]; &nbsp;&nbsp;&nbsp;&nbsp;} &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return new Integer(i); } </td> 
 </tr> 
 </tbody> 
</table>

Integer.valueOf()中有个内部类IntegerCache（类似于一个常量数组，也叫对象池），它维护了一个Integer数组cache，长度为（128+127+1）=256。Integer类中还有一个Static Block(静态块)

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 </td> 
 <td> static { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for(int i = 0; i &lt; cache.length; i++) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;cache[i] = new Integer(i - 128); } </td> 
 </tr> 
 </tbody> 
</table>

从这个静态块可以看出，Integer已经默认创建了数值【-128-127】的Integer缓存数据。所以使用Integer a=1时，JVM会直接在该在对象池找到该值的引用。也就是说这种方式声明一个Integer对象时，JVM首先会在Integer对象的缓存池中查找有木有值为1的对象，如果有直接返回该对象的引用；如果没有，则使用New Integer创建一个对象，并返回该对象的引用地址。因为Java中==比较的是两个对象是否是同一个引用（即比较内存地址），a和b都是引用的同一个对象，所以a==b结果为true；c和d已经超出了缓存的范围，所以重新生成了Integer对象，所以c==d结果为false。

2.下面这段代码的输出结果是什么？

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 </td> 
 <td> <code>public</code>&nbsp;<code>class</code>&nbsp;<code>Main { </code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>public</code>&nbsp;<code>static</code>&nbsp;<code>void</code>&nbsp;<code>main(String[] args) { </code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code>&nbsp; <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>Double i1 =&nbsp;</code><code>100.0</code><code>;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>Double i2 =&nbsp;</code><code>100.0</code><code>;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>Double i3 =&nbsp;</code><code>200.0</code><code>;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>Double i4 =&nbsp;</code><code>200.0</code><code>;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code>&nbsp; <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>System.out.println(i1==i2);</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>System.out.println(i3==i4);</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>}</code> <code>}</code> </td> 
 </tr> 
 </tbody> 
</table>

也许有的朋友会认为跟上面一道题目的输出结果相同，但是事实上却不是。实际输出结果为：

![ContractedBlock.gif][] false false

至于具体为什么，读者可以去查看Double类的valueOf的实现。

在这里只解释一下为什么Double类的valueOf方法会采用与Integer类的valueOf方法不同的实现。很简单：在某个范围内的整型数值的个数是有限的，而浮点数却不是。

**下面我们进行一个归类： **  
**Integer派别：Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。 **  
**Double派别：Double、Float的valueOf方法的实现是类似的。每次都返回不同的对象。**

**下面对Integer派别进行一个总结，如下图： **  
![这里写图片描述][20150922153039509]

4.谈谈Integer i = new Integer(xxx)和Integer i =xxx;这两种方式的区别。

当然，这个题目属于比较宽泛类型的。但是要点一定要答上，我总结一下主要有以下这两点区别：

1）第一种方式不会触发自动装箱的过程；而第二种方式会触发；

2）在执行效率和资源占用上的区别。第二种方式的执行效率和资源占用在一般性情况下要优于第一种情况（注意这并不是绝对的）。

# 二、String #

## 概览 ##

String 被声明为 final，因此它不可被继承。

在 Java 8 中，String 内部使用 char 数组存储数据。

public final class String
 implements java.io.Serializable, Comparable<String>, CharSequence {
 /** The value is used for character storage. */
 private final char value[];
 }

在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 `coder` 来标识使用了哪种编码。

public final class String
 implements java.io.Serializable, Comparable<String>, CharSequence {
 /** The value is used for character storage. */
 private final byte[] value;
 
 /** The identifier of the encoding used to encode the bytes in {@code value}. */
 private final byte coder;
 }

value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。

## 不可变的好处 ##

**1. 可以缓存 hash 值**

因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。

**2. String Pool 的需要**

如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。

[![474e5579-38b1-47d2-8f76-a13ae086b039.jpg][]][474e5579-38b1-47d2-8f76-a13ae086b039.jpg 1]

**3. 安全性**

String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 对象的那一方以为现在连接的是其它主机，而实际情况却不一定是。

**4. 线程安全**

String 不可变性天生具备线程安全，可以在多个线程中安全地使用。

[Program Creek : Why String is immutable in Java?：][Program Creek _ Why String is immutable in Java][https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder][https_stackoverflow.com_questions_2971315_string-stringbuffer-and-stringbuilder]

## String, StringBuffer and StringBuilder ##

**1. 可变性**

*  String 不可变
 *  StringBuffer 和 StringBuilder 可变

**2. 线程安全**

*  String 不可变，因此是线程安全的
 *  StringBuilder 不是线程安全的
 *  StringBuffer 是线程安全的，内部使用 synchronized 进行同步

[StackOverflow : String, StringBuffer, and StringBuilder][https_stackoverflow.com_questions_2971315_string-stringbuffer-and-stringbuilder]

## String Pool：[https://www.cnblogs.com/fangfuhai/p/5500065.html][https_www.cnblogs.com_fangfuhai_p_5500065.html] ##

字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Pool 中。

当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。

下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中，然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。

String s1 = new String("aaa");
    String s2 = new String("aaa");
    System.out.println(s1 == s2);           // false
    String s3 = s1.intern();
    String s4 = s1.intern();
    System.out.println(s3 == s4);           // true

如果是采用 "bbb" 这种字面量的形式创建字符串，会自动地将字符串放入 String Pool 中。

String s5 = "bbb";
    String s6 = "bbb";
    System.out.println(s5 == s6);  // true

在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。

*  [StackOverflow : What is String interning?：：][StackOverflow _ What is String interning][https://stackoverflow.com/questions/10578984/what-is-java-string-interning][https_stackoverflow.com_questions_10578984_what-is-java-string-interning]
 *  [深入解析 String\#intern：][String_intern][https://tech.meituan.com/2014/03/06/in-depth-understanding-string-intern.html][https_tech.meituan.com_2014_03_06_in-depth-understanding-string-intern.html]

## new String("abc") ##

使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）。

*  "abc" 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
 *  而使用 new 的方式会在堆中创建一个字符串对象。

创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。

public class NewStringTest {
        public static void main(String[] args) {
            String s = new String("abc");
        }
    }

使用 javap -verbose 进行反编译，得到以下内容：

// ...
 Constant pool:
 // ...
 #2 = Class #18 // java/lang/String
 #3 = String #19 // abc
 // ...
 #18 = Utf8 java/lang/String
 #19 = Utf8 abc
 // ...
 
 public static void main(java.lang.String[]);
 descriptor: ([Ljava/lang/String;)V
 flags: ACC_PUBLIC, ACC_STATIC
 Code:
 stack=3, locals=2, args_size=1
 0: new #2 // class java/lang/String
 3: dup
 4: ldc #3 // String abc
 6: invokespecial #4 // Method java/lang/String."<init>":(Ljava/lang/String;)V
 9: astore_1
 // ...

在 Constant Pool 中，\#19 存储这字符串字面量 "abc"，\#3 是 String Pool 的字符串对象，它指向 \#19 这个字符串字面量。在 main 方法中，0: 行使用 new \#2 在堆中创建一个字符串对象，并且使用 ldc \#3 将 String Pool 中的字符串对象作为 String 构造函数的参数。

以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。

public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

# 三、运算 #

## 参数传递 ##

Java 的参数是以值传递的形式传入方法中，而不是引用传递。

以下代码中 Dog dog 的 dog 是一个指针，存储的是对象的地址。在将一个参数传入一个方法时，本质上是将对象的地址以值的方式传递到形参中。因此在方法中使指针引用其它对象，那么这两个指针此时指向的是完全不同的对象，在一方改变其所指向对象的内容时对另一方没有影响。

public class Dog {
        String name;
        Dog(String name) {
            this.name = name;
        }
        String getName() {
            return this.name;
        }
        void setName(String name) {
            this.name = name;
        }
        String getObjectAddress() {
            return super.toString();
        }
    }
    public class PassByValueExample {
        public static void main(String[] args) {
            Dog dog = new Dog("A");
            System.out.println(dog.getObjectAddress()); // Dog@4554617c
            func(dog);
            System.out.println(dog.getObjectAddress()); // Dog@4554617c
            System.out.println(dog.getName());          // A
        }
        private static void func(Dog dog) {
            System.out.println(dog.getObjectAddress()); // Dog@4554617c
            dog = new Dog("B");
            System.out.println(dog.getObjectAddress()); // Dog@74a14482
            System.out.println(dog.getName());          // B
        }
    }

如果在方法中改变对象的字段值会改变原对象该字段值，因为改变的是同一个地址指向的内容。

class PassByValueExample {
        public static void main(String[] args) {
            Dog dog = new Dog("A");
            func(dog);
            System.out.println(dog.getName());          // B
        }
    
        private static void func(Dog dog) {
            dog.setName("B");
        }
    }

## float 与 double ##

Java 不能隐式执行向下转型，因为这会使得精度降低。

1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。

// float f = 1.1;

1.1f 字面量才是 float 类型。

float f = 1.1f;

## 隐式类型转换 ##

因为字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型下转型为 short 类型。

short s1 = 1;
    // s1 = s1 + 1;

但是使用 += 或者 ++ 运算符可以执行隐式类型转换。

s1 += 1;
    // s1++;

上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：

s1 = (short) (s1 + 1);

## switch ##

从 Java 7 开始，可以在 switch 条件判断语句中使用 String 对象。

String s = "a";
    switch (s) {
        case "a":
            System.out.println("aaa");
            break;
        case "b":
            System.out.println("bbb");
            break;
    }

switch 不支持 long，是因为 switch 的设计初衷是对那些只有少数的几个值进行等值判断，如果值过于复杂，那么还是用 if 比较合适。

// long x = 111;
    // switch (x) { // Incompatible types. Found: 'long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
    //     case 111:
    //         System.out.println(111);
    //         break;
    //     case 222:
    //         System.out.println(222);
    //         break;
    // }

持续学习，待更新.....

[https_docs.oracle.com_javase_tutorial_java_nutsandbolts_datatypes.html]: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
[Java]: https://www.cnblogs.com/Pjson/p/8777940.html
[ContractedBlock.gif]: /images/20220319/3919491e17af4b73bacddc0f1817409b.png
[20150922153039509]: /images/20220319/c5fe5422c1614098aba32e782ea47c70.png
[474e5579-38b1-47d2-8f76-a13ae086b039.jpg]: https://github.com/CyC2018/CS-Notes/raw/master/docs/notes/pics/474e5579-38b1-47d2-8f76-a13ae086b039.jpg
[474e5579-38b1-47d2-8f76-a13ae086b039.jpg 1]: https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/pics/474e5579-38b1-47d2-8f76-a13ae086b039.jpg
[Program Creek _ Why String is immutable in Java]: https://www.programcreek.com/2013/04/why-string-is-immutable-in-java/
[https_stackoverflow.com_questions_2971315_string-stringbuffer-and-stringbuilder]: https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder
[https_www.cnblogs.com_fangfuhai_p_5500065.html]: https://www.cnblogs.com/fangfuhai/p/5500065.html
[StackOverflow _ What is String interning]: https://stackoverflow.com/questions/10578984/what-is-string-interning
[https_stackoverflow.com_questions_10578984_what-is-java-string-interning]: https://stackoverflow.com/questions/10578984/what-is-java-string-interning
[String_intern]: https://tech.meituan.com/in_depth_understanding_string_intern.html
[https_tech.meituan.com_2014_03_06_in-depth-understanding-string-intern.html]: https://tech.meituan.com/2014/03/06/in-depth-understanding-string-intern.html