string、stringbuffer、stringbuilder详解之string类-凯发app官方网站

strings are constant; their values cannot be changed after they
* are created. string buffers support mutable strings.
* because string objects are immutable they can be shared. 

package testpackage;

class test {

    public static void main(string[] args) {

        string hello = "hello", lo = "lo";

        system.out.print((hello == "hello")   " ");

        system.out.print((other.hello == hello)   " ");

        system.out.print((other.other.hello == hello)   " ");

        system.out.print((hello == ("hel" "lo"))   " ");

        system.out.print((hello == ("hel" lo))   " ");

        system.out.println(hello == ("hel" lo).intern());

    }

}

class other { static string hello = "hello"; }

//另外一个包

package other;

public class other { public static string hello = "hello"; }

result：

true true true true false true

  string()：默认构造函数，主要用来初始化一个空字符串的string对象，此处的空并非为null。

public string() {

    this.value = "".value;

}

string(string)：有默认值得构造函数，其实该构造函数的实现结果等同于string str = "abc" ，需要大家注意的是内部的实现细节：

public string(string original) {

    this.value = original.value;

    this.hash = original.hash;

}

  此处有一个非常大的问题一直困扰着我，this.value = original.value,相当于将原始字符串内部的value直接赋值给了新的字符串对象，所以该操作并不会增加特别多内存，只是将新对象的value直接指向了original的value。具体效果如下：

  string(stringbuffer)：将stringbuffer对象赋值给string，个人将该操作定义为stringbuffer常量化过程，跟上一个方法不同的是，该方法在产生了新的string对象的同时，新的string对象内部数据载体value也指向的新的内存地址空间，所以该常量化过程并没有改变stringbuffer，其实就是讲stringbuffer进行了一次快照。具体实现：

public string(stringbuffer buffer) {

synchronized(buffer) {

 this.value=arrays.copyof(buffer.getvalue(),buffer.length());

}

}
将buffer的value进行了数组拷贝（synchronized的出现是由于stringbuffer是线程安全的）。

string(stringbuilder)：stringbuilder其实跟stringbuffer类似，只不过stringbuilder缺少了线程同步的操作synchronized过程。

public string(stringbuilder builder) {

this.value = arrays.copyof(builder.getvalue(), builder.length());

}

2、修改系：

str.concat(string):字符串拼接函数，将入参字符串“拼接”到当前字符串，并将拼接好的字符串封装成一个新的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);

}

从上图中所述，在整个字符串拼接过程中涉及到了三个内存空间的分配，所以为了防止地址空间的过渡分配，jdk引入了stringbuffer和stringbuilder两个类。

  string.join(delimiter,charsequnce …):静态多字符串分隔符拼接函数，即将多个字符串按照某个拼接符进行逐个拼接。具体实现如下：

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

}

该方法内引入了stringjoiner类，本文不详细讲解该类，有兴趣的可以直接查看源码，其内部主要支撑是stringbuilder类。
  str.replace(oldchar,newchar):本文只讲解该方法的具体细节，其他的replace和replaceall均是采用正则表达式的方式进行匹配替换的。而该方法个人感觉还是挺有意思的：

public string replace(char oldchar, char newchar) {

        if (oldchar != newchar) {

            int len = value.length;

            int i = -1;

            char[] val = value; /* avoid getfield opcode */

 

            while ( i < len) {

                if (val[i] == oldchar) {

                    break;

                }

            }

            if (i < len) {

                char buf[] = new char[len];

                for (int j = 0; j < i; j ) {

                    buf[j] = val[j];

                }

                while (i < len) {

                    char c = val[i];

                    buf[i] = (c == oldchar) ? newchar : c;

                    i ;

                }

                return new string(buf, true);

            }

        }

        return this;

    }

该方法第一步：确定被替换字符和新字符是否相同，如果相同则直接返回当前字符不进行任何查找，也就是说即使oldchar在字符串中不存在也会返回str，否则，通过第一次while循环查找字符串中是否存在oldchar字符，如果存在直接break。（关注一下这里的while( i < len)，而不是用i 的原因，个人觉得这个地方用的非常巧妙和恰当），接着进入第二个if判断，主要判断str中是否存在oldchar。如果存在则进入if体。先创建一个等size的char空数组，通过for循环并将i之前的所有char 全部复制到新数组中，接着从第i的位置开始（包括i）逐个进行判断，如果等于oldchar就用newchar填充i的位置，否则用原有的i位置上的元素进行替换，直到最后。整个过程充分考虑到了string对象不可修改的原则。
3、比较系：
  str.compareto(anotherstring) : 比较两个字符串。比较方式参照下面的实现规则：

public int compareto(string anotherstring) {

        int len1 = value.length;

        int len2 = anotherstring.value.length;

        int lim = math.min(len1, len2);

        char v1[] = value;

        char v2[] = anotherstring.value;

 

        int k = 0;

        while (k < lim) {

            char c1 = v1[k];

            char c2 = v2[k];

            if (c1 != c2) {

                return c1 - c2;

            }

            k ;

        }

        return len1 - len2;

}

  该算法规则：首先取两个字符串之间长度最短的字符串长度为一个中位点。如果在中位点之前两个字符串能够得出比较结果则直接返回，否则以字符串长度为基准。

  str.intern()：该方法其实不是比较方法，正常不应该放到该系里面来讲解，只不过该方法的调用大多数情况下都是用来做比较的用途。故将此方法的讲解放到了此处。该方法是一个native方法（public native string intern();）java中所有的native方法都是jvm底层实现的。该方法的底层实现实质上是通过jvm底层调用获取jvm内存结构中静态方法区中的字符串pool中与当前字符串具有相同value的字符串对象。

后续还将讲解stringbuffer和stringbuilder代码和设计详情。