Java基础-String类的常用方法与对应源码

日期：2018年3月7日：
常见问题：
String str=new String(“ydc”)； 会产生几个对象呢？
答案：1或者2个（答案自行Google）
String str=“y”+“dc”；当字符串常量池为空时，会产生几个对象呢？
答案：在有编译器优化时，只产生1（“ydc”）个，如果未优化，产生3个（“y”，“dc”，“ydc”）

日期：2018年1月2日：
String类：

public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
    private final char value[];

    private int hash; // Default to 0

    private static final long serialVersionUID = -6849794470754667710L;

}

1.String类被final修饰，不能有子类。（这块可以与后面equals方法里的 instanceof 相关联）
2.String类对象创建后不能修改，由0或多个字符组成，包含在一对双引号之间。

常用构造方法：

//无参构造：new String();
public String() {
    this.value = "".value;
}

//传入一个字符串：new String("ydc");
public String(String original) {
    this.value = original.value;
    this.hash = original.hash;
}

//传入字符数组：new String({"y","d","c"});
public String(char value[]) {
    this.value = Arrays.copyOf(value, value.length);
}

//传入字节数组：new String(bytes);
public String(byte bytes[]) {
    this(bytes, 0, bytes.length);
}
public String(byte bytes[], int offset, int length) {
    checkBounds(bytes, offset, length);//校验参数
    this.value = StringCoding.decode(bytes, offset, length);
}

//传入StringBuffer类的实例对象：new String(buffer);
public String(StringBuffer buffer) {
    synchronized(buffer) {
    this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
    }
}

//传入StringBuilder类的实例对象：new String(builder);
public String(StringBuilder builder) {
    this.value = Arrays.copyOf(builder.getValue(), builder.length());
}

常用方法：

//返回字符串长度
public int length() {
    return value.length; //返回字符数组长度
}
//判断字符串是否为空
public boolean isEmpty() {
    return value.length == 0;//判断字符数组长度是否等于0
}
//返回字符串中指定位置的字符（索引从0开始）
public char charAt(int index) {
    //校验索引参数值 
    if ((index < 0) || (index >= value.length)) {
    throw new StringIndexOutOfBoundsException(index);
    }
return value[index];
}

//返回字符串长度
public int length() {
    return value.length; //返回字符数组长度
}
//判断字符串是否为空
public boolean isEmpty() {
    return value.length == 0;//判断字符数组长度是否等于0
}
//返回字符串中指定位置的字符（索引从0开始）
public char charAt(int index) {
    //校验索引参数值 
    if ((index < 0) || (index >= value.length)) {
    throw new StringIndexOutOfBoundsException(index);
    }
return value[index];
}

//字符串比较
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;
}
获取到对应的字符数组，逐个比较，如果逐个比较完仍未返回结果，就比较两者长度，若当前对象比参数大，返回正整数，相等返回0，比参数小，则返回负数。

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                return false;
                i++;
            }
            return true;
        }
    }
    return false;
}
1.先==比较地址，如果相等，则立即返回true
2.判断参数anObject是否属于String类的一个对象实例（一般这类判断用 .getClass() 来比较 会更合适一些，但因为String类被final关键字修饰，不会存在子类，也就不会发生这样的问题）
3、比较两者长度大小
4.逐个比较字符数组里的值

//字符串连接
public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    //创建一个长度为（len + otherLen），初始值为 value 的数组
    char buf[] = Arrays.copyOf(value, len + otherLen);
    //将参数str的值加入buf[]，底层调用的System.arraycopy(value,0,dst,dstbegin,value.length)
    str.getChars(buf, len);
    return new String(buf, true);
}
//字符串中字符的替换
public String replaceAll(String regex, String replacement) {
    return Pattern.compile(regex).matcher(this).replaceAll(replacement);
}
public String replaceAll(String replacement) {
    reset();
    boolean result = find();
    if (result) {
        StringBuffer sb = new StringBuffer();
        do {
        appendReplacement(sb, replacement);
        result = find();
        } while (result);
        appendTail(sb);
        return sb.toString();
    }
    return text.toString();
}
创建StringBuffer类的对象实例，do..while 循环 找出并替换，补全尾部后，调用toString()。
regex参数 可以使用或（|）等，例如：str.replaceAll("a|b",c);//将a或者b，替换成c

//去除字符串两端的空格，中间空格不处理
public String trim() {
    int len = value.length;
    int st = 0;
    char[] val = value; /* avoid getfield opcode */

    while ((st < len) && (val[st] <= ' ')) {
        st++;
    }
    while ((st < len) && (val[len - 1] <= ' ')) {
        len--;
    }
    //通过substring实现截取的效果
    return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}
//字符串--》数组  regex也可以使用 或（|） 例如:str.substring(",|?") 以“，”或“？”进行分割
public String[] split(String regex) {
    return split(regex, 0);
}

public String[] split(String regex, int limit) {
    char ch = 0;
    if (((regex.value.length == 1 &&
        ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
        (regex.length() == 2 &&
        regex.charAt(0) == '\\' &&
        (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
        ((ch-'a')|('z'-ch)) < 0 &&
        ((ch-'A')|('Z'-ch)) < 0)) &&
        (ch < Character.MIN_HIGH_SURROGATE ||
        ch > Character.MAX_LOW_SURROGATE))
    {
        int off = 0;
        int next = 0;
        boolean limited = limit > 0;
        ArrayList<String> list = new ArrayList<>();
        while ((next = indexOf(ch, off)) != -1) {
            if (!limited || list.size() < limit - 1) {
        list.add(substring(off, next));
            off = next + 1;
        } else { // last one
            //assert (list.size() == limit - 1);
            list.add(substring(off, value.length));
            off = value.length;
            break;
        }
    }

    if (off == 0)
    return new String[]{this};


    if (!limited || list.size() < limit)
        list.add(substring(off, value.length));


    int resultSize = list.size();
    if (limit == 0) {
        while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
        resultSize--;
        }
    }
    String[] result = new String[resultSize];
    return list.subList(0, resultSize).toArray(result);
    }
    return Pattern.compile(regex).split(this, limit);
}

字符串与基本类型的转换

//字符串--》基本类型
1. public static byte parseByte(String s)
2. public static short parseShort(String s)
3. public static short parseInt(String s)
4. public static long parseLong(String s)
5. public static float parseFloat(String s)
6. public static double parseDouble(String s)
//基本类型--》字符串
1. static String valueOf(char data[])
2. static String valueOf(char data[], int offset, int count)
3. static String valueOf(boolean b)
4. static String valueOf(char c)
5. static String valueOf(int i)
6. static String valueOf(long l)
7. static String valueOf(float f)
8. static String valueOf(double d)