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

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

 
 

//
  
  
// Source code recreated from a .class file by IntelliJ IDEA
  
  
// (powered by Fernflower decompiler)
  
  
//
  
  

  
  
package com.google.common.base;
  
  

  
  
import com.google.common.annotations.GwtCompatible;
  
  
import com.google.common.annotations.VisibleForTesting;
  
  
import com.google.common.base.Preconditions;
  
  
import javax.annotation.CheckReturnValue;
  
  
import javax.annotation.Nullable;
  
  

  
  
@CheckReturnValue
  
  
@GwtCompatible
  
  
public final class Strings {
  
  
    private Strings() {
  
  
    }
  
  

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

  
  
    @Nullable
  
  
    public static String emptyToNull(@Nullable String string) {
  
  
        return isNullOrEmpty(string)?null:string;
  
  
    }
  
  

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

  
  
    public static String padStart(String string, int minLength, char padChar) {
  
  
        Preconditions.checkNotNull(string);
  
  
        if(string.length() >= minLength) {
  
  
            return string;
  
  
        } else {
  
  
            StringBuilder sb = new StringBuilder(minLength);
  
  

  
  
            for(int i = string.length(); i < minLength; ++i) {
  
  
                sb.append(padChar);
  
  
            }
  
  

  
  
            sb.append(string);
  
  
            return sb.toString();
  
  
        }
  
  
    }
  
  

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

  
  
            for(int i = string.length(); i < minLength; ++i) {
  
  
                sb.append(padChar);
  
  
            }
  
  

  
  
            return sb.toString();
  
  
        }
  
  
    }
  
  

  
  
    public static String repeat(String string, int count) {
  
  
        Preconditions.checkNotNull(string);
  
  
        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;
  
  
            if((long)size != longSize) {
  
  
                throw new ArrayIndexOutOfBoundsException("Required array size too large: " + longSize);
  
  
            } else {
  
  
                char[] array = new char[size];
  
  
                string.getChars(0, len, array, 0);
  
  

  
  
                int n;
  
  
                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);
  
  
            }
  
  
        }
  
  
    }
  
  

  
  
    public static String commonPrefix(CharSequence a, CharSequence b) {
  
  
        Preconditions.checkNotNull(a);
  
  
        Preconditions.checkNotNull(b);
  
  
        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();
  
  
    }
  
  

  
  
    public static String commonSuffix(CharSequence a, CharSequence b) {
  
  
        Preconditions.checkNotNull(a);
  
  
        Preconditions.checkNotNull(b);
  
  
        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();
  
  
    }
  
  

  
  
    @VisibleForTesting
  
  
    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));
  
  
    }
  
  
}
 
 

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

（1）私有构造器

 
 

private Strings() {}
 
 

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

（2）isNullOrEmpty

 
 

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

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

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

（3）nullToEmpty

 
 

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

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

（4）emptyToNull（@Nullable String string）

 
 

@Nullable
  
  
public static String emptyToNull(@Nullable String string) {
  
  
    return isNullOrEmpty(string) ? null : string;
  
  
}
 
 

含义：

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

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

含义：

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

举例：

 
 

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

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

结果：

 
 

padStartResult is 00123
  
  
padStartResult is 12345
 
 

源码分析：

 
 

    /**
  
  
     *
  
  
     * @param string 待补全字符串
  
  
     * @param minLength 补全后的长度至少为minLength
  
  
     * @param padChar 填充的字符
  
  
     * @return 返回补全后的字符串
  
  
     */
  
  
    public static String padStart(String string, int minLength, char padChar) {
  
  
        // 先决条件 检查是否为null
  
  
        Preconditions.checkNotNull(string);
  
  
        // 如果字符串本身长度大于minLength（最低要求）则直接返回
  
  
        if(string.length() >= minLength) {
  
  
            return string;
  
  
        }
  
  
        // 如果不够minLength，则需要填充
  
  
        else {
  
  
            // 开辟minLength大小空间
  
  
            StringBuilder sb = new StringBuilder(minLength);
  
  
            // 使用padChar字符在字符串开始填充直至达到minLength
  
  
            for(int i = string.length(); i < minLength; ++i) {
  
  
                sb.append(padChar);
  
  
            }
  
  
            sb.append(string);
  
  
            return sb.toString();
  
  
        }
  
  
    }
 
 

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

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

含义：

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

举例：

 
 

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

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

结果：

 
 

padEndResult is 123000
  
  
padEndResult is 12345
 
 

