Java常用工具类 : StringUtils、CollectionUtils、ArrayUtils、Lists、Maps等

---

StringUtils

该类是 org.apache.commons 的 commons-lang3 包下的类

StringUtils类与String类的区别在于：此类是null安全的，即如果输入参数String为null，则不会抛出NullPointerException异常，代码更健壮。

引入依赖

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

判断函数 (isNotBlank系列)

• 1.判断是否为空，返回boolean：
  • StringUtils.isEmpty(String str)
• 2.判断是否非空，返回boolean：
  • StringUtils.isNotEmpty(String str)
• 3.判断不存在空（数组），返回boolean：
  • StringUtils.isNoneEmpty(CharSequence… css)
• 4.判断是否存在空（数组），返回boolean：
  • StringUtils.isAnyEmpty(CharSequence… css)
• 5.判断都存在空（数组），返回boolean：
  • StringUtils.isAllEmpty(CharSequence… css)
• 6.判断空白，返回boolean：
  • StringUtils.isBlank(String str)
• 7.判断非空白，返回boolean：
  • StringUtils.isNotBlank(String str)
• 8.判断是否存在空白（数组），返回boolean：
  • StringUtils.isAnyBlank(CharSequence… css)
• 9.判断是否都是空白（数组），返回boolean：
  • StringUtils.isAllBlank(CharSequence… css)
• 10.判断是否都不是空白（数组），返回boolean：
  • StringUtils.isNoneBlank(CharSequence… css)
