Common Lang3 各工具类的使用

字符串工具

@Test
public void stringUtilsTest() {
    //缩短到某长度,用...结尾.其实就是(substring(str, 0, max-3) + "...")
    //public static String abbreviate(String str,int maxWidth)
    StringUtils.abbreviate("abcdefg", 6);// "abc..."

    //字符串结尾的后缀是否与你要结尾的后缀匹配，若不匹配则添加后缀
    StringUtils.appendIfMissing("abc", "xyz");//"abcxyz"
    StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz");//"abcXYZ"

    //首字母大小写转换
    StringUtils.capitalize("cat");//"Cat"
    StringUtils.uncapitalize("Cat");//"cat"

    //字符串扩充至指定大小且居中（若扩充大小少于原字符大小则返回原字符，若扩充大小为 负数则为0计算 ）
    StringUtils.center("abcd", 2);// "abcd"
    StringUtils.center("ab", -1);// "ab"
    StringUtils.center("ab", 4);//" ab "
    StringUtils.center("a", 4, "yz");//"yayz"
    StringUtils.center("abc", 7, "");//"  abc  "

    //去除字符串中的"\n", "\r", or "\r\n"
    StringUtils.chomp("abc\r\n");//"abc"

    //判断一字符串是否包含另一字符串
    StringUtils.contains("abc", "z");//false
    StringUtils.containsIgnoreCase("abc", "A");//true

    //统计一字符串在另一字符串中出现次数
    StringUtils.countMatches("abba", "a");//2

    //删除字符串中的所有空格
    StringUtils.deleteWhitespace("   ab  c  ");//"abc"

    //比较两字符串，返回不同之处。确切的说是返回第二个参数中与第一个参数所不同的字符串
    StringUtils.difference("abcde", "abxyz");//"xyz"

    //检查字符串结尾后缀是否匹配
    StringUtils.endsWith("abcdef", "def");//true
    StringUtils.endsWithIgnoreCase("ABCDEF", "def");//true
    StringUtils.endsWithAny("abcxyz", new String[]{null, "xyz", "abc"});//true

    //检查起始字符串是否匹配
    StringUtils.startsWith("abcdef", "abc");//true
    StringUtils.startsWithIgnoreCase("ABCDEF", "abc");//true
    StringUtils.startsWithAny("abcxyz", new String[]{null, "xyz", "abc"});//true

    //判断两字符串是否相同
    StringUtils.equals("abc", "abc");//true
    StringUtils.equalsIgnoreCase("abc", "ABC");//true

    //比较字符串数组内的所有元素的字符序列，起始一致则返回一致的字符串，若无则返回""
    StringUtils.getCommonPrefix(new String[]{"abcde", "abxyz"});//"ab"

    //正向查找字符在字符串中第一次出现的位置
    StringUtils.indexOf("aabaabaa", "b");//2
    StringUtils.indexOf("aabaabaa", "b", 3);//5(从角标3后查找)
    StringUtils.ordinalIndexOf("aabaabaa", "a", 3);//1(查找第n次出现的位置)

    //反向查找字符串第一次出现的位置
    StringUtils.lastIndexOf("aabaabaa", 'b');//5
    StringUtils.lastIndexOf("aabaabaa", 'b', 4);//2
    StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 2);//1

    //判断字符串大写、小写
    StringUtils.isAllUpperCase("ABC");//true
    StringUtils.isAllLowerCase("abC");//false

    //判断是否为空(注：isBlank与isEmpty 区别)
    StringUtils.isBlank(null);
    StringUtils.isBlank("");
    StringUtils.isBlank(" ");//true
    StringUtils.isNoneBlank(" ", "bar");//false

    StringUtils.isEmpty(null);
    StringUtils.isEmpty("");//true
    StringUtils.isEmpty(" ");//false
    StringUtils.isNoneEmpty(" ", "bar");//true

    //判断字符串数字
    StringUtils.isNumeric("123");//true
    StringUtils.isNumeric("12 3");//false (不识别运算符号、小数点、空格……)
    StringUtils.isNumericSpace("12 3");//true

    //数组中加入分隔符号
    StringUtils.join(new int[]{1, 2, 3}, ';');//"1;2;3"
    //大小写转换
    StringUtils.upperCase("aBc");//"ABC"
    StringUtils.lowerCase("aBc");//"abc"
    StringUtils.swapCase("The dog has a BONE");//"tHE DOG HAS A bone"

    //替换字符串内容……（replacePattern、replceOnce）
    StringUtils.replace("aba", "a", "z");//"zbz"
    StringUtils.replaceOnce("aba", "a", "z");//"zba"
    StringUtils.overlay("abcdef", "zz", 2, 4);//"abzzef"(指定区域)
    StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"});//"wcte"(多组指定替换ab->w，d->t)

    //重复字符
    StringUtils.repeat('e', 3);//"eee"

    //字符串固定长度
    StringUtils.leftPad("test", 8, "0");//0000test
    StringUtils.rightPad("test", 8, "0");//test0000


    //反转字符串
    StringUtils.reverse("bat");//"tab"

    //删除某字符
    StringUtils.remove("queued", 'u');//"qeed"

    //分割字符串
    StringUtils.split("a..b.c", '.');//["a", "b", "c"]
    StringUtils.split("ab:cd:ef", ":", 2);//["ab", "cd:ef"]
    StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-", 2);//["ab", "cd-!-ef"]
    StringUtils.splitByWholeSeparatorPreserveAllTokens("ab::cd:ef", ":");//["ab"," ","cd","ef"]

    //去除首尾空格，类似trim……（stripStart、stripEnd、stripAll、stripAccents）
    StringUtils.strip(" ab c ");//"ab c"
    StringUtils.stripToNull(null);//null
    StringUtils.stripToEmpty(null);//""

    //截取字符串
    StringUtils.substring("abcd", 2);//"cd"
    StringUtils.substring("abcdef", 2, 4);//"cd"

    //left、right从左(右)开始截取n位字符
    StringUtils.left("abc", 2);//"ab"
    StringUtils.right("abc", 2);//"bc"
    //从第n位开始截取m位字符       n  m
    StringUtils.mid("abcdefg", 2, 4);//"cdef"

    StringUtils.substringBefore("abcba", "b");//"a"
    StringUtils.substringBeforeLast("abcba", "b");//"abc"
    StringUtils.substringAfter("abcba", "b");//"cba"
    StringUtils.substringAfterLast("abcba", "b");//"a"

    StringUtils.substringBetween("tagabctag", "tag");//"abc"
    StringUtils.substringBetween("yabczyabcz", "y", "z");//"abc"
}

