浅谈字符串的拼接

朱雀 2022-12-06 12:41 101阅读 0赞

### 文章目录 ###

*  浅谈字符串的拼接
 *   *  1、JVM中常量池的存放
     *  2、字符串的声明
     *  3、String
     *  4、StringBuilder
     *  5、StringBuffer
     *  6、StringJoiner

# 浅谈字符串的拼接 #

## 1、JVM中常量池的存放 ##

在谈字符串拼接之前，我们首先了解一下字符串常量池

![70][]

Java7之前，常量池是存放在方法区中的。

Java7，常量池存放到了堆中。

Java8之后，运行时常量池和静态常量池存放在元空间中，而字符串常量池存放在堆中。

## 2、字符串的声明 ##

String s = "hello";  //直接通过双引号""声明字符串

*  到字符串常量池中查找该字符串是否已经存在.
    
     *  存在，会直接返回该引用,
     *  不存在，则会在堆内存中创建该字符串对象, 然后到字符串常量池中注册该字符串。

String s = new String("hello"); //使用new关键字创建字符串

*  JVM将不会查询字符串常量池, 它将会直接在堆内存中创建一个字符串对象, 并返回给所属变量。

**小结**

当用new关键字创建字符串对象时, 不会查询字符串常量池; 当用双引号直接声明字符串对象时, 虚拟机将会查询字符串常量池.

字符串常量池提供了字符串的复用功能, 除非我们要显式创建新的字符串对象, 否则对同一个字符串虚拟机只会维护一份拷贝。

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

可以用上面的代码去验证我们的结论，==对于对象来说比较的是地址，上面的代码也说明了如果我们不显示创建对象，它将会直接在堆内存中创建一个字符串对象, 并返回给所属变量。

## 3、String ##

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);
        }

翻阅源码我们可以看出,对于String类, 凡是涉及到返回参数类型为String类型的方法, 在返回的时候都会通过new关键字创建一个新的字符串对象

如果我们通过 反编译代码 可以看出当用String类拼接字符串时, 每次都会生成一个StringBuilder对象, 然后调用两次append()方法把字符串拼接好, 最后通过StringBuilder的toString()方法new出一个新的字符串对象。

很显然如果拼接的次数过多, 创建对象所带来的时延会降低系统效率, 同时会造成巨大的内存浪费，使JVM不得不进行GC，进一步降低了系统效率。

## 4、StringBuilder ##

StringBuilder和StringBuffer都继承自AbstractStringBuilder类, 通过查看该类的源码, 得知StringBuilder和StringBuffer两个类也是通过char类型数组实现的（AbstractStringBuilder类中）

@Override
        public StringBuilder append(char[] str) {
        
            super.append(str);
            return this;
        }

我们通过阅读源码也可以看出， StringBuilder类, 大多数方法都会返回StringBuilder对象自身 。也就是说在拼接字符串的时候StringBuilder只需要调用一次append()方法，显然StringBuilder比String效率高效很多

## 5、StringBuffer ##

StringBuffer在方法上添加了 synchronized关键字， 证明它的方法绝大多数方法都是线程同步方法 （insert方法没有），也就是说在多线程的环境下使用StringBuffer保证线程安全, 在单线程环境下使用StringBuilder获得更高的效率。

@Override
        public synchronized StringBuffer append(CharSequence s) {
        
            toStringCache = null;
            super.append(s);
            return this;
        }

大家有兴趣也可以去阅读一下AbstractStringBuilder的源码。

public AbstractStringBuilder append(char[] str) {
        
            int len = str.length;
            ensureCapacityInternal(count + len);
            System.arraycopy(str, 0, value, count, len);
            count += len;
            return this;
        }

## 6、StringJoiner ##

这个类是我在阅读String类的时候发现的,附上String的部分源码

public static String join(CharSequence delimiter, CharSequence... elements) {
        
            Objects.requireNonNull(delimiter);
            Objects.requireNonNull(elements);
            // Number of elements not likely worth Arrays.stream overhead.
            StringJoiner joiner = new StringJoiner(delimiter);
            for (CharSequence cs: elements) {
        
                joiner.add(cs);
            }
            return joiner.toString();
        }

可以看出这个类和StringBuilder有异曲同工之妙， StringJoiner是Java8新出的一个类，用于构造由分隔符分隔的字符序列，也就是运用了StringBuilder的一个拼接字符串的封装处理。

public StringJoiner(CharSequence delimiter) {
        
            this(delimiter, "", "");
        }
    
    
        public StringJoiner(CharSequence delimiter,
                            CharSequence prefix,
                            CharSequence suffix) {
        
            Objects.requireNonNull(prefix, "The prefix must not be null");
            Objects.requireNonNull(delimiter, "The delimiter must not be null");
            Objects.requireNonNull(suffix, "The suffix must not be null");
            // make defensive copies of arguments
            this.prefix = prefix.toString();
            this.delimiter = delimiter.toString();
            this.suffix = suffix.toString();
            this.emptyValue = this.prefix + this.suffix;
        }

这从它的构造函数也很容易得出，下面来举个简单的例子

StringJoiner sj = new StringJoiner(":", "[", "]");
            sj.add("1").add("2").add("3");
            System.out.println(sj.toString());
    		//输出：[1:2:3]

我们再继续阅读源码，会发现它和StringBuilder的联系,部分源码如下

public StringJoiner add(CharSequence newElement) {
        
            prepareBuilder().append(newElement);
            return this;
        }
    
        private StringBuilder prepareBuilder() {
        
            if (value != null) {
        
                value.append(delimiter);
            } else {
        
                value = new StringBuilder().append(prefix);
            }
            return value;
        }

我们发现StringJoiner底层依旧使用的 StringBuilder，第一次添加数据时，会生成StringBuilder对象，并添加 “前缀”，后续添加字符时，追加 “分隔符”，最后调用 append 方法。

本文参考如下：

[StringJoiner][]

[从底层彻底搞懂String，StringBuilder，StringBuffer的实现][String_StringBuilder_StringBuffer]

[70]: /images/20221123/b608a6bbeee5449aa17d5ccabe8be01b.png
[StringJoiner]: https://www.cnblogs.com/wansw/p/10225904.html
[String_StringBuilder_StringBuffer]: https://blog.csdn.net/zp357252539/article/details/97916254