• 11`.判断是否空白，返回boolean：
  • StringUtils.isWhitespace(CharSequence cs)

empty和blank的区别

• isEmpty 等价于 str == null || str.length == 0
• isBlank 等价于 str == null || str.length == 0 || str.trim().length == 0
• isNotEmpty等价于 a != null && a.length > 0
• isNotBlank 等价于 a != null && a.length > 0 && str.trim().length > 0

大小写函数 (转换)

• 1.首字母大写，返回String：
  • StringUtils.capitalize(String str)
• 2.首字母小写，返回String：
  • StringUtils.uncapitalize(String str)
• 3.全部大写，返回String：
  • StringUtils.upperCase(String str)
• 4.全部小写，返回String：
  • StringUtils.lowerCase(String str)
• 5.大小写互相转化，返回String：
  • StringUtils.swapCase(String str)
• 6.判断是否全大写，返回boolean：
  • StringUtils.isAllUpperCase(CharSequence cs)
• 7.判断是否全小写，返回boolean：
  • StringUtils.isAllLowerCase(CharSequence cs)

删除函数 (remove)

• 1.从字符串中删除某字符，返回String：
  • StringUtils.remove(String str, char remove)
• 2.从字符串中删除字符串，返回String：
  • StringUtils.remove(String str, String remove)
• 3.删除结尾匹配的字符串，返回String：
  • StringUtils.removeEnd(String str, String remove)
• 4.删除结尾匹配的字符串，忽略大小写，返回String：
  • StringUtils.removeEndIgnoreCase(String str, String remove)
• 5.删除开头匹配的字符串，返回String：
  • StringUtils.removeStart(String str, String remove)
• 6.删除开头匹配的字符串，忽略大小写，返回String：
  • StringUtils.removeStartIgnoreCase(String str, String remove)
• 7.正则表达式删除字符串，返回String：
  • StringUtils.removePattern(String source, String regex)
• 8.删除所有空格，包括中间，返回String：
  • StringUtils.deleteWhitespace(String str)

字符替换函数 (replace)

• 1.用replacement替换searchString字符串，返回String；
  max表示替换个数，默认全替换，为-1，可不填。0表示不换。其他表示从头开始替换n个
  • StringUtils.replace(String text, String searchString, String replacement, int max)
• 2.仅替换一个，从头开始，返回String：
  • StringUtils.replaceOnce(String text, String searchString, String replacement)
• 3.多个替换, searchList与replacementList需一一对应，返回String：
  • StringUtils.replaceEach(String text, String[] searchList, String[] replacementList)
• 4.多个循环替换,searchList与replacementList需一一对应，返回String：
  • StringUtils.replaceEachRepeatedly(String text, String[] searchList, String[] replacementList)
• 5.替换start到end的字符，返回String：
  • StringUtils.overlay(String str,String overlay,int start,int end)

拆分合并函数 (split)

• 1.特定符号分割字符串，默认为空格，可不填，返回字符数组：
  • StringUtils.split(String str)
• 2.特定符合分割字符串为长度为n的字符数组,n为0，表示全拆，返回字符数组
  • StringUtils.split(String str, String separatorChars, int n)
• 3.合并函数，数组合并为字符串：
  • StringUtils.join(byte[] array,char separator)
• 4.合并函数，separator为合并字符，当为null时，表示简单合并，亦可不填；startIndex和endIndex表示合并数组该下标间的字符，使用separator字符，亦可不填，表示全合并。
  • StringUtils.join(Object[] array,char separator,int startIndex,int endIndex)

截取函数 (substring)

• 1.截取字符串，返回String：
  • StringUtils.substring(String str,int start)
• 2.从某字符后字符开始截取，返回String：
  • StringUtils.substringAfter(String str,String separator)
• 3.截取至最后一处该字符出现，返回String：
  • StringUtils.substringBeforeLast(String str,String separator)
• 4.从第一次该字符出现后截取，返回String：
  • StringUtils.substringAfterLast(String str,String separator)
• 5.截取某字符中间的子字符串，返回String：
  • StringUtils.substringBetween(String str,String tag)

删除空白函数 (trim)

• 1.删除空格，返回String：
  • StringUtils.trim(String str)
• 2.转换空格为empty，返回String：
  • StringUtils.trimToEmpty(String str)
• 3.转换空格为null，返回String：
  • StringUtils.trimToNull(String str)
• 4.删除所有空格，包括字符串中间空格，返回String：
  • StringUtils.deleteWhitespace(String str)

判断是否相等函数 (equals)

• 1.判断是否相等，返回boolean：
  • StringUtils.equals(CharSequence cs1,CharSequence cs2)
• 2.判断是否相等，忽略大小写，返回boolean：
  • StringUtils.equalsIgnoreCase(CharSequence cs1,CharSequence cs2)

是否包含函数 (contains)

• 1.判断第一个参数字符串，是否都出参数2中，返回boolean：
  • StringUtils.containsOnly(CharSequence cs,char… valid)
• 2.判断字符串中所有字符，都不在参数2中，返回boolean：
  • StringUtils.containsNone(CharSequence cs,char… searchChars)
• 3.判断字符串是否以第二个参数开始，返回boolean：
  • StringUtils.startsWith(CharSequence str,CharSequence prefix)
• 4.判断字符串是否以第二个参数开始，忽略大小写，返回boolean：
  • StringUtils.startsWithIgnoreCase(CharSequence str,CharSequence prefix)

CollectionUtils

<dependency>
    <groupId>org.apache.commonsgroupId>
    <artifactId>commons-collections4artifactId>
    <version>4.4version>
dependency>
1
2
3
4
5

集合判断函数

• 1.判断集合是否为空
  • CollectionUtils.isEmpty(Collection coll)
• 2.判断集合是否不为空
  • CollectionUtils.isNotEmpty(Collection coll)

并集、交集、交集的补集、差集（扣除）

• 并集: CollectionUtils.union(listA, listB)

@Test
public void testUnion(){
    String[] arrayA = new String[] { "A", "B", "C", "D", "E", "F" };  
    String[] arrayB = new String[] { "B", "D", "F", "G", "H", "K" };
    List<String> listA = Arrays.asList(arrayA);
    List<String> listB = Arrays.asList(arrayB);
    //2个数组取并集 
    System.out.println(ArrayUtils.toString(CollectionUtils.union(listA, listB)));
    //[A, B, C, D, E, F, G, H, K]
}
1
2
3
4
5
6
7
8
9
10

• 交集 : CollectionUtils.intersection(listA, listB)

@Test
public void testIntersection(){
    String[] arrayA = new String[] { "A", "B", "C", "D", "E", "F" };  
    String[] arrayB = new String[] { "B", "D", "F", "G", "H", "K" };
    List<String> listA = Arrays.asList(arrayA);
    List<String> listB = Arrays.asList(arrayB);
    //2个数组取交集 
    System.out.println(ArrayUtils.toString(CollectionUtils.intersection(listA, listB)));
    //[B, D, F]
}
1
2
3
4
5
6
7
8
9
10

• 交集的补集 : CollectionUtils.disjunction(listA, listB)

@Test
public void testDisjunction(){
    String[] arrayA = new String[] { "A", "B", "C", "D", "E", "F" };  
    String[] arrayB = new String[] { "B", "D", "F", "G", "H", "K" };
    List<String> listA = Arrays.asList(arrayA);
    List<String> listB = Arrays.asList(arrayB);
    //2个数组取交集 的补集
    System.out.println(ArrayUtils.toString(CollectionUtils.disjunction(listA, listB)));
    //[A, C, E, G, H, K]
}
1
2
3
4
5
6
7
8
9
10

• 差集 : CollectionUtils.subtract(listA, listB)

@Test
public void testSubtract(){
    String[] arrayA = new String[] { "A", "B", "C", "D", "E", "F" };  
    String[] arrayB = new String[] { "B", "D", "F", "G", "H", "K" };
    List<String> listA = Arrays.asList(arrayA);
    List<String> listB = Arrays.asList(arrayB);
    //arrayA扣除arrayB
    System.out.println(ArrayUtils.toString(CollectionUtils.subtract(listA, listB)));
    //[A, C, E]
}
1
2
3
4
5
6
7
8
9
10

ArrayUtils

数组判断函数：

• 1.判断objectToFind是否在array中，返回boolean：
  • ArrayUtils.contains(T[] array, T objectToFind)
• 2.判断是否为空，返回boolean：
  • ArrayUtils.isEmpty(T[] array)
• 3.判断数组是否相同，返回boolean：
  • ArrayUtils.isEquals(T array1, T array2)
• 4.判断数组是否相同长度，并且长度不为0，返回boolean：
  • ArrayUtils.isSameLength(T[] array1, T[] array2)

数组增加函数：

• 1.添加指定元素到数组中，返回Array：
  • ArrayUtils.add(T[] array, T element)
• 2.添加指定元素到数组的index位置中，返回Array：
  • ArrayUtils.add(T[] array，Int index， T element)
• 3.合并两个数组，返回Array：
  • ArrayUtils.addAll(T[] array1, T[] array2)
• 4.复制数组，返回数组：
  • ArrayUtils.clone(T[] array)

数组移除函数：

• 1.移除指定位置的元素，返回Array：
  • ArrayUtils.removeElement(T[] array, int element)
• 2.移除指定元素，返回Array：
  • ArrayUtils.removeElement(T[] array, T element)

数组查找函数：

• 1.查找数组中是否存在，并返回其第一个位置，返回int，-1代表不存在：
  • ArrayUtils.indexOf(T[] array, T objectToFind)
• 2.查找数组中是否存在，并返回其最后一个位置，返回int，-1表示不存在：
  • ArrayUtils.lastIndexOf(T[] array, T objectToFind)
• 3.查找指定位置间的子数组，返回子数组Array：
  • ArrayUtils.subarray(T[] array, int startIndexInclusive, int endIndexExclusive)

其他常用函数：

• 1.获取数值长度，返回Int：
  • ArrayUtils.getLength(T[] array)
• 2.数组翻转，该数组本身发生变化，无返回：
  • ArrayUtils.reverse(T[] array)
• 3.数组转换为Map类型，返回Map：
  • ArrayUtils.toMap(T[] array)
• 4.数组转换为String，返回String；当数组为null时，返回stringIfNull，可不填，返回“{}”：
  • ArrayUtils.toString(T[] array, String stringIfNull)

ListUtils

以上是 apache commons-lang3包和commons-collection4包下的常见API

---

Lists (guava包)

UrlUtils

public class UrlUtil {

    public static Map<String, String> getUrlParams(String url) {
        return getUrlParams(false, url);
    }

    public static Map<String, String> getUrlParams(boolean nameLowerCase, String url) {
        Map<String, String> paramMap = new LinkedHashMap<>();
        try {
            URI uri = new URI(url);
            String query = uri.getQuery();
            String[] params = query.split("&");
            for (String param : params) {
                String name = param.substring(0, param.indexOf("="));
                String value = param.substring(param.indexOf("=") + 1);
                if (nameLowerCase) {
                    paramMap.put(name.toLowerCase(), value);
                } else {
                    paramMap.put(name, value);
                }
            }
        } catch (Exception e) {
            log.error(String.format("解析URL:%s 参数出错", url), e);
        }
        return paramMap;
    }

    public static void main(String[] args) {
        String url = "xxx";
        Map<String, String> params = getUrlParams(url);
        System.out.println(params);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33