JDK源码之lang.String(三)String类中的常用方法

1.String类中的offsetByCodePoints(int index, int codePointOffset)方法：

    public int offsetByCodePoints(int index, int codePointOffset) {
        if (index < 0 || index > value.length) {
            throw new IndexOutOfBoundsException();
        }
        return Character.offsetByCodePointsImpl(value, 0, value.length,
                index, codePointOffset);
    }

返回由codePointoffset代码点从给定索引偏移的该字符串中的索引。

在由index和codePointOffset给出的文本范围内的未配对代理可以算作每个代码点。

示例：

package com.ftl813;

public class Test {

	public static void main(String[] args) {
		String str="abcdabcab";
		String str1="whdydd233453io";

		System.out.println(str1.offsetByCodePoints(1, 2));
		System.out.println(str1.offsetByCodePoints(1, 7));
		System.out.println(str1.offsetByCodePoints(4, 7));
	}
}

输出：

英文解释看的不是太懂，大概的意思是返回此 String字符串 中从给定的 index 处偏移 codePointOffset 个代码点后的索引。

试了例子之后，个人认为该方法要表达的意义是（以str1.offsetByCodePoints(1, 2)为例）从字符串str1的index为起点向后偏移codePointOffset之后的字符的索引。str1的1（index）的位置是'h'所在的位置，偏移2（codePointOffset）后所指的位置是‘y’所在的位置，索引为3。感觉返回的就是index+codePointOffset的值，没见过用这个方法的，应该不是常用方法。
 

2.String类中的getBytes(String charsetName)方法：

    public byte[] getBytes(String charsetName)
            throws UnsupportedEncodingException {
        if (charsetName == null) throw new NullPointerException();
        return StringCoding.encode(charsetName, value, 0, value.length);
    }

使用命名的字符集将此String编码为字节序列，将结果存储到新的字节数组中。

此字符串不能在给定字符集中编码时，此方法的行为是未指定的。

charsetName参数表示字符集编码方式

示例：

package com.ftl813;

import java.io.UnsupportedEncodingException;

public class Test {

	public static void main(String[] args) throws UnsupportedEncodingException {
		String str="abcdabcab";
		String str1="whdydd233453io";
		System.out.println(str1.getBytes("utf-8"));
		System.out.println(str1.getBytes("GBK"));
		System.out.println(str1.getBytes("gb2312"));
		System.out.println(str1.getBytes("Unicode"));
		
	}
}

输出：

当需要对编码过程进行更多控制时，应使用CharsetEncoder类

 

3.String类中的getBytes(Charset charset)方法：

    public byte[] getBytes(Charset charset) {
        if (charset == null) throw new NullPointerException();
        return StringCoding.encode(charset, value, 0, value.length);
    }

使用给定的charset将该String编码为一个字节序列，将结果存储到新的字节数组中。

此方法总是用此字符集的默认替换字节数组替换格式错误的输入和不可映射字符序列。

当需要对编码过程的更多控制时，应使用CharsetEncoder类。

根据英文解释来看和getBytes(String charsetName)方法相比此方法总是用此字符集的默认替换字节数组替换格式错误的输入和不可映射字符序列，但是我没有尝试出来有什么区别，问题先留下，看看到后面会不会解决。

 

4.String类中的 getBytes()方法：

    public byte[] getBytes() {
        return StringCoding.encode(value, 0, value.length);
    }

使用平台的默认字符集将此String编码为字节序列，将结果存储到新的字节数组中。

当字符串不能在默认字符集中编码时，此方法的行为是未指定的。 当需要对编码过程进行更多控制时，应使用CharsetEncoder类。

默认采用的是Sytem.getProperty("file.encoding"),即当前文件的编码方式，

 

5.String类中的equals(Object anObject)方法：

    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;
    }

将此字符串与指定对象进行比较。 其结果是true当且仅当该参数不是null并且是String对象，表示相同的字符序列作为该对象

解析：如果字符串与指定对象是同一个对象，则返回true；如果不是同一对象，再看指定对象是不是String类型的，如果不是返回false；如果是String类型的，比较两个字符串的长度，在比较字符串对应位置的值是否相等，如果完全相等返回true；否则返回false。

 关于==：

首先要知道==用于匹配内存单元上的内容，其实就是一个数字，计算机内部也只有数字，而在java语言中，当==匹配时，就是比对两个单元内存的内容是否一样。

      如果是原始类型，byte,boolean,short,char,int,long,float,double,就是直接比较他们的值。

      如果是引用，比较的就是引用的值，引用的值可以被认为是对象的逻辑地址，如果两个引用发生==操作，就是比较两个相应的对象的地址值是否一样，换句话说，如果两个引用保存的是同一个对象，则返回true,否则返回false。

 

6.String类中的contentEquals(StringBuffer sb)方法：

 public boolean contentEquals(StringBuffer sb) {
        return contentEquals((CharSequence)sb);
    }

将这个字符串与指定的StringBuffer进行比较。当且仅当这个字符串表示与指定的StringBuffer相同的字符序列时，结果是 true。这个方法在 StringBuffer上同步。是
contentEquals(StringBuffer sb)方法contentEquals(CharSequence cs)方法中的一种。

 

