Java源碼___String類（九）

java.lang.String分析摘要：

<1>join重載方法

<2>toLowerCase重載方法

<3>toUpperCase重載方法

<4>trim（）方法

<5>toString（）方法

1.join重載方法

該方法将elements中的字元序列拼接在delimiter的String對象。

public static String join(CharSequence delimiter, CharSequence... elements){
    //該方法如果參數不為null，則傳回參數本身，否則抛出NullPointerException異常
    Objects.requireNonNull(delimiter);
    Objects.requireNonNull(elements);
    StringJoiner joiner = new StringJoiner(delimiter);
    for(CharSequence cs : elements){
        joiner.add(cs);
    }
    return joiner.toString();
}

public static String join(CharSequence delimiter, 
                    Interable<? extends CharSequence> elements){
    Objects.requireNonNull(delimiter);
    Objects.requireNonNull(elements);
    StringJoiner joiner = new StringJoiner(delimiter);
    for(CharSequence cs : elements){
        join.add(cs);
    }
    return joiner.toString();
}

這個方法是的屬性有：public公有的、static靜态的。

參數：delimiter

字元序列，String也屬于字元序列

參數：【Object…】elements

字元序列組，用于依次拼接在delimter結尾

參數：【Interable <? extends CharSequence>】elements

實作Interator的對象

傳回值：String類型

傳回值說明：傳回将elements中的字元序列拼接在delimiter的String對象。

該方法注意點：

實作Interable的類可以調用Interator()方法。

2. toLowerCase重載方法

該方法的作用是将字元全部轉換成小寫。

public String toLowerCase(){
    return toLowerCase(Locale.getDefault());
}

