Java源码___String类（五）

 java.lang.String分析摘要：
<1>regionMatches重载方法
<2>equalsIgnoreCase（String anotherString）
<3>compareTo（String anotherString）
<4>compareToIgnoreCase（String str）
<5>String类内置比较器

1.regionMatches重载方法
 该方法用于根据参数规则来比较字符串和实参字符串是否相等。

//比较两个字符串在某个区间内的字符是否相同，相同则返回true，否则返回false。
//toffset:该字符串要开始比较的位置，即下标
//other：要被比较的字符串
//ooffset：被比较的字符串开始进行比较的位置，即下标
//len：要比较的长度，即从开始比较的位置进行增加
public boolean regionMatches(int toffset, String other, int ooffset, int len){
    char[] ta = value;
    int to = toffset;
    char[] pa = other.value;
    int po = ooffset;
    //进行界限计算,如果越界就返回false
    if((to<0 || po<0) || (to>(long)value.length-len) 
                      || (po>(long)other.value.length-len)){
        return false;       
    }
    while(len-- > 0){
        if(ta[to++] != pa[po++]){
            return false;
        }
    }
    return true;
}

//该方法的与上个重载方法作用是一样的，只不过多了一个参数，决定是否忽略大小写差异
//ignoreCase:比较时是否忽略大小写差异
public boolean regionMatches(boolean ignoreCase, int toffset, String other, 
    int ooffset, int len){
    char[] ta = value;
    int to = toffset;
    char[] pa = other.value;
    int po = ooffset;
    if((to<0 || po<0) || (to>(long)value.length-len)
                      || (po>(long)other.value.length-len)){
        return false;
    }
    while(len-- >0){
        char c1 = ta[to++];
        char c2 = pa[po++];
        if(c1 == c2){
            continue;
        }
        if(ignoreCase){
            char u1 = Character.toUpperCase(c1);
            char u2 = Character.toUpperCase(c2);
            if(u1 == u2){
                continue;
            }
            if(Charcter.toLowerCase(u1) == Character.toLowerCase(u2)){
                continue;
            }
        }
    }
    return true;
}
//用指定的编码集将字符串编码，然后将编码后的byte数组返回
//charSetName：字符集名称，用于将字符串编码
public byte[] getBytes(String charsetName) throws UnsupportedEncodingException {
   if (charsetName == null) 
       throw new NullPointerException();
   return StringCoding.encode(charsetName, value, 0, value.length);
}

//使用平台默认的字符集将字符串编码成字节序列，然后将其返回
public byte[] getBytes(){
    return StringCoding.encode(value,0,value.length);
}

这个方法是的属性有：public公有。
返回值：boolean
返回值说明：按参数决定规则比较，相同返回true，否则返回false

 该方法的总结：String类的equals方法没有做非null判断，所以我们要自己注意一下，适当地做非null校验。
该源码的思路是：
<1>判断要比较的字符串范围是否越界，越界的话返回false。
<2>按照参数规则来依次比较字符是否相等，一旦有不相等，则返回fasle。
<3>如果没有忽略大小写，那么就会将字符全都转成大写比较，如果不相等，则转换成小写再比较依次。
<4>如果都相等，则返回true。
 

 注意：在字符转换成大写的时候，如果二者不相等，讲道理，转成小写也应该不相等。但是这边在退出来的时候又转换成小写判断一次是因为：大小写字母的转换对Georgian（格鲁吉亚）字母表不适用，所以这边再做了一次判断。
 
2. equalseIgnoreCase（String anotherString）方法
 比较String本身的字符是否和实参字符串的字符在忽略大小写差异的情况下是否相等。

 public boolean equalsIgnoreCase(String anotherString){
     return (this == anotherString) ? true : (anotherString!=null)
            &&(anotherString.value.length == value.length)
            &&regionMathes(true,0,anotherString,0,value.length);
 }

这个方法是的属性有：public公有。
返回值：boolean
返回值说明：忽略大小写差异的情况下比较两个字符串，相等返回true，否则返回false。

 
该源码的思路是：
<1>先判断实参是否属于本身，如果是则返回true。
<2>如果实参字符串为空，则返回false。
<3>如果两者的长度不相等，则返回false。
<4>调用regionMatches方法比较两者，并将结果返回。
 

3.compareTo（String anotherString）
 该方法是对两个字符串进行比较，根据结果返回不同的int值。

public int compareTo(String anotherString){
    int len1 = value.length;
    int len2 = anotherString.value.length;
    //min方法返回实参中比较小的值
    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;
}

这个方法是的属性有：public公有。
返回值：int
返回值说明：按照字典字母来排序来依次比较，如果该字符串比实参another大（靠后），则返回一个大于0的int值，小（靠前）则返回一个小于0的int值，如果都相等，则返回0。

 
4. compareToIgnoreCase（String str）方法

 该方法是忽视大小写差别，对两个字符串进行比较，根据结果返回不同的int值。

//String类的比较器。该比较器会在方法5中介绍
private static final Comparator<String> CASE_INSENSITIVE_ORDER = 
        new CaseInsensitiveComparator();

public int compareToIgnoreCase(String str){
    return CASE_INSENSITIVE_ORDER.compare(this,str);
}

这个方法是的属性有：public公有。
返回值：int
返回值说明：忽略大小写差异，按照字典字母来排序来依次比较，如果该字符串比实参another大（靠后），则返回一个大于0的int值，小（靠前）则返回一个小于0的int值，如果都相等，则返回0。

 
5. String类内置比较器

 这个是String类用来做比较的比较器介绍。

private static final CaseInsensitiveComparator implements Comparator<String>,
        java.io.Serializable{
    //序列化数值
    private static final long serialVersionUID = 8575799808933029326LL;

    //比较器的比较方法
    public int compare(String s1, String s2){
        int n1 = s1.length;
        int n2 = s2.length;
        int min = Math.min(s1,s2);
        for(int i=0; i<min; i++){
            char c1 = s1.charAt(i);
            char c2 = s2.charAt(i);
            if(c1 != c2){
                c1 = Character.toUpperCase(c1);
                c2 = Character.toUpperCase(c2);
                if(c1 != c2){
                    c1 = Character.toLowerCase(c1);
                    c2 = Character.toLowerCase(c2);
                    if(c1 != c2){
                        return c1 - c2;
                    }
                }
            }
        }
        return n1-n2;
    }

    //与反序列化有关的方法，这边暂时不做深入研究。
    private Object readResolve(){
        return CASE_INSENSITIVE_ORDER;
    }
}

该类具有的属性有：一个序列化数值，一个比较方法compare（）以及一个和反序列化有关的方法readResolv（）。