String、StringBuilder、StringBuffer深入理解

「爱情、让人受尽委屈。」 2021-12-04 00:39 307阅读 0赞

## 一、从源码来理解String类     ##

public final class String
        	    implements java.io.Serializable, Comparable<String>, CharSequence {
        	    /** The value is used for character storage. */
        	    private final char value[];
        
        	    /** Cache the hash code for the string */
        	    private int hash; // Default to 0
        
        	    /** use serialVersionUID from JDK 1.0.2 for interoperability */
        	    private static final long serialVersionUID = -6849794470754667710L;
        	 }

1）**String类是final类**，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法。在早期的JVM实现版本中，被final修饰的方法会被转为内嵌调用以提升执行效率。而从Java SE5/6开始，就渐渐摈弃这种方式了。因此在现在的Java SE版本中，不需要考虑用final去提升方法调用效率。只有在确定不想让该方法被覆盖时，才将方法设置为final。

private final char value[];
        
            /** Cache the hash code for the string */
            private int hash; // Default to 0

源码中String类中的成员属性可以看出，**String类其实是通过char数组来保存字符串的**。

public String substring(int beginIndex, int endIndex) {
                if (beginIndex < 0) {
                    throw new StringIndexOutOfBoundsException(beginIndex);
                }
                if (endIndex > value.length) {
                    throw new StringIndexOutOfBoundsException(endIndex);
                }
                int subLen = endIndex - beginIndex;
                if (subLen < 0) {
                    throw new StringIndexOutOfBoundsException(subLen);
                }
                return ((beginIndex == 0) && (endIndex == value.length)) ? this
                        : new String(value, beginIndex, subLen);
            }
     
    
            public String concat(String str) {
                int otherLen = str.length();
                if (otherLen == 0) {
                    return this;
                }
                int len = value.length;
                char buf[] = Arrays.copyOf(value, len + otherLen);
                str.getChars(buf, len);
                return new String(buf, true);
            }

从上面的两个方法可以看出，无论是 substring()还是 concat()操作都不是在原有的字符串上进行的，而是重新生成了一个新的字符串对象。也就是说进行这些操作后，**最原始的字符串并没有被改变**。  
　　在这里要永远记住一点：  
　　 “对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象”。

### **连接表达式+(加号)**   1、只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。   2、对于所有包含new方式新建对象（包括null）的“+”连接表达式，它所产生的新对象都不会被加入字符串池中 ###

String str1 = "str";
        	String str2 = "ing";
        	
        	String str3 = "str" + "ing";
        	String str4 = str1 + str2;
        	System.out.println(str3 == str4);//false
        	
        	String str5 = "string";
        	System.out.println(str3 == str5);//true

//监听单元格编辑
            table.on('edit(' + gridId + ')', function (obj) {
                var value = obj.value //得到修改后的值
                    , data = obj.data //得到所在行所有键值
                    , field = obj.field; //得到字段
    
                obj.update(data)
    
            });
    
    
            // 修改和删除
            table.on('tool(' + gridId + ')', function (obj) {
                var data = obj.data; // 获得当前行数据
                if (obj.event === 'del') {
                    obj.del();
                }
            });

## **FAQ** ##

1. String str1 = “abc”; System.out.println(str1 == “abc”);

> 步骤：  
> a> 栈中开辟一块空间存放引用str1；  
> b> String池中开辟一块空间，存放String常量”abc”；  
> c> 引用str1指向池中String常量”abc”；  
> d> str1所指代的地址即常量”abc”所在地址，输出为true；

String str2 = new String(“abc”); System.out.println(str2 == “abc”);

> 步骤：  
> a> 栈中开辟一块空间存放引用str2；  
> b> 堆中开辟一块空间存放一个新建的String对象”abc”；  
> c> 引用str2指向堆中的新建的String对象”abc”；  
> d> str2所指代的对象地址为堆中地址，而常量”abc”地址在池中，输出为false；  
> **注意：****对于通过new产生的对象，会先去常量池检查有没有 “abc”，如果没有，先在常量池创建一个 “abc” 对象，然后在堆中创建一个常量池中此 “abc” 对象的拷贝对象；**

String s2 = new String(“Hello”); 产生几个对象？