public String toLowerCase(Locale locale){
    if(locale == null){
        throw new NullPointerExcetpion();
    }

    int firstUpper;
    final int len = value.length;

    //檢查是否需要本身就是大寫，如果是的話就不需要轉
    scan:{
        for(firstUpper = ; firstUpper<len;){
            char c = value[firstUpper];
            if((c>=Character.MIN_HIGH_SURROGATE)
                && (C<=Character.toLowerCase(Character.MAX_HIGH_SURROGATE))){
                int supplChar = codePointAt(firstUpper);
                if(supplChar != Character.toLowerCase(supplChar)){
                    break scan;
                }
                //确定表示指定字元（Unicode代碼點）所需的char值的數目。
                //如果指定字元等于或大于0x10000，則該方法傳回2。否則，該方法傳回1。
                firstUpper += Character.charCount(supplChar);
            }else{
                if(c != Character.toLowerCase(c)){
                    break scan;
                }
                firstUpper++;
            }
        }
        return this;
    }

    char[] result = new char[len];
    int resultOffset = ;

    //結果可能會增長，是以i+resultOffset是結果中的寫入位置。
    System.arraycopy(value, , result, , firstUpper);

    String lang = locale.getLanguage();
    boolean localeDependent = 
            (hljs-string">"tr" || hljs-string">"az" || hljs-string">"lt");
    char[] lowerCharArray;
    int lowerChar;
    int srcChar;
    int srcCount;
    for(int i=firstUpper; i<len; i+=srcCount){
        srcChar = (int)value[i];
        if((char)srcChar >= Character.MIN_HIGH_SURROGATE
            && (char)srcChar <= Character.MAX_HIGH_SURROGATE){
            srcCount = codePointAt(i);
            srcCount = Character.charCount(srcChar);
        }eles{
            srcCount = ;
        }
        if(localeDependent || 
                srcChar=='\u03A3' || //希臘大寫字母西格瑪
                srcChar == '\u0130') {//拉丁文大寫字母I
            lowerChar = ConditionalSpecialCasing.toLowerCaseEx(this, i, locale);
        }else{
            lowerChar = Character.toLowerCase(srcChar);
        }
        if((lowerChar==Character.ERROR)
                || (lowerChar>=Character.MIN_SUPPLEMENTARY_POINT)){
            if(lowerChar == Character.ERROR){
                lowerCharArray = ConditionalSpecialCasing.toLowerCaseCharArray(
                                    this, i, locale);
            }else if(srcCount == ){
                resultOffset += Character.toChars(lowerChar, result, 
                                    i+resultOffset) - srcCount;
                continue;
            }else{
                lowerCharArray = Character.toChars(lowerChar);
            }
            int maplen = lowerCharArray.length;
            if(mapLen > srcCount){
                char[] result2 = new char[result.length + maplen -srcCount];
                System.arraycopy(result, , result2, , i + resultOffset);
                result = result2;
            }
            for(int x=; x<mapLen;++x){
                result[i+resultOffset+x] = lowerCharArray[x];
            }
            resultOffset += (mapLen - srcCount);
        }esle{
            result[i+resultOffset] = (char)lowerChar;
        }
    }
    return new String(result, , len+resultOffset);
}

這個方法是的屬性有：public公有。

參數：locale

國際化對象，裡面存儲了一些國際化的資訊，比如語言方式等

傳回值：String類型

傳回值說明：傳回該字元串的小寫字元序列。

該源碼的思路是：

<1>如果本身字母就都是小寫的話，傳回this字元串。

<2>如果不是則傳回小寫字元序列

3.toUpperCase重載方法

該方法會傳回this字元序列轉成大寫的形式。

public String toUpperCase(){
    return toUpper(Locale.getDefault());
}

public String toUpperCase(Locale locale) {
    if (locale == null) {
        throw new NullPointerException();
    }

    int firstLower;
    final int len = value.length;

    /* Now check if there are any characters that need to be changed. */
    scan: {
        for (firstLower =  ; firstLower < len; ) {
            int c = (int)value[firstLower];
            int srcCount;
            if ((c >= Character.MIN_HIGH_SURROGATE)
                    && (c <= Character.MAX_HIGH_SURROGATE)) {
                c = codePointAt(firstLower);
                srcCount = Character.charCount(c);
            } else {
                srcCount = ;
            }
            int upperCaseChar = Character.toUpperCaseEx(c);
            if ((upperCaseChar == Character.ERROR)
                    || (c != upperCaseChar)) {
                break scan;
            }
            firstLower += srcCount;
        }
        return this;
    }

    /* result may grow, so i+resultOffset is the write location in result */
    int resultOffset = ;
    char[] result = new char[len]; /* may grow */

    /* Just copy the first few upperCase characters. */
    System.arraycopy(value, , result, , firstLower);

    String lang = locale.getLanguage();
    boolean localeDependent =
            (lang == "tr" || lang == "az" || lang == "lt");
    char[] upperCharArray;
    int upperChar;
    int srcChar;
    int srcCount;
    for (int i = firstLower; i < len; i += srcCount) {
        srcChar = (int)value[i];
        if ((char)srcChar >= Character.MIN_HIGH_SURROGATE &&
            (char)srcChar <= Character.MAX_HIGH_SURROGATE) {
            srcChar = codePointAt(i);
            srcCount = Character.charCount(srcChar);
        } else {
            srcCount = ;
        }
        if (localeDependent) {
            upperChar = ConditionalSpecialCasing.toUpperCaseEx(this, i, locale);
        } else {
            upperChar = Character.toUpperCaseEx(srcChar);
        }
        if ((upperChar == Character.ERROR)
                || (upperChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {
            if (upperChar == Character.ERROR) {
                if (localeDependent) {
                    upperCharArray =
                            ConditionalSpecialCasing.toUpperCaseCharArray(
                                        this, i, locale);
                } else {
                    upperCharArray = Character.toUpperCaseCharArray(srcChar);
                }
            } else if (srcCount == ) {
                resultOffset += Character.toChars(upperChar, result, 
                                        i + resultOffset) - srcCount;
                continue;
            } else {
                upperCharArray = Character.toChars(upperChar);
            }

            /* Grow result if needed */
            int mapLen = upperCharArray.length;
            if (mapLen > srcCount) {
                char[] result2 = new char[result.length + mapLen - srcCount];
                System.arraycopy(result, , result2, , i + resultOffset);
                result = result2;
            }
            for (int x = ; x < mapLen; ++x) {
                result[i + resultOffset + x] = upperCharArray[x];
            }
            resultOffset += (mapLen - srcCount);
        } else {
            result[i + resultOffset] = (char)upperChar;
        }
    }
    return new String(result, , len + resultOffset);
}

這個方法是的屬性有：public公有。

參數：locale

國際化對象，裡面存儲了一些國際化的資訊，比如語言方式等

傳回值：String類型

傳回值說明：傳回該字元串的大寫字元序列。

該源碼的思路是：

<1>如果本身字母就都是大寫的話，傳回this字元串。

<2>如果不是則傳回大寫字元序列

4. trim（）方法

該方法的作用将this字元串中首尾的空字元串除去，然後将其傳回。

public String trim(){
    int len = value.length;
    int st = ;
    char[] val = value;

    while((st<len) && (val[st]<='')){
        st++;
    }
    while((st<len) && (val[len-]<='')){
        len--;
    }
    return ((st>)||(len<value.length))?substring(st,len):this;
}

這個方法是的屬性有：public公有。

傳回值：String類型

傳回值說明：傳回該字元串除去首尾空字元的字元串。

該源碼思路：

<1>用一個st記錄this字元串開始有幾個空字元。

<2>用一個len記錄this字元串結尾處往回數有幾個空字元。

<3>如果st或len有一個大于0，則切割字元串，傳回首尾除去空字元的字元串。

<4>否則傳回this對象。

5. toString（）方法

傳回this對象，即字元串本身的字元。

public String toString(){
    return this;
}

這個方法是的屬性有：public公有。

傳回值：String字元串

傳回值說明：傳回this對象。

Java源碼___String類（九）

繼續閱讀

第二十二講 HashSet和HashMap、疊代器、TreeMap集合、Collections工具類、JDK8之Optional類

java轉換大小寫

java源碼分析---LinkedList

sql trim()以及translate()，replace()函數介紹與舉例

固态硬碟SSD優化--fstrim指令

java源碼分析之集合架構 ArrayList和LinkedList的差別05

Collections.emptyList() 和 Collections.EMPTY_LIST的差別

《Java困惑》：多并發情況下HashMap是否還會産生死循環《Java困惑》：多并發情況下HashMap是否還會産生死循環

java容器源碼分析--HashMap（JDK1.8）

關于java中的AbstractStringBuilder中的其他方法分析(源碼分析)

Java源碼___StringBuffer類（二）

JAVA實作對字元串的大小寫的轉換

都是ß惹的禍

寫一個字元串轉成駝峰的方法

java源碼分析：ArrayList的擴容機制

進一步評估了EP、EP/7.5%TFXBJ和CNC1的粘接性能，首先分别研究了三個體系的樣品在UV光固化，光-熱雙固化以