血战commons-StringUtils,Strings,String

package xyz.tangzekk;


import static com.google.common.base.Strings.*;
import static org.junit.jupiter.api.Assertions.*;

import com.google.common.collect.*;
import java.util.Iterator;
import java.util.Locale;
import org.apache.commons.lang3.*;
import org.junit.*;

public class MyStrings {

  private static final String abc = "abc";
  private static final String nullString = null;
  private static final String blankString = "";

  /**
   * guava Strings
   */
  @Test
  public void test1() {
    assertEquals("", nullToEmpty(null));
    assertEquals("abc", nullToEmpty("abc"));

    assertNull(emptyToNull(""));
    assertEquals("abc", emptyToNull("abc"));

    assertTrue(isNullOrEmpty(""));
    assertTrue(isNullOrEmpty(null));
    assertFalse(isNullOrEmpty("abc"));

    assertEquals("!!abc", padStart("abc", 5, '!'));
    assertThrows(NullPointerException.class, () -> padStart(null, 5, '!'));

    assertEquals("abc??", padEnd("abc", 5, '?'));
    assertThrows(NullPointerException.class, () -> padEnd(null, 5, '?'));

    assertEquals("qwerqwerqwer", repeat("qwer", 3));
    assertThrows(NullPointerException.class, () -> repeat(null, 3));
    assertThrows(IllegalArgumentException.class, () -> repeat("ad", -1));
    assertEquals("", repeat("ad", 0));
    //  repeat 后的 String 长度大于 int 最大长度
    assertThrows(ArrayIndexOutOfBoundsException.class,
        () -> repeat(repeat("xxxxxxxxxxxxxxxxxx", 33), 99999999));

    assertEquals("南京", commonPrefix("南京小学", "南京大学"));
    assertEquals("", commonPrefix("北京大学", "南京大学"));
    assertEquals("京大学", commonSuffix("北京大学", "南京大学"));

    assertEquals("2019年4月26日", lenientFormat("%s年%s月%s日", "2019", "4", "26"));
//    System.out.println(lenientFormat("a%sa%sa%s","aaa","b","jkjk"));
  }

  @Test
  public void test2() {
    assertTrue("".isEmpty());

    assertEquals('c', "abcd".charAt(2));  //  charAt => (index) =[0,1,2...]
    assertThrows(StringIndexOutOfBoundsException.class, () -> "ab".charAt(2));

    assertTrue("abc".contentEquals(new StringBuffer("abc")));

    assertTrue("abc".equalsIgnoreCase("aBC"));
    assertEquals(-2, "a".compareTo("c"));

    assertTrue("abcd".startsWith("ab"));
    assertTrue("abcd".startsWith("c", 2));

    assertEquals(2, "tencent".indexOf("n"));
    assertEquals(5, "tencent".indexOf("n", 3));
    assertEquals(5, "tencent".lastIndexOf("n"));

    assertEquals("cd", "abcd".substring(2));
    assertEquals("c", "abcd".substring(2, 3));
    assertEquals("c", "abcd".subSequence(2, 3));

    assertEquals("鸡你太美", "鸡".concat("你太美"));
    assertThrows(NullPointerException.class, () -> nullString.concat("a"));
    assertThrows(NullPointerException.class, () -> "a".concat(nullString));

    assertEquals("呵呵abcd呵呵", "wabcdw".replace("w", "呵呵"));

    assertEquals("jqsdlzffjqjq", "jqsd24lz2344ff243465jqjq".replaceAll("\\d+", ""));
    assertNotEquals("jqsdlzffjqjq", "jqsd24lz2344ff243465jqjq".replace("\\d+", ""));

    assertTrue("1".matches("\\d+"));

    assertTrue("ac".contains("a"));

    assertEquals("waq", "qaq".replaceFirst("q", "w"));
//    System.out.println(Arrays.asList("一心一意一天一天一".split("一"))); // [, 心, 意, 天, 天]  第一个会被替换为空

    assertArrayEquals(new String[]{"心", "意", "天", "天"}, "心一意一天一天".split("一"));
    assertArrayEquals(new String[]{"a", "c", "d"}, "a342c435d".split("\\d+"));
    assertArrayEquals(new String[]{"a", "c435d"}, "a342c435d".split("\\d+", 2));

    assertEquals("a-b-c-d", String.join("-", new String[]{"a", "b", "c", "d"}));
    assertEquals("a-b-c-d", String.join("-", "a", "b", "c", "d"));

    assertEquals("A", "a".toUpperCase(Locale.TAIWAN));
    assertEquals("acc", "  acc          ".trim());

    assertEquals("2019年4月26日", String.format("%s年%s月%s日", "2019", "4", "26"));

    assertEquals("null", String.valueOf(nullString));
  }