首先，在jvm的工作过程中，会创建一片的内存空间专门存入string对象。我们把这片内存空间叫做string池；  
String s2 = new String(“Hello”);jvm首先在string池内里面看找不找到字符串”Hello”,如果找到不做任何事情；否则创建新的string对象，放到string池里面。由于遇到了new，还会在内存Heap上（不是string池里面）创建string对象存储”Hello”，并将内存上的（不是string池内的）string对象返回给s2。  
Re: 如果常量池中原来没有“Hello”, 则创建两个对象。如果原来的常量池中存在“Hello”时，就是一个对象；

## 二、深入理解String、StringBuffer、StringBuilder ##

### 1.String str="hello world"和String str=new String("hello world")的区别 ###

String str=“hello world” 通过直接赋值的形式可能创建一个或者不创建对象，如果"hello world"在字符串池中不存在，会在java字符串池中创建一个String对象（“hello world”）,常量池中的值不能有 重复的，所以当你通过这种方式创建对象的时候，java虚拟机会自动的在常量池中搜索有没有这个值，如果有的话就直接利用他的值，如果没有，他会自动创建一个对象，所以，str指向这个内存地址，无论以后用这种方式创建多少个值为”hello world”的字符串对象，始终只有一个内存地址被分配。

String str=new String(“hello world”)通过new 关键字至少会创建一个对象，也有可能创建两个。因为用到new关键字，肯定会在堆中创建一个String对象，如果字符池中已经存在"hello world",则不会在字符串池中创建一个String对象，如果不存在，则会在字符串常量池中也创建一个对象。他是放到堆内存中的，这里面可以有重复的，所以每一次创建都会new一个新的对象，所以他们的地址不同。

**String 有一个intern() 方法，native，用来检测在String pool是否已经有这个String存在。**

通过一段代码来理解一下

public class Main {         
            public static void main(String[] args) {
                String str1 = "hello world";
                String str2 = new String("hello world");
                String str3 = "hello world";
                String str4 = new String("hello world");
                 
                System.out.println(str1==str2);
                System.out.println(str1==str3);
                System.out.println(str2==str4);
            }
        }

返回的结果是

false
        true
        false

### 2.String、StringBuffer以及StringBuilder的区别  ###

通过代码来理解他们之间的区别

**1）利用String操作**

public class Main {
            public static void main(String[] args) {
                String string = "";
                for(int i=0;i<10000;i++){
                    string += "hello";
                }
            }
        }

从上面String的源码中我们可以分析出：这句 string += “hello”;的过程相当于将原有的string变量指向的对象内容取出与"hello"作字符串相加操作再存进另一个新的String对象当中，再让string变量指向**新生成的对象**。也就是说这个循环执行完毕new出了10000个对象，试想一下，如果这些对象没有被回收，会造成多大的**内存资源浪费**。

**2）利用StringBulider操作**

public class Main {      
            public static void main(String[] args) {
                StringBuilder stringBuilder = new StringBuilder();
                for(int i=0;i<10000;i++){
                    stringBuilder.append("hello");
                }
            }
        }

这断代码和前面的功能一样，但是这里的10000次循环new操作只进行了一次，也就是说**只生成了一个对象**，append操作是在原有对象的基础上进行的。因此在循环了10000次之后，这段代码**所占的资源**要比上面小得多。这就是String和stringBuilder的最最主要的区别。

那么有人会问既然有了StringBuilder类，为什么还需要StringBuffer类？查看源代码便一目了然，事实上，StringBuilder和StringBuffer类拥有的成员属性以及成员方法基本相同，**区别是StringBuffer类的成员方法前面多了一个关键字：synchronized**，不用多说，这个关键字是在多线程访问时起到安全保护作用的,也就是说StringBuffer是线程安全的。有关线程的问题，我们讲多线程的时候在详细讲解！

## 总结： ##

这三个类是各有利弊，应当根据不同的情况来进行选择使用  
1、循环外字符串拼接可以直接使用String的+操作，没有必要通过StringBuilder进行append.  
2、有循环体的话，好的做法是在循环外声明StringBuilder对象，在循环内进行手动append。  
不论循环多少层都只有一个StringBuilder对象。  
3、当字符串相加操作较多的情况下，建议使用StringBuilder，如果采用了多线程，则使用StringBuffer。  
\---------------------   
  
原文：https://blog.csdn.net/weixin\_43610698/article/details/90812353