数字工具

@Test
public void numberUtilsTest() {
    //从数组中选出最大值
    NumberUtils.max(1, 2, 3, 4);//4
    //从数组中选出最小值
    NumberUtils.min(1, 2, 3, 4);//1
    //判断字符串是否全是整数
    NumberUtils.isDigits("153.4");//false
    NumberUtils.isDigits("0123");//true
    //判断字符串是否是有效数字
    //慎用，有效数字包括进制标有0x或0X预选项，八进制数、科学记数法和标有类型限定符的数字
    NumberUtils.isCreatable("0321.1");//false
    NumberUtils.isCreatable("08");//false
    NumberUtils.isCreatable("09");//false
    NumberUtils.isCreatable("10");//true

    //将一个字符串转换为int类型，失败返回0
    NumberUtils.toInt("123");
    //将一个字符串转换为int类型，失败返回自定义
    NumberUtils.toInt("123", 1);
    //toLong toFloat toDouble 同上
    //将一个字符串转换为BigDecimal,默认保留2位小数,舍入模式为RoundingMode.HALF_EVEN
    NumberUtils.toScaledBigDecimal("2.1");
    //将一个字符串转换为BigDecimal,自定义小数位数,自定义舍入模式
    NumberUtils.toScaledBigDecimal("2.1", 2, RoundingMode.HALF_UP);
}

数组工具

@Test
public void arrayUtils() {
    //创建数组
    String[] array = ArrayUtils.toArray("1", "2");
    //判断数组中是否包含某一对象
    ArrayUtils.contains(array, "33");
    //二维数组转换成MAP
    Map<Object, Object> map = ArrayUtils.toMap(new String[][]{{"RED", "#FF0000"}, {"GREEN", "#00FF00"}, {"BLUE", "#0000FF"}});
}

日期工具

@Test
public void dateUtils() throws ParseException {
    // Date 转化为字符串
    DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss");
    // 字符串 转 Date
    DateUtils.parseDate("2020-05-07 22:00:00", "yyyy-MM-dd HH:mm:ss");

    Date now = new Date();
    // Date 加 1 天
    Date addDays = DateUtils.addDays(now, 1);
    // Date 加 33 分钟
    Date addMinutes = DateUtils.addMinutes(now, 33);
    // Date 减去 233 秒
    Date addSeconds = DateUtils.addSeconds(now, -233);
    // 判断是否 Wie 同一天
    boolean sameDay = DateUtils.isSameDay(addDays, addMinutes);
    // 过滤时分秒,若 now 为 2020-05-07 22:13:00 调用 truncate 方法以后
    // 返回时间为 2020-05-07 00:00:00
    Date truncate = DateUtils.truncate(now, Calendar.DATE);
}

