Guava源码解析二：Guava-Strings源码解析

构造器

private Strings() {

}

静态构造器，所以只能使用类直接调用静态方法来使用工具类中的方法

 

静态方法

对于Strings的方法可以分为三类进行分析

第一类是对字符串为null或空的处理

1.nullToEmpty(@Nullable String string)

如果非空，则返回给定的字符串；否则返回空字符串

源码实现为：

public static String nullToEmpty(@Nullable String string) {
    //如果string为null则返回空字符串，否则返回给定的string
    return string == null?"":string;
}

2.isNullOrEmpty(@Nullable String string)

如果字符串为空或长度为0返回true，否则返回false

源码实现为：

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

3.emptyToNull(@Nullable String string)

如果非空，则返回给定的字符串；否则返回null

源码实现为：

public static String emptyToNull(@Nullable String string) {
    //调用isNullOrEmpty方法，如果返回true则return null，否则返回原字符串
    return isNullOrEmpty(string)?null:string;
}

第二类是生成指定字符串的字符串副本

1.padStart(String string, int minLength, char padChar)

根据传入的minLength进行补充，如果minLength小于原来字符串的长度，则直接返回原来字符串，否则在字符串开头添加string.length()-minLength个padChar字符

源码实现为：

public static String padStart(String string, int minLength, char padChar) {
    //使用Preconditions工具类进行字符串验空处理   
    Preconditions.checkNotNull(string);
    //如果原字符串长度大于传入的新长度则直接返回原字符串
    if(string.length() >= minLength) {
        return string;
    } else { //否则
        StringBuilder sb = new StringBuilder(minLength);
        //先在字符串前面添加string.length()-minLength个padChar字符
        for(int i = string.length(); i < minLength; ++i) {
            sb.append(padChar);
        }
        //最后将原始字符串添加到尾部
        sb.append(string);
        return sb.toString();
    }
}

2.padEnd(String string, int minLength, char padChar)

根据传入的minLength进行补充，如果minLength小于原来字符串的长度，则直接返回原来字符串，否则在字符串结尾添加string.length()-minLength个padChar字符

源码实现为：

public static String padEnd(String string, int minLength, char padChar) {
    Preconditions.checkNotNull(string);   
    //如果原字符串长度大于传入的新长度则直接返回原字符串
    if(string.length() >= minLength) {
        return string;
    } else {
        StringBuilder sb = new StringBuilder(minLength);
        //先将原始字符串添加到预生成的字符串当中
        sb.append(string);
        //在使用padChar进行填补
        for(int i = string.length(); i < minLength; ++i) {
            sb.append(padChar);
        }
        return sb.toString();
    }
}

3.repeat(String string, int count)

返回count份string字符串拼接成的字符串

源码实现为：

public static String repeat(String string, int count) {
    Preconditions.checkNotNull(string);
    //如果小于1，则抛出异常
    if(count <= 1) {
        Preconditions.checkArgument(count >= 0, "invalid count: %s", new Object[]{Integer.valueOf(count)});
        return count == 0?"":string;
    } else {
        int len = string.length();
        long longSize = (long)len * (long)count;
        int size = (int)longSize;
        //如果新创建的字符串长度超出int最大值，则抛出需要的数组过长的异常
        if((long)size != longSize) {
            throw new ArrayIndexOutOfBoundsException((new StringBuilder(51)).append("Required array size too large: ").append(longSize).toString());
        } else {
            char[] array = new char[size];
            //讲string从0开始len结束之间的字符串复制到array数组中，且array数组从0开始存储
            string.getChars(0, len, array, 0);
            int n;
            //复制数组，复制的步长为（1,2,4...n^2），所以这快提供了一个外层循环为ln2的算法
            for(n = len; n < size - n; n <<= 1) {
                System.arraycopy(array, 0, array, n, n);
            }
            System.arraycopy(array, 0, array, n, size - n);
            return new String(array);
        }
    }
}

第三类为查找两个字符串的公共前缀或后缀

在说明commonPrefix和commonSuffix两个方法前我们需要解析完validSurrogatePairAt方法

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

他的用处为判断最后两个字符是不是合法的“Java 平台增补字符

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

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

 

1.commonPrefix(CharSequence a, CharSequece b)

返回a和b两个字符串的公共前缀

源码实现为：

public static String commonPrefix(CharSequence a, CharSequence b) {
    Preconditions.checkNotNull(a);
    Preconditions.checkNotNull(b);
    //将字符串a和字符串b两个中短的字符串长度赋值给maxPrefixLength
    int maxPrefixLength = Math.min(a.length(), b.length());
    int p;
    //遍历直到第一个两个字符不相等的位置
    for(p = 0; p < maxPrefixLength && a.charAt(p) == b.charAt(p); ++p) {
        ;
    }
    //判断需要截取的字符是否合法
    if(validSurrogatePairAt(a, p - 1) || validSurrogatePairAt(b, p - 1)) {
        --p;
    }
    return a.subSequence(0, p).toString();
}

2.commonSuffix(CharSequence a, CharSequence b)

返回字符串a和字符串b的公共后缀

源码实现为：

public static String commonSuffix(CharSequence a, CharSequence b) {
    Preconditions.checkNotNull(a);
    Preconditions.checkNotNull(b);
    //将字符串a和字符串b两个中短的字符串长度赋值给maxPrefixLength
    int maxSuffixLength = Math.min(a.length(), b.length());
    int s;
    //遍历直到第一个两个字符不相等的位置
    for(s = 0; s < maxSuffixLength && a.charAt(a.length() - s - 1) == b.charAt(b.length() - s - 1); ++s) {
        ;
    }
    if(validSurrogatePairAt(a, a.length() - s - 1) || validSurrogatePairAt(b, b.length() - s - 1)) {
        --s;
    }
    return a.subSequence(a.length() - s, a.length()).toString();
}