7.String类中的contentEquals(CharSequence cs)方法：

  public boolean contentEquals(CharSequence cs) {
        // Argument is a StringBuffer, StringBuilder
        if (cs instanceof AbstractStringBuilder) {
            if (cs instanceof StringBuffer) {
                synchronized(cs) {
                   return nonSyncContentEquals((AbstractStringBuilder)cs);
                }
            } else {
                return nonSyncContentEquals((AbstractStringBuilder)cs);
            }
        }
        // Argument is a String
        if (cs instanceof String) {
            return equals(cs);
        }
        // Argument is a generic CharSequence
        char v1[] = value;
        int n = v1.length;
        if (n != cs.length()) {
            return false;
        }
        for (int i = 0; i < n; i++) {
            if (v1[i] != cs.charAt(i)) {
                return false;
            }
        }
        return true;
    }

将此字符串与指定的CharSequence进行比较。 其结果是true如果并且如果该只String表示char值的相同序列与指定序列。 请注意，如果CharSequence是StringBuffer那么该方法将同步它。

 

比较boolean equals(Object anObject)和boolean contentEquals(CharSequence cs)方法：

这两个方法都可以用来比较String对象内容序列的异同，但也存在差异。

最大的差别就是String的equals方法只有在另一个对象是String的情况下才可能返回true，

而contentEquals只要求另一个对象是CharSequence或其子类的对象

CharSequence是一个接口，String、StringBuilder和StringBuffer都实现了CharSequence接口

 

8.String类中的nonSyncContentEquals(AbstractStringBuilder sb)方法：

private boolean nonSyncContentEquals(AbstractStringBuilder sb) {
        char v1[] = value;
        char v2[] = sb.getValue();
        int n = v1.length;
        if (n != sb.length()) {
            return false;
        }
        for (int i = 0; i < n; i++) {
            if (v1[i] != v2[i]) {
                return false;
            }
        }
        return true;
    }

将此字符串与指定的AbstractStringBuilder进行比较。 其结果是true如果并且如果该只String表示char值的相同序列与指定序列。

StringBuffer 和 StringBuilder 的源码时发现两者都继承了AbstractStringBuilder， AbstractStringBuilder和String一样，在其内部都是以字符数组的形式实现的。也就是String,StringBuffer以及StringBuilder在其内部都是以字符数组的形式实现的。

 

9.String类中的equalsIgnoreCase(String anotherString)方法：

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

将此字符串与指定的String进行比较。 其结果是true如果并且如果该只String表示char值的相同序列与指定序列。（字符串比较是忽略大小写）

 

10.String类中的compareTo(String anotherString)方法：

    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;
    }

按字典顺序比较两个字符串。 比较是基于字符串中每个字符的Unicode值。 由该String对象表示的字符序列按字典顺序与由参数字符串表示的字符序列进行比较。

如果String对象按字典顺序排列在参数字符串之前，结果为负整数。

结果是一个正整数，如果String对象按字典顺序跟随参数字符串。

如果字符串相等，结果为零; 当equals(Object)方法将返回true时，compareTo返回0  。

这是字典排序的定义。 如果两个字符串不同，则它们在某些索引处具有不同的字符，这两个字符串是两个字符串的有效索引，或者它们的长度不同，或两者都是不同的。 如果它们在一个或多个索引位置具有不同的字符，则令k为最小的索引; 那么在位置k处的字符具有较小值的字符串，如通过使用<运算符确定的，以字典顺序位于另一个字符串之前。 在这种情况下， compareTo返回两个字符串中位置k处的两个字符值的差值，即值：this.charAt(k)-anotherString.charAt(k)

如果没有它们不同的索引位置，则较短的字符串按字典顺序位于较长的字符串之前。 在这种情况下， compareTo返回字符串长度的差异 - 即值： this.length()-anotherString.length()

 

 

11.String类中的CASE_INSENSITIVE_ORDER属性：

    public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();

将字符串对象排序为compareToIgnoreCase的比较器。这个比较器是可序列化的。

注意,这个比较器不会考虑语言环境,并将导致不满意要求对某些场景文本包提供Collators允许对场景敏感的排序。

 

 

12.String类中的CaseInsensitiveComparator类：

 

    private static class CaseInsensitiveComparator
            implements Comparator<String>, java.io.Serializable {
        // use serialVersionUID from JDK 1.2.2 for interoperability
        private static final long serialVersionUID = 8575799808933029326L;

        public int compare(String s1, String s2) {
            int n1 = s1.length();
            int n2 = s2.length();
            int min = Math.min(n1, n2);
            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) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }

        /** Replaces the de-serialized object. */
        private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
    }

按字典顺序比较两个字符串。 比较是基于字符串中每个字符的Unicode值。 由该String对象表示的字符序列按字典顺序与由参数字符串表示的字符序列进行比较。 （忽略大小写）

 

13.String类中的compareToIgnoreCase(String str)方法：

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

按字典顺序比较两个字符串，忽略病例差异。 此方法返回一个整数，其标志是调用的compareTo与在不同的情况下已经被淘汰，通过调用字符串的规范化版本Character.toLowerCase(Character.toUpperCase(character))上的每一个字符。

请注意，此方法不场所考虑，并会导致特定的语言环境不满意的排序。 java.text包提供了整理器来允许区域设置敏感的排序

（忽略大小写）