@DevWiki 2015-07-02T21:13:44.000000Z 字数 8767 阅读 912

JDK源码学习之String

JDK源码

String类是最常用的类之一了.

1.定义

public final class String extends Object implements Serializable, Comparable<String>, CharSequence

1.1 关键字

public

被public修饰的类为全局可访问的类

final

悲final的类为终类,不可被继承不可被覆盖

1.2 继承的父类

Object

直接继承于Object类,Object类为所有Java类的间接或直接父类

1.3 实现的接口

Serializable

实现此接口,说明String类能被序列化

Comparable

实现此接口,说明String类的对象可以被排序

CharSequence

实现此接口,说明String类是一种字符序列

2.Field字段

private final char value[];
private int hash; // Default to 0
private static final long serialVersionUID = -6849794470754667710L;
private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];

value[]

用于存放String类对象的值的字符数组,比如

String str = "abc";

那么value[]数组就等于:

value[] = new char[]{'a', 'b', 'c'};

hash

String类对象的哈希值

serialVersionUID

String类运行时序列化的版本号

ObjectStreamField[]

用于String类序列化的描述

3.构造方法

String()

public String() {
    this.value = new char[0];
}

创建一个新的String对象,默认字符串长度为0.

String(String original)

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

用一个已有的String对象创建一个新的String对象.将参数对象的字符数组和哈希值赋值给新的对象.

String(char value[])

public String(char value[]) {
    this.value = Arrays.copyOf(value, value.length);
}

用一个字符数组创建一个String对象.内部不是直接赋值,而是使用了Arrays.copyOf()方法:

