java中StringStringBuilder和StringBuffer理解

Posted 2020-08-31 无痕

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java中StringStringBuilder和StringBuffer理解相关的知识，希望对你有一定的参考价值。

String、StringBuilder和StringBuffer理解

1>String

java.lang.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;

    /**
     * Class String is special cased within the Serialization Stream Protocol.
     *
     * A String instance is written initially into an ObjectOutputStream in the
     * following format:
     * <pre>
     *      <code>TC_STRING</code> (utf String)
     * </pre>
     * The String is written by method <code>DataOutput.writeUTF</code>.
     * A new handle is generated to  refer to all future references to the
     * string instance within the stream.
     */
    private static final ObjectStreamField[] serialPersistentFields =
            new ObjectStreamField[0];
　　......

从以上JDK中String源码可以看出，String类被final修饰，在java中被final修饰的类是不能够被继承的，而且String类中的成员变量都被修饰成final。

而且可以看出String是通过char数组来实现保存字符串的。

    public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? 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);
    }

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

以上是String类的部分成员方法，可以看出他们都不是在原有的String对象上操作的。只要对String对象进行改变，则就会创建新的String对象，对原有的对象并没有改变。

注意：String str1="abc" 和 String str2=new String("abc");有什么区别呢？代码测试为证：

public class stringTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str1 = "abc";
        String str2 = new String("abc");
        String str3 = new String("abc");
        String str4 = "abc";
        
        System.out.println(str1 == str2);
        System.out.println(str2 == str3);
        System.out.println(str1 == str4);
    }
}