[Guava源码日报]（2）Strings分析

我们先看大体看一下Strings的源码：

1. //
2. // Source code recreated from a .class file by IntelliJ IDEA
3. // (powered by Fernflower decompiler)
4. //
6. package com.google.common.base;
8. import com.google.common.annotations.GwtCompatible;
9. import com.google.common.annotations.VisibleForTesting;
10. import com.google.common.base.Preconditions;
11. import javax.annotation.CheckReturnValue;
12. import javax.annotation.Nullable;
14. @CheckReturnValue
15. @GwtCompatible
16. public final class Strings {
17.    private Strings() {
18.    }
20.    public static String nullToEmpty(@Nullable String string) {
21.        return string == null?"":string;
22.    }
24.    @Nullable
25.    public static String emptyToNull(@Nullable String string) {
26.        return isNullOrEmpty(string)?null:string;
27.    }
29.    public static boolean isNullOrEmpty(@Nullable String string) {
30.        return string == null || string.length() == 0;
31.    }
33.    public static String padStart(String string, int minLength, char padChar) {
34.        Preconditions.checkNotNull(string);
35.        if(string.length() >= minLength) {
36.            return string;
37.        } else {
38.            StringBuilder sb = new StringBuilder(minLength);
40.            for(int i = string.length(); i < minLength; ++i) {
41.                sb.append(padChar);
42.            }
44.            sb.append(string);
45.            return sb.toString();
46.        }
47.    }
49.    public static String padEnd(String string, int minLength, char padChar) {
50.        Preconditions.checkNotNull(string);
51.        if(string.length() >= minLength) {
52.            return string;
53.        } else {
54.            StringBuilder sb = new StringBuilder(minLength);
55.            sb.append(string);
57.            for(int i = string.length(); i < minLength; ++i) {
58.                sb.append(padChar);
59.            }
61.            return sb.toString();
62.        }
63.    }
65.    public static String repeat(String string, int count) {
66.        Preconditions.checkNotNull(string);
67.        if(count <= 1) {
68.            Preconditions.checkArgument(count >= 0, "invalid count: %s", new Object[]{Integer.valueOf(count)});
69.            return count == 0?"":string;
70.        } else {
71.            int len = string.length();
72.            long longSize = (long)len * (long)count;
73.            int size = (int)longSize;
74.            if((long)size != longSize) {
75.                throw new ArrayIndexOutOfBoundsException("Required array size too large: " + longSize);
76.            } else {
77.                char[] array = new char[size];
78.                string.getChars(0, len, array, 0);
80.                int n;
81.                for(n = len; n < size - n; n <<= 1) {
82.                    System.arraycopy(array, 0, array, n, n);
83.                }
85.                System.arraycopy(array, 0, array, n, size - n);
86.                return new String(array);
87.            }
88.        }
89.    }
91.    public static String commonPrefix(CharSequence a, CharSequence b) {
92.        Preconditions.checkNotNull(a);
93.        Preconditions.checkNotNull(b);
94.        int maxPrefixLength = Math.min(a.length(), b.length());
96.        int p;
97.        for(p = 0; p < maxPrefixLength && a.charAt(p) == b.charAt(p); ++p) {
98.            ;
99.        }
101.        if(validSurrogatePairAt(a, p - 1) || validSurrogatePairAt(b, p - 1)) {
102.            --p;
103.        }
105.        return a.subSequence(0, p).toString();
106.    }
108.    public static String commonSuffix(CharSequence a, CharSequence b) {
109.        Preconditions.checkNotNull(a);
110.        Preconditions.checkNotNull(b);
111.        int maxSuffixLength = Math.min(a.length(), b.length());
113.        int s;
114.        for(s = 0; s < maxSuffixLength && a.charAt(a.length() - s - 1) == b.charAt(b.length() - s - 1); ++s) {
115.            ;
116.        }
118.        if(validSurrogatePairAt(a, a.length() - s - 1) || validSurrogatePairAt(b, b.length() - s - 1)) {
119.            --s;
120.        }
122.        return a.subSequence(a.length() - s, a.length()).toString();
123.    }
125.    @VisibleForTesting
126.    static boolean validSurrogatePairAt(CharSequence string, int index) {
127.        return index >= 0 && index <= string.length() - 2 && Character.isHighSurrogate(string.charAt(index)) && Character.isLowSurrogate(string.charAt(index + 1));
128.    }
129. }

现在我们具体看一下每个方法具体含义以及使用方式：

（1）私有构造器

1. private Strings() {}

静态方式使用strings,所以不需要使用权限为public的构造器,设置为private更合理。

（2）isNullOrEmpty

1. public static boolean isNullOrEmpty(@Nullable String string) {
2.     return string == null || string.length() == 0;
3. }

@Nullable 表示该参数变量可以为空。

含义：如果传入的参数string变量为null或者为空，则返回true，否则返回false。

（3）nullToEmpty

1. public static String nullToEmpty(@Nullable String string) {
2.     return string == null?"":string;
3. }

含义：如果传入的参数string变量不为null，则返回该string变量，否则返回空字符串。使用此方法的目的是使null转换为空字符串。

