JDK 1.8 String

只是简单谈谈,没啥可说的,不全面覆盖

  1. String为final类不能被继承。其实就是一个final的char数组。
  2. 看看好多人都比较困惑的字符串比较问题。
    // original = "你好吗"
    private static void t1(String original) {
        String o = "你好吗";
        String j = o;
        String j1 = new String(o);
        StringBuilder j2 = new StringBuilder(original);
        System.out.println(original == o);
        System.out.println(original == j);
        System.out.println(original.equals(j));
        System.out.println("=====");
        System.out.println(original == j1);
        System.out.println(original.equals(j1));
        System.out.println("=====");
        System.out.println(j.equals(j2));
        System.out.println(j.contentEquals(j2));
        System.out.println("=====");
        //System.out.println("abc".equals("ABC"));
        //System.out.println("abc".equalsIgnoreCase("ABC"));
    }
输出:
  true 比较引用地址
  true 比较引用地址
  true 看equals源码,比较引用地址
  =====
  false j1 对象指向的是一块新的内存地址,所以 == 比较后地址不同返回 false
  true  看 equals 源码,在判断(if (anObject instanceof String)) j1 为 String 类型后,采用相同角标循环遍历判断2个 char 数组中的值是否相同。比较后值相同返回 true
  =====
  false 首先 j2 是一个 StringBuilder 类型的对象。再看 equals 源码,得知此方法有2处判断,第一为几类型引用地址判断,第二种为是否是 String 类型判断。因为 j2 为一个 StringBuilder 类型,j2 的引用又与 j 的不同,所以该方法返回 false
  true  这怎么就又为 true 了呢?查看 contentEquals 源码可知,StringBuilder 继承了 AbstractStringBuilder ,所以 j2 为 AbstractStringBuilder 类型,然后根据类型判断进入到了 nonSyncContentEquals() 方法,首选判断长度,其次比较相同索引下 char 数组中的值。所以返回 true
  =====

源码如下:

    public boolean equals(Object anObject) {
        // 基本类型比较或者比较对象的引用地址
        if (this == anObject) { 
            return true;
        }
        // 判断 anObject 是否为 String 类型
        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) {
                    // 比对2个 char 数组中每个位置上的值是否相等,如有不等,返回 false
                    if (v1[i] != v2[i]) 
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

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

    private boolean nonSyncContentEquals(AbstractStringBuilder sb) {
        char v1[] = value;
        char v2[] = sb.getValue();
        int n = v1.length;
        if (n != sb.length()) { // 长度不匹配,2串不相等
            return false;
        }
        for (int i = 0; i < n; i++) { // 相同角标值不同,2串不相等
            if (v1[i] != v2[i]) {
                return false;
            }
        }
        return true;
    }
  1. 说一下concat这个方法。其实很简单,通过2次数组的复制就可以实现。第一次为扩容char数组,第二次为填充要concatchar数组内容。
    public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        // 把之前的 char 数组拷贝到新的数组后返回
        char buf[] = Arrays.copyOf(value, len + otherLen); 
        // 把 str 的 char 数组添加到从 len 开始的位置上
        str.getChars(buf, len); 
        return new String(buf, true);
    }

    void getChars(char dst[], int dstBegin) {
        System.arraycopy(value, 0, dst, dstBegin, value.length);
    }
  1. 看一下 JDK 1.8 新加的一个小玩意 。意思是返回一个由elementsdelimiter分割的字符串
    public static String join(CharSequence delimiter, CharSequence... elements)
    public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements)
    private static void t2(String original) {
        System.out.println(String.join(",","a","b", "c", "d"));
        String[] strings = {"我", "爱", "小", "二", "狗儿"};
        System.out.println(String.join("->", Arrays.asList(strings)));
    }
输出:
  a,b,c,d
  我->爱->小->二->狗儿