public static char[] copyOf(char[] original, int newLength) {
    char[] copy = new char[newLength];
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

Arrays.copyOf内部新建了一个与参数长度相同的方法,并调用System.arrayscopy()方法复制.

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

System.arrayscopy()方法是使用的操作系统底层实现复制的.

String(char value[], int offset, int count)

public String(char value[], int offset, int count) {
    if (offset < 0) {
        throw new StringIndexOutOfBoundsException(offset);
    }
    if (count < 0) {
        throw new StringIndexOutOfBoundsException(count);
    }
    // Note: offset or count might be near -1>>>1.(2147483647)
    if (offset > value.length - count) {
        throw new StringIndexOutOfBoundsException(offset + count);
    }
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}

截取字符数组一部分创建一个新的String对象.
如果起始偏移量或者截取的数量或者起始偏移量与截取数量之和大于字符数组的长度时会抛出StringIndexOutOfBoundsException异常.
而value[]是使用的Arrays.copyOfRange方法截取复制

public static char[] copyOfRange(char[] original, int from, int to) {
    int newLength = to - from;
    if (newLength < 0)
        throw new IllegalArgumentException(from + " > " + to);
    char[] copy = new char[newLength];
    System.arraycopy(original, from, copy, 0,
                     Math.min(original.length - from, newLength));
    return copy;
}

在Arrays.copyOfRange中创建新的字符数组,并调用系统底层的数组复制方法System.arraycopy.

String(int[] codePoints, int offset, int count)

public String(int[] codePoints, int offset, int count) {
    if (offset < 0) {
        throw new StringIndexOutOfBoundsException(offset);
    }
    if (count < 0) {
        throw new StringIndexOutOfBoundsException(count);
    }
    // Note: offset or count might be near -1>>>1.
    if (offset > codePoints.length - count) {
        throw new StringIndexOutOfBoundsException(offset + count);
    }
    final int end = offset + count;
    // Pass 1: Compute precise size of char[]
    int n = count;
    for (int i = offset; i < end; i++) {
        int c = codePoints[i];
        if (Character.isBmpCodePoint(c))
            continue;
        else if (Character.isValidCodePoint(c))
            n++;
        else throw new IllegalArgumentException(Integer.toString(c));
    }
    // Pass 2: Allocate and fill in char[]
    final char[] v = new char[n];
    for (int i = offset, j = 0; i < end; i++, j++) {
        int c = codePoints[i];
        if (Character.isBmpCodePoint(c))
            v[j] = (char)c;
        else
            Character.toSurrogates(c, v, j++);
    }
    this.value = v;
}

截取int型数组的一部分创建新的String对象,新的String对象为Unicode码组成,即将int数组的值转为Unicode码.
如果起始偏移量或者截取的数量或者起始偏移量与截取数量之和大于字符数组的长度时会抛出StringIndexOutOfBoundsException异常.
创建分为两步:
第一步:计算char[]数组的长度
1.先判断int值是否为BMP代码点,是则跳过.
2.判断指定的代码点是否为从 0x0000 到 0x10FFFF 范围之内的有效 Unicode 代码点值,是则加一

第二步:截取赋值字符

String(byte bytes[], int offset, int length, String charsetName)

public String(byte bytes[], int offset, int length, String charsetName)
        throws UnsupportedEncodingException {
    if (charsetName == null)
        throw new NullPointerException("charsetName");
    checkBounds(bytes, offset, length);
    this.value = StringCoding.decode(charsetName, bytes, offset, length);
}

使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。
如果未指定charsetName则报空指向异常
checkBounds()方法是检查offset和length是否超过数组边界,此方法是为了复用提取的内部私有方法.

private static void checkBounds(byte[] bytes, int offset, int length) {
    if (length < 0)
        throw new StringIndexOutOfBoundsException(length);
    if (offset < 0)
        throw new StringIndexOutOfBoundsException(offset);
    if (offset > bytes.length - length)
        throw new StringIndexOutOfBoundsException(offset + length);
}

最后使用StringCode进行解码,如果编码方式为null,则默认使用ISO-8859-1编码.

static char[] decode(String charsetName, byte[] ba, int off, int len)
        throws UnsupportedEncodingException
    {
        StringDecoder sd = deref(decoder);
        String csn = (charsetName == null) ? "ISO-8859-1" : charsetName;
        if ((sd == null) || !(csn.equals(sd.requestedCharsetName())
                              || csn.equals(sd.charsetName()))) {
            sd = null;
            try {
                Charset cs = lookupCharset(csn);
                if (cs != null)
                    sd = new StringDecoder(cs, csn);
            } catch (IllegalCharsetNameException x) {}
            if (sd == null)
                throw new UnsupportedEncodingException(csn);
            set(decoder, sd);
        }
        return sd.decode(ba, off, len);
    }

StringCoding类为java.lang包内部的字符编码和解码的工具类;StringDecoder和StringEncoder类是StringCoding类内部的解码和编码类.

String(byte bytes[], String charsetName)

public String(byte bytes[], String charsetName)
        throws UnsupportedEncodingException {
    this(bytes, 0, bytes.length, charsetName);
}

用byte数组和指定的编码方式创建一个String对象.

String(byte bytes[], int offset, int length)

public String(byte bytes[], int offset, int length) {
    checkBounds(bytes, offset, length);
    this.value = StringCoding.decode(bytes, offset, length);
}

截取byte数组一部分创建一个String对象.
先检查数组边界,在调用了StringCoding编码.

String(byte bytes[])

public String(byte bytes[]) {
    this(bytes, 0, bytes.length);
}

用byte数组创建一个String对象,内部调用的是String(byte bytes[], int offset, int length)方法.

String(StringBuffer buffer)

public String(StringBuffer buffer) {
    synchronized(buffer) {
        this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
    }
}

用一个StringBuffer对象创建一个String对象,采用同步操作,多线程对buffer的操作不会影响String对象的值.内部使用Arrays.copyOf方法复制字符数组.

String(StringBuilder builder)

public String(StringBuilder builder) {
    this.value = Arrays.copyOf(builder.getValue(), builder.length());
}

使用一个StringBuilder对象创建一个String对象.内部使用Arrays.copyOf复制字符数组.

public String(char[] value, boolean share) {
    // assert share : "unshared not supported";
    this.value = value;
}

使用一个char数组创建一个String对象,直接将char数组的引用传递给内部的value数组.

4.类方法

copyValueOf(char data[])

public static String copyValueOf(char data[]) {
    return new String(data);
}

返回指定数组中表示该字符序列的 String。即调用构造方法用数组生成一个String对象.比如:

char[] data = new char[]{'1', '2', '3'};
String str = String.coprValueOf(data);

结果为:123

copyValueOf(char data[], int offset, int count)

public static String copyValueOf(char data[], int offset, int count) {
    return new String(data, offset, count);
}

返回指定数组中一份表示该字符序列的 String。即调用构造方法用数组生成一个String对象.比如:

char[] data = new char[]{'1', '2', '3'};
String str = String.coprValueOf(data, 0, 3);

结果为:123

format(String format, Object... args)

public static String format(String format, Object... args) {
    return new Formatter().format(format, args).toString();
}

使用指定的格式字符串和参数返回一个格式化字符串。内部调用Formatter类的format方法.
Formatter类是printf 风格的格式字符串的解释程序.使用了Formatter的无参构造方法:

public Formatter() {
    this(Locale.getDefault(Locale.Category.FORMAT), new StringBuilder());
}

而此方法内部默认调用两个参数的构造方法.其中的Local对象为系统获取当前运行系统的默认区域并新建了一个StringBuilder对象,StringBuilder的父类实现了Appendable接口,说明StringBuilder是可以继续拼接修改的

Local local = Locale.getDefault(Locale.Category.FORMAT);
StringBuilder builder = new StringBuilder();

在调用Formatter类的format方法时默认使用默认的区域格式.

public Formatter format(String format, Object ... args) {
    return format(l, format, args);
}

内部又调用了format(Locale l, String format, Object ... args)

public Formatter format(Locale l, String format, Object ... args) {
    ensureOpen();
    // index of last argument referenced
    int last = -1;
    // last ordinary index
    int lasto = -1;
    FormatString[] fsa = parse(format);
    for (int i = 0; i < fsa.length; i++) {
        FormatString fs = fsa[i];
        int index = fs.index();
        try {
            switch (index) {
            case -2:  // fixed string, "%n", or "%%"
                fs.print(null, l);
                break;
            case -1:  // relative index
                if (last < 0 || (args != null && last > args.length - 1))
                    throw new MissingFormatArgumentException(fs.toString());
                fs.print((args == null ? null : args[last]), l);
                break;
            case 0:  // ordinary index
                lasto++;
                last = lasto;
                if (args != null && lasto > args.length - 1)
                    throw new MissingFormatArgumentException(fs.toString());
                fs.print((args == null ? null : args[lasto]), l);
                break;
            default:  // explicit index
                last = index - 1;
                if (args != null && last > args.length - 1)
                    throw new MissingFormatArgumentException(fs.toString());
                fs.print((args == null ? null : args[last]), l);
                break;
            }
        } catch (IOException x) {
            lastException = x;
        }
    }
    return this;
}

此方法返回的是一个Formatter对象,然后调用了toString方法,将a打印输出.

public String toString() {
    ensureOpen();
    return a.toString();
}

String valueOf(Object obj)

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

将一个对象转为String对象,调用该对象的toString方法.

String valueOf(char[] data)

public static String valueOf(char[] data) {
    return new String(data, 0, data.length);
}

调用String的构造方法创建一个String对象.

String valueOf(char[] data, int start, int length)

public static String valueOf(char[] data, int start, int length) {
    return new String(data, start, length);
}

调用String的构造方法创建一个String对象.
此系列的方法还有:
String valueOf(boolean b)

public static String valueOf(boolean b) {
    return b ? "true" : "false";
}

String valueOf(char value)

public static String valueOf(char c) {
    char data[] = {c};
    return new String(data, true);
}

一以下方法均是调用相应的包装类的toString方法.

String valueOf(char c)
String valueOf(int i)
String valueOf(long l)
String valueOf(float f) 
String valueOf(double d)