（4）emptyToNull（@Nullable String string）

1. @Nullable
2. public static String emptyToNull(@Nullable String string) {
3.    return isNullOrEmpty(string) ? null : string;
4. }

含义：

如果传入的参数string变量不为空或者null，则返回该string变量，否则返回null。使用此方法的目的是使空字符串转换为null。

（5）padStart（String string,int minLength,char padChar） 

含义：

从开始位置使用padChar传入的字符补全字符串，长度至少为minLength。即如果如果给定的字符串的长度已经大于minLength，则不用补全字符串。

举例：

1. // 使用字符0从开始位置填充补全字符串，长度至少为5
2. String padStartResult = Strings.padStart("123", 5, '0');
3. System.out.println("padStartResult is " + padStartResult);
5. // 使用字符0从开始位置填充补全字符串，长度至少为3
6. String padStartResult2 = Strings.padStart("12345", 3, '0');
7. System.out.println("padStartResult is " + padStartResult2);

结果：

1. padStartResult is 00123
2. padStartResult is 12345

源码分析：

1.    /**
2.     *
3.     * @param string 待补全字符串
4.     * @param minLength 补全后的长度至少为minLength
5.     * @param padChar 填充的字符
6.     * @return 返回补全后的字符串
7.     */
8.    public static String padStart(String string, int minLength, char padChar) {
9.        // 先决条件 检查是否为null
10.        Preconditions.checkNotNull(string);
11.        // 如果字符串本身长度大于minLength（最低要求）则直接返回
12.        if(string.length() >= minLength) {
13.            return string;
14.        }
15.        // 如果不够minLength，则需要填充
16.        else {
17.            // 开辟minLength大小空间
18.            StringBuilder sb = new StringBuilder(minLength);
19.            // 使用padChar字符在字符串开始填充直至达到minLength
20.            for(int i = string.length(); i < minLength; ++i) {
21.                sb.append(padChar);
22.            }
23.            sb.append(string);
24.            return sb.toString();
25.        }
26.    }

注意：待补全字符串string不能为null，否则抛出异常

（6）padEnd（String string,int minLength,char padChar） 

含义：

从字符串后使用padChar字符填充字符串，使长度达到minLength。如果如果给定的字符串的长度已经大于等于minLength，则不用补全字符串。

举例：

1. // 使用字符0从字符串末尾填充补全字符串，长度不足6进行补全
2. String padEndResult = Strings.padEnd("123", 6, '0');
3. System.out.println("padEndResult is " + padEndResult);
5. // 使用字符0从字符串末尾填充补全字符串，长度至不足3进行补全
6. String padEndResult2 = Strings.padEnd("12345", 4, '0');
7. System.out.println("padEndResult is " + padEndResult2);

结果：

1. padEndResult is 123000
2. padEndResult is 12345

源码分析：

1.    /**
2.     *
3.     * @param string 待补全字符串
4.     * @param minLength 补全后的长度至少为minLength
5.     * @param padChar 填充字符
6.     * @return 返回补全后的字符串
7.     */
8.    public static String padEnd(String string, int minLength, char padChar) {
9.        // 先决条件 检查是否为null
10.        Preconditions.checkNotNull(string);
11.        // 如果字符串本身长度大于等于minLength（最低要求）则直接返回
12.        if(string.length() >= minLength) {
13.            return string;
14.        }
15.        // 如果不够minLength，则需要填充
16.        else {
17.            // 开辟minLength大小空间
18.            StringBuilder sb = new StringBuilder(minLength);
19.            sb.append(string);
20.            // 使用padChar字符在字符串后填充直至字符串长度达到minLength
21.            for(int i = string.length(); i < minLength; ++i) {
22.                sb.append(padChar);
23.            }
24.            return sb.toString();
25.        }
26.    }

（7）repeat（String string,int count）

含义：

举例：

1. String repeatStr = Strings.repeat("123",3);
2. System.out.println("repeatStr is " + repeatStr);
4. String repeatStr2 = Strings.repeat("12",0);
5. System.out.println("repeatStr is " + repeatStr2);

结果：

1. repeatStr is 123123123
2. repeatStr is

源码分析：

1. /**
2.     *
3.     * @param string 待重复字符串
4.     * @param count 重复次数
5.     * @return
6.     */
7.    public static String repeat(String string, int count) {
8.        // 先决条件 检查是否为null
9.        Preconditions.checkNotNull(string);
10.        // 重复次数小于等于1
11.        if(count <= 1) {
12.            // 重复次数必须大于等于0 小于0报非法参数异常
13.            Preconditions.checkArgument(count >= 0, "invalid count: %s", new Object[]{Integer.valueOf(count)});
14.            // 如果重复次数为0则返回空字符串
15.            return count == 0?"":string;
16.        }
17.        // 重复次数大于1
18.        else {
19.            int len = string.length();
20.            // 计算重复后的大小
21.            long longSize = (long)len * (long)count;
22.            // long 防止溢出
23.            int size = (int)longSize;
24.            // 判断是否溢出 抛出数组下标越界异常
25.            if((long)size != longSize) {
26.                throw new ArrayIndexOutOfBoundsException("Required array size too large: " + longSize);
27.            }
28.            else {
29.                // 开辟size大小空间
30.                char[] array = new char[size];
31.                // 把这个字符串中的[0,len)区间字符复制到目标字符数组[0,len)区间
32.                string.getChars(0, len, array, 0);
33.                int n;
34.                for(n = len; n < size - n; n <<= 1) {
35.                    // 复制源数组中[0,n)区间数据到目标数组[n,2n)区间中
36.                    System.arraycopy(array, 0, array, n, n);
37.                }
38.                // 复制源数组中[0,size - n)区间数据到目标数组[n,size)区间中
39.                System.arraycopy(array, 0, array, n, size - n);
40.                return new String(array);
41.            }
42.        }
43.    }

