Java源码___String类（六）

 java.lang.String分析摘要：
<1>startsWith 重载方法
<2>endsWith（String suffix）
<3>hashCode（）
<4>indexOf重载方法

1.startsWith重载方法
 该方法的作用是：判断字符串是否是否以实参字符串开头，是返回true,否则返回false。

//判断本字符串是否以实参prefix开头
//prefix：用于比较的字符串
 public boolean startWith(String prefix){
     return startWith(prefix, 0);
 }

public boolean startsWith(String prefix, int toffset){
    char[] ta = value;
    int to = toffset;
    char[] pa = prefix.value;
    int po = 0;
    int pc = prefix.value.length;
    if((toffset<0) || (toffset>value.length - pc)){
        return false;
    }
    while(--pc >= 0){
        if(ta[to++] != pa[po++]){
            return false;
        }
    }
    return true;
}

这个方法是的属性有：public公有的。
参数：prefix要被比较的开始字符串
参数：toffset该字符串开头比较的位置，取值为下标
 
返回值：boolean类型
返回值说明：根据规则的情况下，符合要求（以prefix结尾）返回true，否则返回false。
 
2. endsWith（String suffix）方法
 该方法与startWith相对应，判断的是本字符串是否以实参字符串结尾。

public boolean endsWith(String suffix){
    reutn startWith(suffix, value.length-suffix.value.length);
}

这个方法是的属性有：public公有。
参数：suffix 要比较结尾的字符串
返回值：boolean类型
返回值说明：如果本字符串是以suffix结尾，则返回true。否则返回false。

 该源码的思路是：
<1>通过value.length - suffix.value.length来确定suffix在本字符串的下标。
<2>然后通过startsWith（suffix, value.length-suffix.value.length）来简介达到比较结尾的目的。
 

3.hashCode（）方法
 该方法重写了Object类的hashCode方法，返回一个hash值。

public int hashCode(){
    int h = hash;
    if(h==0 && value.length>0){
        char[] val = value;
        for(int i=0; i<value.length; i++){
            h = 31*h+value[i];
        }
        hash = h;
    }
    return h;
}

这个方法是的属性有：public公有。
返回值：int
返回值说明：返回该字符串的散列值。

 该方法的源码思路是：
<1>判断字符串的hash值是否为0，如果为0，并且长度大于0，则给hash进行赋值。
<2>返回hash值。
 

4. indexOf重载方法

 该方法返回实参字符在本字符串第一次出现的位置（下标），如果没有，则返回-1。

//从某下标开始，返回寻找第一个出现字符ch的下标，如果没找到则返回-1.
public int indexOf(int ch, int formIndex){
    final int max = value.length;
    if(formIndex < 0){
        formIndex = 0;
    }else if(formIndex >= max){
        return -1;
    }

    //Charater.MIN_SUPPLEMENTARY_CODE_POINT：65536 [0x10000]
    if(ch < Charater.MIN_SUPPLEMENTARY_CODE_POINT){
        final char[] value = this.value;
        for(int i=formIndex; i<max; i++){
            if(value[i] == ch){
                return i;
            }
        }
        return -1;
    }else{
        return indexOfSupplementary(ch,formIndex);
    }
}

//从本字符串开头开始寻找字符ch，找到则返回下标位置。没找到则返回-1
public int indexOf(int ch){
    return indexOf(ch, 0);
}

//source：      源字符数组（从该数组从寻找target数组的位置）
//sourceOffset：源字符数组的偏移位置（下标）
//sourceCount： 源字符数组的长度
//target：       要寻找的字符数组
//targetOffset：要寻找的字符数组的偏移位置
//targetCount： 要寻找的字符数组的长度
//formIndex：    要开始寻找的位置
static int indexOf(char[] source, int sourceOffset, int sourceCount, 
                    char[] target, int targetOfsset, int targetCount,
                    int fromIndex){
    if(fromIndex >= sourceCount){
        return (targetCount==0 ? sourceCount : -1);
    }
    if(fromIndex < 0){
        fromIndex = 0;
    }
    if(targetCount == 0){
        return fromIndex;
    }
    char first = target[targetOffset];
    //max这边是最大偏移的位置（下标）
    int max = sourceOffset + (sourceCount - targetCount);
    for(int i=sourceOffset+fromIndex; i<= max; i++){
        if(source[i] != first){
            while(++i <= max && sorce[i]!= first);
        }
        if(i < max){
            int j = i+1;
            int end = j+targetCount-1;
            for(int k=targetOffset+1; j<end&&source[i]==target[k]; j++,k++);
            if(j == end){
                return i-sourceOffset;
            }
        }
    }
    return -1
}

static int indexOf(char[] source, int sourceOffset, int sourceCount, 
                    String target, int fromIndex){
    return indexOf(source, sourceOffset, sourceCount, target.value, 0, 
                    target.value.length, fromIndex);
}

//从本字符串的下标fromIndex开始查找字符串str第一次出现的下标
public int indexOf(String str, int fromIndex){
    return indexOf(value, 0, value.length, 
                    str.value, 0, str.value.length, fromIndex);
}

//返回从本字符串开头开始查找字符串str第一次出现的下标
public int indexOf(String str){
    return (str, 0);
}

这个方法是的属性有：public公有。
参数：ch可以传一个字符，将会被解析成int类型【其值为Unicode的解码值】
参数：formIndex从本字符串开始比较的下标
返回值：int
返回值说明：寻找ch在本字符串中出现的位置，如果没找到则返回-1。

 方法细节注意点：该方法中有句代码ch < Character.MIN_SUPPLEMENTARY_CODE_POINT，其中MIN_SUPPLEMENTARY_CODE_POINT等于十进制的65536，刚好是两个字节的界限。
该源码思路为：
<1>判断formIndex的位置，如果大于本字符串的长度，则返回-1。
<2>如果小于0，则下标按照0计算。然后进行寻找。
<3>如果找到字符则返回字符的位置，否则返回-1。

5. indexOfSupplementary(int ch, int fromIndex)方法

 这是String类中index方法中会调用的私有方法。

private int indexOfSupplementary(int ch, int fromIndex){
    if(Character.isValidCodePoint(ch)){
        final char[] value = this.value;
        final char hi = Character.hightSurrogate(ch);
        final char lo = Character.lowSurrogate(ch);
        final int max = value.length-1;
        for(int i = fromIndex; i<max; i++){
            if(value[i]==hi && value[i++]==lo){
                return i;
            }
        }
    }
    return -1;
}

这个方法是的属性有：private私有。
参数：ch可以传一个字符，将会被解析成int类型【其值为Unicode的解码值】
参数：formIndex从本字符串开始比较的下标
返回值：int
返回值说明：寻找ch在本字符串中出现的位置，如果没找到则返回-1。

 方法补充：该方法是使用辅助字符来处理索引调用。