随机数工具

@Test
public void randomTest() {
    //产生5位长度的随机字符串，中文环境下是乱码
    RandomStringUtils.random(5);
    /*
     * count: 创建一个随机字符串，其长度是指定的字符数,字符将从参数的字母数字字符集中选择，如参数所示。
     * letters: true,生成的字符串可以包括字母字符
     * numbers: true,生成的字符串可以包含数字字符
     */
    RandomStringUtils.random(15, true, false);//giMDuCNthJgelfO
    /*
     * 创建一个随机字符串，其长度是指定的字符数。
     * 字符将从字符串指定的字符集中选择，不能为空。如果NULL，则使用所有字符集。
     */
    RandomStringUtils.random(15, "abcdefgABCDEFG123456789");//A4eG7dfegc14FCb
    //使用指定的字符生成5位长度的随机字符串
    RandomStringUtils.random(5, 'a', 'b', 'c', 'd', 'e', 'f', '1', '2', '3');//3ee3b
    /*
     * 创建一个随机字符串，其长度是指定的字符数,字符将从参数的字母数字字符集中选择，如参数所示。
     * count:计算创建的随机字符长度
     * start:字符集在开始时的位置
     * end:字符集在结束前的位置，必须大于65
     * letters true,生成的字符串可以包括字母字符
     * numbers true,生成的字符串可以包含数字字符
     */
    RandomStringUtils.random(1009, 5, 129, true, true);
    /*
     * 产生一个长度为指定的随机字符串的字符数，字符将从拉丁字母（a-z、A-Z的选择）。
     * count:创建随机字符串的长度
     */
    RandomStringUtils.randomAlphabetic(15);//thWwNyvaBqLsJoD
    /*
     * 创建一个随机字符串，其长度介于包含最小值和最大最大值之间,，字符将从拉丁字母（a-z、A-Z的选择）。
     * minLengthInclusive ：要生成的字符串的包含最小长度
     * maxLengthExclusive ：要生成的字符串的包含最大长度
     */
    RandomStringUtils.randomAlphabetic(2, 15);
    //生成指定长度的字母和数字的随机组合字符串
    RandomStringUtils.randomAlphanumeric(5);
    /*
     * 创建一个随机字符串，其长度介于包含最小值和最大最大值之间,字符将从拉丁字母（a-z、A-Z）和数字0-9中选择。
     * minLengthInclusive ：要生成的字符串的包含最小长度
     * maxLengthExclusive ：要生成的字符串的包含最大长度
     */
    RandomStringUtils.randomAlphanumeric(5, 68);

    //生成随机数字字符串
    RandomStringUtils.randomNumeric(5);
    /*
     * 创建一个随机字符串，其长度介于包含最小值和最大最大值之间,将从数字字符集中选择字符.
     * minLengthInclusive, 要生成的字符串的包含最小长度
     * maxLengthExclusive 要生成的字符串的包含最大长度
     */
    RandomStringUtils.randomNumeric(15, 20);
}

时间计算

@Test
public void time() throws InterruptedException {
    // 创建之后立刻计时
    StopWatch watch = StopWatch.createStarted();
    // 若想主动开始计时,创建计时器，调用 start 方法开始计时
    StopWatch watch1 = StopWatch.create();
    watch1.start();
    // 模拟其他代码耗时
    TimeUnit.SECONDS.sleep(2L);

    System.out.println("统计从开始到现在运行时间：" + watch.getTime() + "ms"); //2000ms

    TimeUnit.SECONDS.sleep(2L);
    watch.split();
    System.out.println("从start到此刻为止的时间：" + watch.getTime()); //4000
    System.out.println("从开始到第一个切入点运行时间：" + watch.getSplitTime()); //4000

    Thread.sleep(1000);
    watch.split();
    System.out.println("从开始到第二个切入点运行时间：" + watch.getSplitTime()); //5001

    watch.reset(); //重置后必须使用start方法
    watch.start();
    Thread.sleep(1000);
    System.out.println("重新开始后到当前运行时间是：" + watch.getTime()); //1000

    watch.suspend(); //暂停
    Thread.sleep(6000); //模拟暂停6秒钟

    watch.resume(); //上面suspend，这里要想重新统计，需要恢复一下
    System.out.println("恢复后执行的时间是：" + watch.getTime()); //1000  注意此时这个值还是1000

    watch.stop();
    System.out.println("花费的时间》》" + watch.getTime() + "ms"); //1000ms
    System.out.println("花费的时间》》" + watch.getTime(TimeUnit.SECONDS) + "s"); //1s 可以直接转成s
}