备注：

1. public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

java.lang.String.getChars() 方法从这个字符串中的字符复制到目标字符数组。要复制的第一个字符在索引srcBegin处，被复制的最后一个字符是在srcEnd-1位置，即要复制的字符区间为[srcBegin，srcEnd）。字符被复制到子数组的dstBegin位置。

1. public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

复制指定的源容器数据到目标容器，从源容器指定的位置开始，复制到目标容器的指定位置。src容器的[srcPos,srcPos+len)区间数据复制到目标容器的[destPos,destPos+len)区间。

注意：count必须大于等于0，否则报非法参数异常。

（8）validSurrogatePairAt(CharSequence string, int index)

含义：

判断最后两个字符是不是合法的“Java 平台增补字符”

源码分析：

1.    @VisibleForTesting
2.    static boolean validSurrogatePairAt(CharSequence string, int index) {
3.        return index >= 0 && index <= string.length() - 2 && Character.isHighSurrogate(string.charAt(index)) && Character.isLowSurrogate(string.charAt(index + 1));
4.    }

Character.isHighSurrogate   确定给定char值是Unicode高代理项代码单元(也称为高级代理项代码单元)。这个值并不代表字符本身，而是在UTF-16编码的补充的字符的表示被使用。

Character.isLowSurrogate  确定给定char值是否为一个Unicode低代理项代码单元（也称为尾部代理项代码单元）。这些值并不代表本身的字符，但用于表示增补字符的UTF-16编码。

（9）commonPrefix（CharSequence a, CharSequence b）

含义：

获得两个字符串相同的前缀

举例：

1. // 相同前缀
2. String a = "com.qunar.exercise.exception";
3. String b = "com.qunar.exercise.log";
4. String ourCommonPrefix = Strings.commonPrefix(a,b);
5. System.out.println("a,b common prefix is " + ourCommonPrefix);

结果：

1. a,b common prefix is com.qunar.exercise.

源码分析：

1. /**
2.     *
3.     * @param a 字符序列a
4.     * @param b 字符序列b
5.     * @return 公共前缀
6.     */
7. public static String commonPrefix(CharSequence a, CharSequence b) {
8.        // Preconditions.checkNotNull 先决条件 判断是否为null
9.        checkNotNull(a);
10.        checkNotNull(b);
11.        // 两者最小长度（公共前缀不超过两者的最小长度）
12.        int maxPrefixLength = Math.min(a.length(), b.length());
13.        // 从字符串开始比较是否相同直至失败
14.        int p = 0;
15.        while (p < maxPrefixLength && a.charAt(p) == b.charAt(p)) {
16.            p++;
17.        }
18.        // 判断最后两个字符是不是合法的“Java 平台增补字符”
19.        if (validSurrogatePairAt(a, p - 1) || validSurrogatePairAt(b, p - 1)) {
20.            p--;
21.        }
22.        return a.subSequence(0, p).toString();
23. }

（10）commonSuffix（CharSequence a, CharSequence b）

含义：

获得两个字符串相同的后缀

举例：

      // 相同后缀

1. String c = "com.google.Hello";
2. String d = "com.jd.Hello";
3. String ourSuffix = Strings.commonSuffix(c,d);
4. System.out.println("c,d common suffix is " + ourSuffix);

结果：

1. c,d common suffix is .Hello

源码分析：

1. /**
2.     *
3.     * @param a 字符序列a
4.     * @param b 字符序列b
5.     * @return 公共后缀
6.     */
7. public static String commonSuffix(CharSequence a, CharSequence b) {
8.        // Preconditions.checkNotNull 先决条件 判断是否为null
9.        Preconditions.checkNotNull(a);
10.        Preconditions.checkNotNull(b);
11.        // 两者最小长度（公共后缀不超过两者的最小长度）
12.        int maxSuffixLength = Math.min(a.length(), b.length());
13.        int s;
14.        // 从字符串末尾开始比较，查看是否相同直至失败
15.        for(s = 0; s < maxSuffixLength && a.charAt(a.length() - s - 1) == b.charAt(b.length() - s - 1); ++s) {
16.            ;
17.        }
18.        // 判断最后两个字符是不是合法的“Java 平台增补字符” ?
19.        if(validSurrogatePairAt(a, a.length() - s - 1) || validSurrogatePairAt(b, b.length() - s - 1)) {
20.            --s;
21.        }
22.        return a.subSequence(a.length() - s, a.length()).toString();
23. }