源码分析：

 
 

    /**
  
  
     *
  
  
     * @param string 待补全字符串
  
  
     * @param minLength 补全后的长度至少为minLength
  
  
     * @param padChar 填充字符
  
  
     * @return 返回补全后的字符串
  
  
     */
  
  
    public static String padEnd(String string, int minLength, char padChar) {
  
  
        // 先决条件 检查是否为null
  
  
        Preconditions.checkNotNull(string);
  
  
        // 如果字符串本身长度大于等于minLength（最低要求）则直接返回
  
  
        if(string.length() >= minLength) {
  
  
            return string;
  
  
        }
  
  
        // 如果不够minLength，则需要填充
  
  
        else {
  
  
            // 开辟minLength大小空间
  
  
            StringBuilder sb = new StringBuilder(minLength);
  
  
            sb.append(string);
  
  
            // 使用padChar字符在字符串后填充直至字符串长度达到minLength
  
  
            for(int i = string.length(); i < minLength; ++i) {
  
  
                sb.append(padChar);
  
  
            }
  
  
            return sb.toString();
  
  
        }
  
  
    }
 
 

（7）repeat（String string,int count）

含义：

举例：

 
 

String repeatStr = Strings.repeat("123",3);
  
  
System.out.println("repeatStr is " + repeatStr);
  
  

  
  
String repeatStr2 = Strings.repeat("12",0);
  
  
System.out.println("repeatStr is " + repeatStr2);
 
 

结果：

 
 

repeatStr is 123123123
  
  
repeatStr is 
 
 

源码分析：

 
 

/**
  
  
     *
  
  
     * @param string 待重复字符串
  
  
     * @param count 重复次数
  
  
     * @return
  
  
     */
  
  
    public static String repeat(String string, int count) {
  
  
        // 先决条件 检查是否为null
  
  
        Preconditions.checkNotNull(string);
  
  
        // 重复次数小于等于1
  
  
        if(count <= 1) {
  
  
            // 重复次数必须大于等于0 小于0报非法参数异常
  
  
            Preconditions.checkArgument(count >= 0, "invalid count: %s", new Object[]{Integer.valueOf(count)});
  
  
            // 如果重复次数为0则返回空字符串
  
  
            return count == 0?"":string;
  
  
        }
  
  
        // 重复次数大于1
  
  
        else {
  
  
            int len = string.length();
  
  
            // 计算重复后的大小
  
  
            long longSize = (long)len * (long)count;
  
  
            // long 防止溢出
  
  
            int size = (int)longSize;
  
  
            // 判断是否溢出 抛出数组下标越界异常
  
  
            if((long)size != longSize) {
  
  
                throw new ArrayIndexOutOfBoundsException("Required array size too large: " + longSize);
  
  
            }
  
  
            else {
  
  
                // 开辟size大小空间
  
  
                char[] array = new char[size];
  
  
                // 把这个字符串中的[0,len)区间字符复制到目标字符数组[0,len)区间
  
  
                string.getChars(0, len, array, 0);
  
  
                int n;
  
  
                for(n = len; n < size - n; n <<= 1) {
  
  
                    // 复制源数组中[0,n)区间数据到目标数组[n,2n)区间中
  
  
                    System.arraycopy(array, 0, array, n, n);
  
  
                }
  
  
                // 复制源数组中[0,size - n)区间数据到目标数组[n,size)区间中
  
  
                System.arraycopy(array, 0, array, n, size - n);
  
  
                return new String(array);
  
  
            }
  
  
        }
  
  
    }
 
 

备注：

 
 

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

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

 
 

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 平台增补字符”

源码分析：

 
 

    @VisibleForTesting
  
  
    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));
  
  
    }
 
 

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

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

（9）commonPrefix（CharSequence a, CharSequence b）

含义：

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

举例：

 
 

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

 
 

结果：

 
 

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

源码分析：

 
 

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

（10）commonSuffix（CharSequence a, CharSequence b）

含义：

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

举例：

      // 相同后缀

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

结果：

 
 

c,d common suffix is .Hello
 
 

源码分析：

 
 

/**
  
  
     *
  
  
     * @param a 字符序列a
  
  
     * @param b 字符序列b
  
  
     * @return 公共后缀
  
  
     */
  
  
 public static String commonSuffix(CharSequence a, CharSequence b) {
  
  
        // Preconditions.checkNotNull 先决条件 判断是否为null
  
  
        Preconditions.checkNotNull(a);
  
  
        Preconditions.checkNotNull(b);
  
  
        // 两者最小长度（公共后缀不超过两者的最小长度）
  
  
        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) {
  
  
            ;
  
  
        }
  
  
        // 判断最后两个字符是不是合法的“Java 平台增补字符” ?
  
  
        if(validSurrogatePairAt(a, a.length() - s - 1) || validSurrogatePairAt(b, b.length() - s - 1)) {
  
  
            --s;
  
  
        }
  
  
        return a.subSequence(a.length() - s, a.length()).toString();
  
  
 }