我们先看大体看一下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.  }



# guava
Logo
开放原子开发者工作坊

开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！

更多推荐

“源”聚天大，码动未来|开放原子校源行（天津大学站）即将启幕！

11月22日，开放原子校源行（天津大学站）将在天津大学北洋园校区隆重举办。

avatar 开放原子开发者工作坊

openEuler系累计装机量突破1000万，树立操作系统产业新里程碑

11月15日，以“以智能，致世界”为主题的操作系统大会2024在北京中关村国际创新中心召开。

avatar 开放原子开发者工作坊

多模态大模型&科学计算双管齐下，百度飞桨两大赛项报名倒计时！

第二届开放原子大赛是由开放原子开源基金会组织举办的开源技术领域专业赛事，聚焦解决真问题，重点覆盖基础软件、工业软件、人工智能大模型等领域

avatar 开放原子开发者工作坊