  @Test
  public void test3() {
    assertTrue(StringUtils.isAnyEmpty("asda", nullString));
    assertTrue(StringUtils.isAnyEmpty("asda", ""));
    assertTrue(StringUtils.isAnyBlank("asda", ""));
    assertFalse(StringUtils.isNoneEmpty("asda", ""));
    assertFalse(StringUtils.isNoneEmpty("asda", nullString));
    assertTrue(StringUtils.isAllEmpty("", nullString));

    assertTrue(StringUtils.isBlank("  "));

    assertNull(StringUtils.trim(nullString));
    assertEquals("das", StringUtils.trim("   das "));

    assertNull(StringUtils.trimToNull("   "));
    assertEquals("aa", StringUtils.trimToNull("aa"));

    assertEquals("", StringUtils.trimToEmpty(nullString));
    assertEquals("aa", StringUtils.trimToEmpty("aa"));

    assertEquals("cde", StringUtils.truncate("abcdefg", 2, 3));
    assertEquals("cdefg", StringUtils.truncate("abcdefg", 2, Integer.MAX_VALUE));
    assertEquals("ab", StringUtils.truncate("abcdefg", 0, 2));
//    System.out.println(StringUtils.truncate("aa", 3, 1)); // ""
    assertThrows(IllegalArgumentException.class, () -> StringUtils.truncate("aa", 3, -1));
    assertThrows(IllegalArgumentException.class, () -> StringUtils.truncate("aa", -1, 1));

    assertEquals("a c", StringUtils.strip("  a c        "));
    assertEquals("", StringUtils.strip("    "));
    assertNull(StringUtils.strip(nullString));

    assertNull(StringUtils.stripToNull(""));
    assertNull(StringUtils.stripToNull(nullString));
    assertEquals("", StringUtils.stripToEmpty("   "));
    assertEquals("", StringUtils.stripToEmpty(nullString));

    assertEquals("ac", StringUtils.strip("**ac*", "*"));
    assertEquals("ac*", StringUtils.stripStart("**ac*", "*"));
    assertEquals("**ac", StringUtils.stripEnd("**ac*", "*"));

    assertArrayEquals(new String[]{"cc", "dd"}, StringUtils.stripAll("  cc  ", "dd           "));
    assertArrayEquals(new String[]{"cc", "dd"},
        StringUtils.stripAll(new String[]{"****cc", "****dd"}, "*"));

    assertTrue(StringUtils.equals("", ""));
    assertFalse(StringUtils.equals("", nullString));
    assertTrue(StringUtils.equalsIgnoreCase("a", "A"));

    assertEquals(-3, StringUtils.compare("", "   "));
    assertEquals(1, StringUtils.compare("", null));
    assertEquals(0, StringUtils.compare(null, null));
    assertEquals(-1, StringUtils.compare(null, ""));
    assertEquals(1, StringUtils.compare(null, "ert", false));

    assertTrue(StringUtils.equalsAnyIgnoreCase("ad", "AD", "aD", "Ad"));

    assertEquals(-1, StringUtils.indexOf("abc", "d"));
    assertEquals(-1, StringUtils.indexOf("", "d"));
    assertEquals(-1, StringUtils.indexOf(nullString, "d"));
    assertEquals(3, StringUtils.indexOf("abcde", "de"));
    assertEquals(5, StringUtils.indexOf("deabcde", "de", 3));

    assertEquals(5, StringUtils.ordinalIndexOf("xiaomi", "i", 2));
    assertEquals(9, StringUtils.ordinalIndexOf("今天的天气像昨天的天气一样好", "天", 4));
    assertEquals(7, StringUtils.ordinalIndexOf("今天的天气像昨天的天气一样好", "天", 3));
    assertEquals(3, StringUtils.ordinalIndexOf("今天的天气像昨天的天气一样好", "天", 2));
    assertEquals(1, StringUtils.ordinalIndexOf("今天的天气像昨天的天气一样好", "天", 1));

    assertEquals(4, StringUtils.lastIndexOf("abcde", "e"));

    assertEquals(1, StringUtils.lastIndexOf("aeccedeef", "e", 1));
    assertEquals(1, StringUtils.lastIndexOf("aeccedeef", "e", 2));
    assertEquals(1, StringUtils.lastIndexOf("aeccedeef", "e", 3));
    assertEquals(4, StringUtils.lastIndexOf("aeccedeef", "e", 4));
    assertEquals(4, StringUtils.lastIndexOf("aeccedeef", "e", 5));
    assertEquals(6, StringUtils.lastIndexOf("aeccedeef", "e", 6));
    assertEquals(7, StringUtils.lastIndexOf("aeccedeef", "e", 7));
    assertEquals(7, StringUtils.lastIndexOf("aeccedeef", "e", 8));
    assertEquals(7, StringUtils.lastIndexOf("aeccedeef", "e", 9));

    assertTrue(StringUtils.contains("abc", "c"));
    assertFalse(StringUtils.contains("", "c"));

    assertTrue(StringUtils.contains("a", 97));
    assertTrue(StringUtils.containsIgnoreCase("Abc", "a"));
    assertTrue(StringUtils.containsWhitespace("Ab c"));
    assertFalse(StringUtils.containsWhitespace("Abc"));

    assertEquals(1, StringUtils.indexOfAny("abc", 'c', 'b'));
    assertEquals(1, StringUtils.indexOfAny("abc", new char[]{'c', 'b'}));
    assertEquals(1, StringUtils.indexOfAny("abc", "b"));

    assertTrue(StringUtils.containsAny("abcd", "b", "c"));
    assertTrue(StringUtils.containsAny("abcd", 'b', 'c'));
//todo indexOfAnyBut 真的不会
//  assertEquals(0,StringUtils.indexOfAnyBut("abcdef",'a','e'));

    assertTrue(StringUtils.containsOnly("abc", 'a', 'b', 'c'));
    assertFalse(StringUtils.containsOnly("a3bc", 'a', 'b', 'c'));
    assertTrue(StringUtils.containsOnly("abc", "abcdef"));
    assertFalse(StringUtils.containsOnly("abc1", "abcdef"));

    assertTrue(StringUtils.containsNone("acd", "qwe"));
    assertFalse(StringUtils.containsNone("acd", "awe"));

    assertEquals(1, StringUtils.indexOfAny("abcdbcd", "bcd"));
    assertEquals(4, StringUtils.lastIndexOf("abcdbcd", "bcd"));

    assertEquals("bcde", StringUtils.substring("abcde", 1));
    assertEquals("bc", StringUtils.substring("abcde", 1, 3)); // [1,2] 3

    assertEquals("ab", StringUtils.left("abcde", 2));
    assertEquals("de", StringUtils.right("abcde", 2));
    assertEquals("cd", StringUtils.mid("abcde", 2, 2));
    assertEquals("bcd", StringUtils.mid("abcde", 1, 3));

    assertEquals("qq", StringUtils.substringBefore("qq.com", "."));
    assertEquals("com", StringUtils.substringAfter("qq.com", "."));

    assertEquals("www.qq.com", StringUtils.substringBeforeLast("www.qq.com.cn", "."));
    assertEquals("cn", StringUtils.substringAfterLast("www.qq.com.cn", "."));
    assertEquals("qq", StringUtils.substringBetween("www.qq.com.cn", "."));
    assertEquals("qq", StringUtils.substringBetween("www.qq.com.cn", ".", "."));
    assertArrayEquals(new String[]{"tom", "jerry"},
        StringUtils.substringsBetween("[tom],[jerry]", "[", "]"));

    assertArrayEquals(new String[]{"tom", "jerry"}, StringUtils.split("tom jerry"));
    assertArrayEquals(new String[]{"www", "qq", "com", "cn"},
        StringUtils.split("www.qq.com.cn", "."));

    assertArrayEquals(new String[]{"www", "qq", "com.cn"},
        StringUtils.split("www.qq.com.cn", ".", 3));
    assertArrayEquals(new String[]{"www", "qq", "com.cn"},
        StringUtils.splitByWholeSeparator("www.qq.com.cn", ".", 3));
    assertArrayEquals(new String[]{"tom", "", "jerry"},
        StringUtils.splitPreserveAllTokens("tom  jerry"));
    assertArrayEquals(new String[]{"tom", "jerry"},
        StringUtils.splitPreserveAllTokens("tom jerry"));
  }

