• 常用工具类commons-lang3的学习使用

    apache提供的众多commons工具包，号称Java第二API，而common里面lang3包更是被我们使用得最多的。因此本文主要详细讲解lang3包里面几乎每个类的使用，希望以后大家使用此工具包。

    Apache Commons Lang3 Maven 依赖：

    2. <dependency>
    3.   <groupId>org.apache.commonsgroupId>
    4.   <artifactId>commons-lang3artifactId>
    5.   <version>3.9version>
    6. dependency>

    字符串的处理类（StringUtils)

    1. //缩短到某长度,用...结尾.其实就是(substring(str, 0, max-3) + "...")
    2.         //public static String abbreviate(String str,int maxWidth)
    3.         StringUtils.abbreviate("abcdefg", 6);// ---"abc..."
    4.  
    5.         //字符串结尾的后缀是否与你要结尾的后缀匹配，若不匹配则添加后缀
    6.         StringUtils.appendIfMissing("abc","xyz");//---"abcxyz"
    7.         StringUtils.appendIfMissingIgnoreCase("abcXYZ","xyz");//---"abcXYZ"
    8.  
    9.         //首字母大小写转换
    10.         StringUtils.capitalize("cat");//---"Cat"
    11.         StringUtils.uncapitalize("Cat");//---"cat"
    12.  
    13.         //字符串扩充至指定大小且居中（若扩充大小少于原字符大小则返回原字符，若扩充大小为 负数则为0计算 ）
    14.         StringUtils.center("abcd", 2);//--- "abcd"
    15.         StringUtils.center("ab", -1);//--- "ab"
    16.         StringUtils.center("ab", 4);//---" ab "
    17.         StringUtils.center("a", 4, "yz");//---"yayz"
    18.         StringUtils.center("abc", 7, "");//---"  abc  "
    19.  
    20.         //去除字符串中的"\n", "\r", or "\r\n"
    21.         StringUtils.chomp("abc\r\n");//---"abc"
    22.  
    23.         //判断一字符串是否包含另一字符串
    24.         StringUtils.contains("abc", "z");//---false
    25.         StringUtils.containsIgnoreCase("abc", "A");//---true
    26.  
    27.         //统计一字符串在另一字符串中出现次数
    28.         StringUtils.countMatches("abba", "a");//---2
    29.  
    30.         //删除字符串中的梭有空格
    31.         StringUtils.deleteWhitespace("   ab  c  ");//---"abc"
    32.  
    33.         //比较两字符串，返回不同之处。确切的说是返回第二个参数中与第一个参数所不同的字符串
    34.         StringUtils.difference("abcde", "abxyz");//---"xyz"
    35.  
    36.         //检查字符串结尾后缀是否匹配
    37.         StringUtils.endsWith("abcdef", "def");//---true
    38.         StringUtils.endsWithIgnoreCase("ABCDEF", "def");//---true
    39.         StringUtils.endsWithAny("abcxyz", new String[] {null, "xyz", "abc"});//---true
    40.  
    41.         //检查起始字符串是否匹配
    42.         StringUtils.startsWith("abcdef", "abc");//---true
    43.         StringUtils.startsWithIgnoreCase("ABCDEF", "abc");//---true
    44.         StringUtils.startsWithAny("abcxyz", new String[] {null, "xyz", "abc"});//---true
    45.  
    46.         //判断两字符串是否相同
    47.         StringUtils.equals("abc", "abc");//---true
    48.         StringUtils.equalsIgnoreCase("abc", "ABC");//---true
    49.  
    50.         //比较字符串数组内的所有元素的字符序列，起始一致则返回一致的字符串，若无则返回""
    51.         StringUtils.getCommonPrefix(new String[] {"abcde", "abxyz"});//---"ab"
    52.  
    53.         //正向查找字符在字符串中第一次出现的位置
    54.         StringUtils.indexOf("aabaabaa", "b");//---2
    55.         StringUtils.indexOf("aabaabaa", "b", 3);//---5(从角标3后查找)
    56.         StringUtils.ordinalIndexOf("aabaabaa", "a", 3);//---1(查找第n次出现的位置)
    57.  
    58.         //反向查找字符串第一次出现的位置
    59.         StringUtils.lastIndexOf("aabaabaa", ‘b‘);//---5
    60.         StringUtils.lastIndexOf("aabaabaa", ‘b‘, 4);//---2
    61.         StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 2);//---1
    62.  
    63.         //判断字符串大写、小写
    64.         StringUtils.isAllUpperCase("ABC");//---true
    65.         StringUtils.isAllLowerCase("abC");//---false
    66.  
    67.         //判断是否为空(注：isBlank与isEmpty 区别)
    68.         StringUtils.isBlank(null);StringUtils.isBlank("");StringUtils.isBlank(" ");//---true
    69.         StringUtils.isNoneBlank(" ", "bar");//---false
    70.  
    71.         StringUtils.isEmpty(null);StringUtils.isEmpty("");//---true
    72.         StringUtils.isEmpty(" ");//---false
    73.         StringUtils.isNoneEmpty(" ", "bar");//---true
    74.  
    75.         //判断字符串数字
    76.         StringUtils.isNumeric("123");//---false
    77.         StringUtils.isNumeric("12 3");//---false (不识别运算符号、小数点、空格……)
    78.         StringUtils.isNumericSpace("12 3");//---true
    79.  
    80.         //数组中加入分隔符号
    81.         //StringUtils.join([1, 2, 3], ‘;‘);//---"1;2;3"
    82.  
    83.         //大小写转换
    84.         StringUtils.upperCase("aBc");//---"ABC"
    85.         StringUtils.lowerCase("aBc");//---"abc"
    86.         StringUtils.swapCase("The dog has a BONE");//---"tHE DOG HAS A bone"
    87.  
    88.         //替换字符串内容……（replacePattern、replceOnce）
    89.         StringUtils.replace("aba", "a", "z");//---"zbz"
    90.         StringUtils.overlay("abcdef", "zz", 2, 4);//---"abzzef"(指定区域)
    91.         StringUtils.replaceEach("abcde", new String[]{"ab", "d"},
    92.                 new String[]{"w", "t"});//---"wcte"(多组指定替换ab->w，d->t)
    93.  
    94.         //重复字符
    95.         StringUtils.repeat(‘e‘, 3);//---"eee"
    96.  
    97.         //反转字符串
    98.         StringUtils.reverse("bat");//---"tab"
    99.  
    100.         //删除某字符
    101.         StringUtils.remove("queued", ‘u‘);//---"qeed"
    102.  
    103.         //分割字符串
    104.         StringUtils.split("a..b.c", ‘.‘);//---["a", "b", "c"]
    105.         StringUtils.split("ab:cd:ef", ":", 2);//---["ab", "cd:ef"]
    106.         StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-", 2);//---["ab", "cd-!-ef"]
    107.         StringUtils.splitByWholeSeparatorPreserveAllTokens("ab::cd:ef", ":");//-["ab"," ","cd","ef"]
    108.  
    109.         //去除首尾空格，类似trim……（stripStart、stripEnd、stripAll、stripAccents）
    110.         StringUtils.strip(" ab c ");//---"ab c"
    111.         StringUtils.stripToNull(null);//---null
    112.         StringUtils.stripToEmpty(null);//---""
    113.  
    114.         //截取字符串
    115.         StringUtils.substring("abcd", 2);//---"cd"
    116.         StringUtils.substring("abcdef", 2, 4);//---"cd"
    117.  
    118.         //left、right从左(右)开始截取n位字符
    119.         StringUtils.left("abc", 2);//---"ab"
    120.         StringUtils.right("abc", 2);//---"bc"
    121.         //从第n位开始截取m位字符       n  m
    122.         StringUtils.mid("abcdefg", 2, 4);//---"cdef"
    123.  
    124.         StringUtils.substringBefore("abcba", "b");//---"a"
    125.         StringUtils.substringBeforeLast("abcba", "b");//---"abc"
    126.         StringUtils.substringAfter("abcba", "b");//---"cba"
    127.         StringUtils.substringAfterLast("abcba", "b");//---"a"
    128.  
    129.         StringUtils.substringBetween("tagabctag", "tag");//---"abc"
    130.         StringUtils.substringBetween("yabczyabcz", "y", "z");//---"abc"
    131.  
    132.

    扩展

    abbreviateMiddle截取指定字符串，中间使用指定字符代替

    1. /**
    2.     *
    3.     * 截取指定的字符串，中间用指定字符代替。前面字符个数 + 代替字符个数 + 后2个字符 = 截取的字符个    数
    4.     * 显示5个长度的字符串，除了最后一个中间用设置的符号代替
    5.     * 长度不能小于   2
    6. */
    7.     //截取9个字符，中间使用四个*代替
    8.     String str2 = StringUtils.abbreviateMiddle("15889009897","****",9);
    9.     System.out.println(str2); //158****97
    10.     //字符刚好只有10个
    11.     String s1 = StringUtils.abbreviateMiddle("1342354534", "**", 10);
    12.     System.out.println(s1); //1342354534
    13.     //截取5个字符
    14.     String s2 = StringUtils.abbreviateMiddle("12345678910", "*", 5);
    15.     System.out.println(s2); //12*10
    16.     //截取长度不能小于2
    17.     String s3 = StringUtils.abbreviateMiddle("12345678910", "*", 2);
    18.     System.out.println(s3); //12345678910
    19.

    abbreviate截取指定字符串，多的用指定字符代替

    1. //显示6个长的的字符串，多的用三个点代替（...）
    2. StringUtils.abbreviate("abc中文asdfdefg",6);//输出结果：abc...
    3. StringUtils.abbreviate("这是中文哦可以全部显示吗",5);//这是...
    4. StringUtils.abbreviate("abcdefgh",12); //abcdefgh
    5. StringUtils.abbreviate("abcdaldf","**",3); //a**

       contains检测某个字符串中是否包含某个字符

    1.  //检测abcde字符串中是否包含abc字符
    2.   StringUtils.contains("abcde", "abc"); //true

      containsAny检测某个字符串中是否包含字符串1或者字符串2……

    1.         //检测字符串abcdef中是否保护abm或者y
    2.         StringUtils.containsAny("abcdef", "abm", "y"); //false

     检测abcdefg字符串中是否包含 "b"或者"h"或者"N”字符串

         StringUtils.containsAny("abcdefg", "b", "h", "N"); //true

    defaultString将 null空字符串转为 ""空字符串

    1.     //defaultString将 null空字符串转为 ""空字符串
    2.         StringUtils.defaultString(null);// ""
    3.         StringUtils.defaultString("");// ""
    4.         StringUtils.defaultString("bat");//"bat"

    isEmpty和 isNotEmpty判断字符串是否为空

    javaAPI中常用类的使用
    zip 0星 超过10%的资源 959KB
    下载
    1. StringUtils.isEmpty(null);//true
    2. StringUtils.isEmpty("");//true
    3. StringUtils.isEmpty(" ");//false
    4. StringUtils.isEmpty("bob");//false
    5. StringUtils.isEmpty("  bob  ");//false
    6. StringUtils.isNotEmpty(null);//false
    7. StringUtils.isNotEmpty("");//false
    8. StringUtils.isNotEmpty(" ");//true
    9. StringUtils.isNotEmpty("bob");//true
    10. StringUtils.isNotEmpty("  bob  ");//true

     注意:isEmpty和 isBlank区别

    isEmpty认为 " "是不等于空的。isBlank认为 " "是等于空的，具有一个前后去掉空格的意思。

    replace替换字符串

    1. 方法：public static String replace(final String text, final String searchString, final String replacement) {}
    2.  
    3. 将 text字符串中的 searchString字符替换成 replacement
    4.  
    5. StringUtils.replace(null,,);//null
    6. StringUtils.replace("",,);//""
    7. StringUtils.replace("any",null,);//"any"
    8. StringUtils.replace("any",,null);//"any"
    9. StringUtils.replace("any","",);//"any"
    10. StringUtils.replace("aba","a",null);//"aba"
    11. StringUtils.replace("aba","a","");//"b"
    12. StringUtils.replace("aba","a","z");//"zbz"
    13.

    随机数生成类（RandomUtils）

    1. //返回一个随机布尔值
    2. boolean b = RandomUtils.nextBoolean();
    3. System.out.println(b);
    4.  
    5. //随机生成10个长的的byte数组
    6. byte[] bytes = RandomUtils.nextBytes(10);
    7. //打印字节数组
    8. System.out.println(Arrays.toString(bytes));
    9. //输出结果：[105, 86, 28, 57, -113, 13, -30, -83, -96, 126]
    10.  
    11.  
    12. for (int i = 0; i < 20; i++) {
    13. 	
    14.     //指定范围随机数1-5 不包括5
    15.     int rand = RandomUtils.nextInt(1, 5);
    16.     
    17.     System.out.print(rand+"  ");
    18. }
    19. 输出结果：4  3  2  2  2  2  4  1  3  3  3  2  3  4  4  2  2  1  3  2 
    20.  
    21.  
    22. //1-4.99999之间的随机数，nextLong，nextFloat
    23. double v = RandomUtils.nextDouble(1, 5); //3.6664777207393597
    24. System.out.println(v);

    随机数生成类（RandomStringUtils）

    1.         //随机生成n位数数字
    2.         RandomStringUtils.randomNumeric(n);
    3.         //在指定字符串中生成长度为n的随机字符串
    4.         RandomStringUtils.random(n, "abcdefghijk");
    5.         //指定从字符或数字中生成随机字符串
    6.         System.out.println(RandomStringUtils.random(n, true, false));  
    7.         System.out.println(RandomStringUtils.random(n, false, true));
    8.

    数字类NumberUtils

    1.        //从数组中选出最大值
    2.         NumberUtils.max(new int[] { 1, 2, 3, 4 });//---4
    3.         //判断字符串是否全是整数
    4.         NumberUtils.isDigits("153.4");//--false
    5.         //判断字符串是否是有效数字
    6.         NumberUtils.isNumber("0321.1");//---false    
    7.

    数组类 ArrayUtils

    1.         //创建数组
    2.         String[] array = ArrayUtils.toArray("1", "2");
    3.         //判断两个数据是否相等，如果内容相同， 顺序相同 则返回 true
    4.         ArrayUtils.isEquals(arr1,arr2);
    5.         //判断数组中是否包含某一对象
    6.         ArrayUtils.contains(arr, "33");
    7.         //二维数组转换成MAP
    8.         Map map = ArrayUtils.toMap(new String[][] { 
    9.                 { "RED", "#FF0000" }, { "GREEN", "#00FF00" }, { "BLUE", "#0000FF" } });
    10.

    日期类DateUtils

    1.         //日期加n天
    2.         DateUtils.addDays(new Date(), n);
    3.         //判断是否同一天
    4.         DateUtils.isSameDay(date1, date2);
    5.         //字符串时间转换为Date
    6.         DateUtils.parseDate(str, parsePatterns);
    7.

    附: StringUtile

    1. /*
    2.  * Copyright 2015-2017 the original author or authors.
    3.  *
    4.  * Licensed under the Apache License, Version 2.0 (the "License");
    5.  * you may not use this file except in compliance with the License.
    6.  * You may obtain a copy of the License at
    7.  *
    8.  *      http://www.apache.org/licenses/LICENSE-2.0
    9.  *
    10.  * Unless required by applicable law or agreed to in writing, software
    11.  * distributed under the License is distributed on an "AS IS" BASIS,
    12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13.  * See the License for the specific language governing permissions and
    14.  * limitations under the License.
    15.  */
    16.  
    17. package com.funtl.leesite.common.utils;
    18.  
    19. import java.io.UnsupportedEncodingException;
    20. import java.util.ArrayList;
    21. import java.util.List;
    22. import java.util.Locale;
    23. import java.util.regex.Matcher;
    24. import java.util.regex.Pattern;
    25.  
    26. import javax.servlet.http.HttpServletRequest;
    27.  
    28. import com.google.common.collect.Lists;
    29.  
    30. import org.apache.commons.lang3.StringEscapeUtils;
    31. import org.springframework.web.context.request.RequestContextHolder;
    32. import org.springframework.web.context.request.ServletRequestAttributes;
    33. import org.springframework.web.servlet.LocaleResolver;
    34.  
    35. /**
    36.  * 字符串工具类, 继承org.apache.commons.lang3.StringUtils类
    37.  *
    38.  * @author Lusifer
    39.  * @version 2013-05-22
    40.  */
    41. public class StringUtils extends org.apache.commons.lang3.StringUtils {
    42.  
    43.     private static final char SEPARATOR = '_';
    44.     private static final String CHARSET_NAME = "UTF-8";
    45.  
    46.     /**
    47.      * 转换为字节数组
    48.      *
    49.      * @param str
    50.      * @return
    51.      */
    52.     public static byte[] getBytes(String str) {
    53.         if (str != null) {
    54.             try {
    55.                 return str.getBytes(CHARSET_NAME);
    56.             } catch (UnsupportedEncodingException e) {
    57.                 return null;
    58.             }
    59.         } else {
    60.             return null;
    61.         }
    62.     }
    63.  
    64.     /**
    65.      * 转换为字节数组
    66.      *
    67.      * @param str
    68.      * @return
    69.      */
    70.     public static String toString(byte[] bytes) {
    71.         try {
    72.             return new String(bytes, CHARSET_NAME);
    73.         } catch (UnsupportedEncodingException e) {
    74.             return EMPTY;
    75.         }
    76.     }
    77.  
    78.     /**
    79.      * 是否包含字符串
    80.      *
    81.      * @param str  验证字符串
    82.      * @param strs 字符串组
    83.      * @return 包含返回true
    84.      */
    85.     public static boolean inString(String str, String... strs) {
    86.         if (str != null) {
    87.             for (String s : strs) {
    88.                 if (str.equals(trim(s))) {
    89.                     return true;
    90.                 }
    91.             }
    92.         }
    93.         return false;
    94.     }
    95.  
    96.     /**
    97.      * 替换掉HTML标签方法
    98.      */
    99.     public static String replaceHtml(String html) {
    100.         if (isBlank(html)) {
    101.             return "";
    102.         }
    103.         String regEx = "<.+?>";
    104.         Pattern p = Pattern.compile(regEx);
    105.         Matcher m = p.matcher(html);
    106.         String s = m.replaceAll("");
    107.         return s;
    108.     }
    109.  
    110.     /**
    111.      * 替换为手机识别的HTML，去掉样式及属性，保留回车。
    112.      *
    113.      * @param html
    114.      * @return
    115.      */
    116.     public static String replaceMobileHtml(String html) {
    117.         if (html == null) {
    118.             return "";
    119.         }
    120.         return html.replaceAll("<([a-z]+?)\\s+?.*?>", "<$1>");
    121.     }
    122.  
    123.     /**
    124.      * 替换为手机识别的HTML，去掉样式及属性，保留回车。
    125.      *
    126.      * @param txt
    127.      * @return
    128.      */
    129.     public static String toHtml(String txt) {
    130.         if (txt == null) {
    131.             return "";
    132.         }
    133.         return replace(replace(Encodes.escapeHtml(txt), "\n", "
      "      ), "\t", "    ");
    134.     }
    135.  
    136.     /**
    137.      * 缩略字符串（不区分中英文字符）
    138.      *
    139.      * @param str    目标字符串
    140.      * @param length 截取长度
    141.      * @return
    142.      */
    143.     public static String abbr(String str, int length) {
    144.         if (str == null) {
    145.             return "";
    146.         }
    147.         try {
    148.             StringBuilder sb = new StringBuilder();
    149.             int currentLength = 0;
    150.             for (char c : replaceHtml(StringEscapeUtils.unescapeHtml4(str)).toCharArray()) {
    151.                 currentLength += String.valueOf(c).getBytes("GBK").length;
    152.                 if (currentLength <= length - 3) {
    153.                     sb.append(c);
    154.                 } else {
    155.                     sb.append("...");
    156.                     break;
    157.                 }
    158.             }
    159.             return sb.toString();
    160.         } catch (UnsupportedEncodingException e) {
    161.             e.printStackTrace();
    162.         }
    163.         return "";
    164.     }
    165.  
    166.     public static String abbr2(String param, int length) {
    167.         if (param == null) {
    168.             return "";
    169.         }
    170.         StringBuffer result = new StringBuffer();
    171.         int n = 0;
    172.         char temp;
    173.         boolean isCode = false; // 是不是HTML代码
    174.         boolean isHTML = false; // 是不是HTML特殊字符,如 
    175.         for (int i = 0; i < param.length(); i++) {
    176.             temp = param.charAt(i);
    177.             if (temp == '<') {
    178.                 isCode = true;
    179.             } else if (temp == '&') {
    180.                 isHTML = true;
    181.             } else if (temp == '>' && isCode) {
    182.                 n = n - 1;
    183.                 isCode = false;
    184.             } else if (temp == ';' && isHTML) {
    185.                 isHTML = false;
    186.             }
    187.             try {
    188.                 if (!isCode && !isHTML) {
    189.                     n += String.valueOf(temp).getBytes("GBK").length;
    190.                 }
    191.             } catch (UnsupportedEncodingException e) {
    192.                 e.printStackTrace();
    193.             }
    194.  
    195.             if (n <= length - 3) {
    196.                 result.append(temp);
    197.             } else {
    198.                 result.append("...");
    199.                 break;
    200.             }
    201.         }
    202.         // 取出截取字符串中的HTML标记
    203.         String temp_result = result.toString().replaceAll("(>)[^<>]*(, "$1$2");
    204.         // 去掉不需要结素标记的HTML标记
    205.         temp_result = temp_result.replaceAll("]*/?>", "");
    206.         // 去掉成对的HTML标记
    207.         temp_result = temp_result.replaceAll("<([a-zA-Z]+)[^<>]*>(.*?)", "$2");
    208.         // 用正则表达式取出标记
    209.         Pattern p = Pattern.compile("<([a-zA-Z]+)[^<>]*>");
    210.         Matcher m = p.matcher(temp_result);
    211.         List endHTML = Lists.newArrayList();
    212.         while (m.find()) {
    213.             endHTML.add(m.group(1));
    214.         }
    215.         // 补全不成对的HTML标记
    216.         for (int i = endHTML.size() - 1; i >= 0; i--) {
    217.             result.append(");
    218.             result.append(endHTML.get(i));
    219.             result.append(">");
    220.         }
    221.         return result.toString();
    222.     }
    223.  
    224.     /**
    225.      * 转换为Double类型
    226.      */
    227.     public static Double toDouble(Object val) {
    228.         if (val == null) {
    229.             return 0D;
    230.         }
    231.         try {
    232.             return Double.valueOf(trim(val.toString()));
    233.         } catch (Exception e) {
    234.             return 0D;
    235.         }
    236.     }
    237.  
    238.     /**
    239.      * 转换为Float类型
    240.      */
    241.     public static Float toFloat(Object val) {
    242.         return toDouble(val).floatValue();
    243.     }
    244.  
    245.     /**
    246.      * 转换为Long类型
    247.      */
    248.     public static Long toLong(Object val) {
    249.         return toDouble(val).longValue();
    250.     }
    251.  
    252.     /**
    253.      * 转换为Integer类型
    254.      */
    255.     public static Integer toInteger(Object val) {
    256.         return toLong(val).intValue();
    257.     }
    258.  
    259.     /**
    260.      * 获得i18n字符串
    261.      */
    262.     public static String getMessage(String code, Object[] args) {
    263.         LocaleResolver localLocaleResolver = (LocaleResolver) SpringContextHolder.getBean(LocaleResolver.class);
    264.         HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    265.         Locale localLocale = localLocaleResolver.resolveLocale(request);
    266.         return SpringContextHolder.getApplicationContext().getMessage(code, args, localLocale);
    267.     }
    268.  
    269.     /**
    270.      * 获得用户远程地址
    271.      */
    272.     public static String getRemoteAddr(HttpServletRequest request) {
    273.         String remoteAddr = request.getHeader("X-Real-IP");
    274.         if (isNotBlank(remoteAddr)) {
    275.             remoteAddr = request.getHeader("X-Forwarded-For");
    276.         } else if (isNotBlank(remoteAddr)) {
    277.             remoteAddr = request.getHeader("Proxy-Client-IP");
    278.         } else if (isNotBlank(remoteAddr)) {
    279.             remoteAddr = request.getHeader("WL-Proxy-Client-IP");
    280.         }
    281.         return remoteAddr != null ? remoteAddr : request.getRemoteAddr();
    282.     }
    283.  
    284.     /**
    285.      * 驼峰命名法工具
    286.      *
    287.      * @return toCamelCase("hello_world") == "helloWorld"
    288.      * toCapitalizeCamelCase("hello_world") == "HelloWorld"
    289.      * toUnderScoreCase("helloWorld") = "hello_world"
    290.      */
    291.     public static String toCamelCase(String s) {
    292.         if (s == null) {
    293.             return null;
    294.         }
    295.  
    296.         s = s.toLowerCase();
    297.  
    298.         StringBuilder sb = new StringBuilder(s.length());
    299.         boolean upperCase = false;
    300.         for (int i = 0; i < s.length(); i++) {
    301.             char c = s.charAt(i);
    302.  
    303.             if (c == SEPARATOR) {
    304.                 upperCase = true;
    305.             } else if (upperCase) {
    306.                 sb.append(Character.toUpperCase(c));
    307.                 upperCase = false;
    308.             } else {
    309.                 sb.append(c);
    310.             }
    311.         }
    312.  
    313.         return sb.toString();
    314.     }
    315.  
    316.     /**
    317.      * 驼峰命名法工具
    318.      *
    319.      * @return toCamelCase("hello_world") == "helloWorld"
    320.      * toCapitalizeCamelCase("hello_world") == "HelloWorld"
    321.      * toUnderScoreCase("helloWorld") = "hello_world"
    322.      */
    323.     public static String toCapitalizeCamelCase(String s) {
    324.         if (s == null) {
    325.             return null;
    326.         }
    327.         s = toCamelCase(s);
    328.         return s.substring(0, 1).toUpperCase() + s.substring(1);
    329.     }
    330.  
    331.     /**
    332.      * 驼峰命名法工具
    333.      *
    334.      * @return toCamelCase("hello_world") == "helloWorld"
    335.      * toCapitalizeCamelCase("hello_world") == "HelloWorld"
    336.      * toUnderScoreCase("helloWorld") = "hello_world"
    337.      */
    338.     public static String toUnderScoreCase(String s) {
    339.         if (s == null) {
    340.             return null;
    341.         }
    342.  
    343.         StringBuilder sb = new StringBuilder();
    344.         boolean upperCase = false;
    345.         for (int i = 0; i < s.length(); i++) {
    346.             char c = s.charAt(i);
    347.  
    348.             boolean nextUpperCase = true;
    349.  
    350.             if (i < (s.length() - 1)) {
    351.                 nextUpperCase = Character.isUpperCase(s.charAt(i + 1));
    352.             }
    353.  
    354.             if ((i > 0) && Character.isUpperCase(c)) {
    355.                 if (!upperCase || !nextUpperCase) {
    356.                     sb.append(SEPARATOR);
    357.                 }
    358.                 upperCase = true;
    359.             } else {
    360.                 upperCase = false;
    361.             }
    362.  
    363.             sb.append(Character.toLowerCase(c));
    364.         }
    365.  
    366.         return sb.toString();
    367.     }
    368.  
    369.     /**
    370.      * 如果不为空，则设置值
    371.      *
    372.      * @param target
    373.      * @param source
    374.      */
    375.     public static void setValueIfNotBlank(String target, String source) {
    376.         if (isNotBlank(source)) {
    377.             target = source;
    378.         }
    379.     }
    380.  
    381.     /**
    382.      * 转换为JS获取对象值，生成三目运算返回结果
    383.      *
    384.      * @param objectString 对象串
    385.      *                     例如：row.user.id
    386.      *                     返回：!row?'':!row.user?'':!row.user.id?'':row.user.id
    387.      */
    388.     public static String jsGetVal(String objectString) {
    389.         StringBuilder result = new StringBuilder();
    390.         StringBuilder val = new StringBuilder();
    391.         String[] vals = split(objectString, ".");
    392.         for (int i = 0; i < vals.length; i++) {
    393.             val.append("." + vals[i]);
    394.             result.append("!" + (val.substring(1)) + "?'':");
    395.         }
    396.         result.append(val.substring(1));
    397.         return result.toString();
    398.     }
    399.  
    400.     /**
    401.      * 通过正则表达式获取内容
    402.      *
    403.      * @param regex 正则表达式
    404.      * @param from  原字符串
    405.      * @return
    406.      */
    407.     public static String[] regex(String regex, String from) {
    408.         Pattern pattern = Pattern.compile(regex);
    409.         Matcher matcher = pattern.matcher(from);
    410.         List results = new ArrayList();
    411.         while (matcher.find()) {
    412.             for (int i = 0; i < matcher.groupCount(); i++) {
    413.                 results.add(matcher.group(i + 1));
    414.             }
    415.         }
    416.         return results.toArray(new String[]{});
    417.     }
    418.  
    419. }

  • 相关阅读:
    在ubuntu上用QT写一个简单的C++小游戏(附源码)
    各种获取JVM DUMP的方法
    leetcode 11.盛最多水的容器
    紫光展锐6nm国产5G处理器T820_国产手机芯片5G方案
    R语言dplyr包select函数筛选dataframe数据中以指定字符串开头的数据列（变量）
    【群智能算法改进】一种改进的鹈鹕优化算法 IPOA算法[1]【Matlab代码#57】
    树状数组略解
    GBase 8d的特性-高性能
    【TB作品】基于MSP430G2553单片机的超声波测距与报警系统，原理图，PCB
    天气这么好，都外出了。顺便了解一下漏桶算法
  • 原文地址：https://blog.csdn.net/weixin_53998054/article/details/126125304