  @Test
  public void test4() {
    assertEquals("abc", StringUtils.join("a", "", nullString, "b", "c"));

    assertEquals("a,b,c", StringUtils.join(new String[]{"a", "b", "c"}, ","));
    assertEquals("b,c", StringUtils.join(new String[]{"a", "b", "c"}, ",", 1, 3)); // 0 [1 2]
    Iterator<String> iterator = Lists.newArrayList("a", "b", "c").iterator();
    assertEquals("a,b,c", StringUtils.join(iterator, ","));
    assertEquals("a,b,c", StringUtils.join(Lists.newArrayList("a", "b", "c"), ","));
    assertEquals("b,c", StringUtils.join(Lists.newArrayList("a", "b", "c"), ",", 1, 3));

    assertEquals("a,b,c", StringUtils.joinWith(",", "a", "b", "c"));

    assertEquals("abc", StringUtils.deleteWhitespace("       a       b         c     "));

    assertEquals("qq.com", StringUtils.removeStart("www.qq.com", "www."));
    assertEquals("www.qq.com", StringUtils.removeStartIgnoreCase("www.qq.com", "qq"));
    assertEquals("www.qq", StringUtils.removeEndIgnoreCase("www.qq.com", ".com"));

    assertEquals("复,木兰当户织", StringUtils.removeIgnoreCase("唧唧复唧唧,木兰当户织", "唧"));
//    assertEquals("qwer",StringUtils.removeAll("q4224w534e3424r","[1-9]"));  //  Moved to RegExUtils.

    assertEquals("qaq", StringUtils.replaceOnceIgnoreCase("aqaq", "a", ""));
    assertEquals("qq", StringUtils.replace("aqaq", "a", "", 2));

    assertEquals("zwxrzaz",
        StringUtils.replaceEach("qwerqaq", new String[]{"q", "e"}, new String[]{"z", "x"}));
    assertEquals("zwerzaz", StringUtils
        .replaceEach("qwerqaq", new String[]{"q", "z"}, new String[]{"z", "x"}));   //  不覆盖此次修改行为
    assertEquals("xwerxax", StringUtils.replaceEachRepeatedly("qwerqaq", new String[]{"q", "z"},
        new String[]{"z", "x"}));  //  覆盖此次修改行为

    assertEquals("adc", StringUtils.replaceChars("abc", 'b', 'd'));
    assertEquals("adc", StringUtils.replaceChars("abc", "b", "d"));

    assertEquals("qaaar", StringUtils.overlay("qwer", "aaa", 1, 3));
    assertEquals("qaaa", StringUtils.overlay("qwer", "aaa", 1, 4));

    assertEquals("a&a&a", StringUtils.repeat("a", "&", 3));

    assertEquals("qwer   ", StringUtils.rightPad("qwer", 7));
    assertEquals("qwer???", StringUtils.rightPad("qwer", 7, "?"));
    assertEquals("???qwer", StringUtils.leftPad("qwer", 7, "?"));

    assertEquals("**wo**", StringUtils.center("wo", 6, "*"));
    assertEquals("  wo  ", StringUtils.center("wo", 6));
    assertEquals(StringUtils.upperCase("abc"), "abc".toUpperCase());
//    assertEquals(StringUtils.upperCase(nullString),nullString.toUpperCase()); //  区别在于 StringUtils 返回 null 不会报空指针,后者会空指针

    assertEquals("Hello world", StringUtils.capitalize("hello world"));
    assertEquals("hello world", StringUtils.uncapitalize("Hello world"));
    assertEquals("hELLO WORLD", StringUtils.swapCase("Hello world"));

    assertEquals(4, StringUtils.countMatches("一天又一天,一年又一年", "一"));

    assertTrue(StringUtils.isAlpha("敖德萨多"));  //  only Unicode letters
    assertTrue(StringUtils.isAlphaSpace("敖德   萨多"));  //  only Unicode letters and whitespace
    assertTrue(StringUtils.isAlphanumericSpace("敖德24      萨多"));

    assertTrue(StringUtils.isNumeric("453"));
    assertFalse(StringUtils.isNumeric("45a3"));
    assertTrue(StringUtils.isNumericSpace("45  3"));

    assertEquals("999", StringUtils.getDigits("^*9*%&9*(das9"));

    assertTrue(StringUtils.isWhitespace("                       "));

    assertTrue(StringUtils.isAllLowerCase("abc"));
    assertTrue(StringUtils.isAllUpperCase("ABC"));
    assertTrue(StringUtils.isMixedCase("AdC"));

    assertEquals("", StringUtils.defaultString("", "def"));
    assertEquals("def", StringUtils.defaultString(null, "def"));

    assertEquals("shanghai",
        StringUtils.firstNonBlank("     ", nullString, null, "shanghai", "beijing"));
    assertEquals("     ",
        StringUtils.firstNonEmpty("     ", nullString, null, "shanghai", "beijing"));
    assertEquals("shanghai",
        StringUtils.firstNonEmpty("", nullString, null, "shanghai", "beijing"));

    assertEquals("空了", StringUtils.defaultIfBlank("         ", "空了"));
    assertEquals("  ", StringUtils.defaultIfEmpty("  ", "空了"));
    assertEquals("空了", StringUtils.defaultIfEmpty(null, "空了"));

    assertEquals("一切为了孩子", StringUtils.rotate("为了孩子一切", 2));

    assertEquals("习学好好", StringUtils.reverse("好好学习"));
    assertEquals("壶水热", StringUtils.reverse("热水壶"));
    assertEquals("www.qq.com", StringUtils.reverseDelimited("com.qq.www", '.'));

    assertEquals("一则新闻...", StringUtils.abbreviate("一则新闻,母猪上树,树上七只猴", 7));

    assertEquals("考试", StringUtils.difference("好好学习", "好好考试"));
    assertEquals(2, StringUtils.indexOfDifference("好好学习", "好好考试"));

    assertEquals(2, StringUtils.indexOfDifference(new String[]{"qwer", "qwaa", "qwec"}));

    assertEquals("www.", StringUtils.getCommonPrefix("www.qq", "www.ww"));

    assertTrue(StringUtils.startsWithIgnoreCase("www", "w"));
    assertTrue(StringUtils.startsWithAny("qwww", "w", "b", "q"));
    assertTrue(StringUtils.endsWithAny("qwww", "w", "b", "q"));

    assertEquals("qwerty", StringUtils.appendIfMissing("qwer", "ty", "qq", "wc"));
    assertEquals("qwerwc", StringUtils.appendIfMissing("qwerwc", "ty", "qq", "wc"));
    assertEquals("qwerqq", StringUtils.appendIfMissingIgnoreCase("qwerqq", "ty", "qq", "wc"));

    assertEquals("tyqwer", StringUtils.prependIfMissing("qwer", "ty", "qq", "wc"));
    assertEquals("wcqwer", StringUtils.prependIfMissing("wcqwer", "ty", "qq", "wc"));
    assertEquals("qqwerq", StringUtils.prependIfMissingIgnoreCase("qqwerq", "ty", "qq", "wc"));

    assertEquals("select name ='飞机'", "select name =" + StringUtils.wrap("飞机", "\'"));
    assertEquals("select name ='飞机'", "select name =" + StringUtils.wrapIfMissing("'飞机", "\'"));

    assertEquals("name", StringUtils.unwrap("$name$", "$"));
//    assertEquals("",StringUtils.toCodePoints("cc"));

  }
}