Spring工具类整理_containswhitespace

Spring自带的工具类

1. StringUtils

import org.springframework.util.StringUtils;

字符串判断

1.1 hasLength

• 判断字符串长度是否大于1

StringUtils.hasLength(null);  // false
StringUtils.hasLength("");  // false
StringUtils.hasLength(" ");  // false

StringUtils.hasLength("Hello");  // true
1
2
3
4
5

1.2 hasText

• 判断字符串中是否有字符

StringUtils.hasText(null);  // false
StringUtils.hasText("");  // false
StringUtils.hasText(" ");  // false

StringUtils.hasText("12345");  // true
StringUtils.hasText(" 12345 ");  // true
1
2
3
4
5
6

1.3 containsWhitespace

• 判断是否包含空白字符

StringUtils.containsWhitespace(null);  //false
StringUtils.containsWhitespace("");  // false
StringUtils.containsWhitespace("a");  // false
StringUtils.containsWhitespace("abc");  // false
StringUtils.containsWhitespace("abc");  // false

StringUtils.containsWhitespace(" ");  // true
StringUtils.containsWhitespace(" a");  // true
StringUtils.containsWhitespace("abc ");  // true
StringUtils.containsWhitespace("a b");  // true
StringUtils.containsWhitespace("a  b");  // true
1
2
3
4
5
6
7
8
9
10
11

1.4 matchesCharacter

• 判断字符串是否和指定的字符相等

char char3 = '/';
StringUtils.matchesCharacter("/", char3);  // true
StringUtils.matchesCharacter("hello", char3);  // false
1
2
3

1.5 startsWithIgnoreCase

• 判断字符串是否以指定字符串开头,忽略大小写

StringUtils.startsWithIgnoreCase("Aabz", "a");  // true
StringUtils.startsWithIgnoreCase("babz", "ba");  // true

StringUtils.startsWithIgnoreCase("babz", "a");  // false
1
2
3
4

1.6 endsWithIgnoreCase

• 判断字符串是否以指定字符串结尾,忽略大小写

StringUtils.endsWithIgnoreCase("AaBz", "bz");  // true
1

1.7 substringMatch

• 判断从指定索引开始,是否匹配子字符串

StringUtils.substringMatch("aabbccdd", 1, "abb");  // true
StringUtils.substringMatch("aabbccdd", 0, "aabb");  // true
1
2

字符串删除

1.1 trimWhitespace

• 去掉字符串中首尾的空白字符

StringUtils.trimWhitespace(null);  // null
StringUtils.trimWhitespace("");  // ""
StringUtils.trimWhitespace(" ");  // ""
StringUtils.trimWhitespace("\t");  // ""

StringUtils.trimWhitespace(" a");  // "a"
StringUtils.trimWhitespace("a ");  // "a"
StringUtils.trimWhitespace(" a ");  // "a"
StringUtils.trimWhitespace(" a b ");  // "a b";
1
2
3
4
5
6
7
8
9

1.2 trimAllWhitespace

• 去掉字符串中所有的空白字符

StringUtils.trimAllWhitespace("");  // ""
StringUtils.trimAllWhitespace(" ");  // ""
StringUtils.trimAllWhitespace("\t");  // ""

StringUtils.trimAllWhitespace(" a");  // "a"
StringUtils.trimAllWhitespace("a ");  // "a"
StringUtils.trimAllWhitespace(" a ");  // "a"
StringUtils.trimAllWhitespace(" a b ");  // "ab"
StringUtils.trimAllWhitespace(" a b  c ");  // "abc"
1
2
3
4
5
6
7
8
9

1.3 trimLeadingWhitespace

• 去掉字符串左边的空白字符

StringUtils.trimLeadingWhitespace(null);  // null
StringUtils.trimLeadingWhitespace("");  // ""
StringUtils.trimLeadingWhitespace(" ");  // ""
StringUtils.trimLeadingWhitespace("\t");  // ""

StringUtils.trimLeadingWhitespace(" a");  // "a"
StringUtils.trimLeadingWhitespace("a ");  // "a "
StringUtils.trimLeadingWhitespace(" a ");  // "a "
StringUtils.trimLeadingWhitespace(" a b ");  // "a b "
StringUtils.trimLeadingWhitespace(" a b  c ");  // "a b  c "
1
2
3
4
5
6
7
8
9
10

1.4 trimTrailingWhitespace

• 去掉字符串右边边的空白字符

StringUtils.trimTrailingWhitespace(null);  // null
StringUtils.trimTrailingWhitespace(" ");  // ""
StringUtils.trimTrailingWhitespace("\t");  // ""
StringUtils.trimTrailingWhitespace("a ");  // "a"
StringUtils.trimTrailingWhitespace(" a");  // " a"
StringUtils.trimTrailingWhitespace(" a ");  // " a"
StringUtils.trimTrailingWhitespace(" a b ");  // " a b"
StringUtils.trimTrailingWhitespace(" a b  c ");  // " a b  c"
1
2
3
4
5
6
7
8

1.5 trimLeadingCharacter

• 去掉字符串开头的指定字符

String testStr = "/1/h/e/l/lo";
StringUtils.trimLeadingCharacter(testStr, '/');  // "1/h/e/l/lo"

String testStr = "//h/e/l/lo";
StringUtils.trimLeadingCharacter(testStr, '/');  // "h/e/l/lo"
1
2
3
4
5

1.6 trimTrailingCharacter

• 去掉字符串结尾的指定字符
• 指定字符是char类型的,因此要用单引号’'来包裹

String testStr = "/1/h/e/l/lo";
StringUtils.trimTrailingCharacter(testStr, 'o');  // "/1/h/e/l/l"

String testStr = "/1/h/e/l/looo";
StringUtils.trimTrailingCharacter(testStr, 'o');  // "/1/h/e/l/l"
1
2
3
4
5

1.7 delete

• 删除所有匹配的子字符串

StringUtils.delete("ababaabab", "ab");  // "a"
1

1.8 deleteAny

• 删除子字符串中任意出现的字符

// 原字符串中包含了子字符串中的a和b,因此删除之后只会剩下z
StringUtils.deleteAny("ababaababz", "bar");  // "z"
1
2

字符串统计

1.14 countOccurrencesOf

• 判断子字符串在字符串中出现的次数

StringUtils.countOccurrencesOf("ababaabab", "ab");  // 4
1

字符串转换

1.1 replace

• 在字符串中使用子字符串替换

// 参数1:原字符串 参数2:待替换的字符串 参数3:要替换成的字符串
StringUtils.replace("ababaabab", "ab", "cd");  // "cdcdacdcd"
1
2

1.2 quote

• 在字符串前后增加单引号,比较适合在日志时候使用

StringUtils.quote("hello");  // "'hello'"
1

1.3 quoteIfString

• 如果是字符串的话,就在前后加单引号;如果不是字符串返回原对象
• 返回值是Object类型

StringUtils.quoteIfString("hello");  // "'hello'"
1

1.4 capitalize

• 首字母大写

StringUtils.capitalize("wolfcode");  // "Wolfcode"
1

1.5 uncapitalize

• 取消首字母大写

StringUtils.uncapitalize("Java");  // "java"
1

1.6 collectionToDelimitedString

• 将一个集合中的元素,使用前缀,后缀,分隔符拼装一个字符串,前缀后后缀是针对每一个字符串的
• 有重载方法,只使用分隔符即可

String[] arrs=new String[]{"aa","bb","cc","dd"};
StringUtils.collectionToDelimitedString(Arrays.asList(arrs), ",", "{", "}");
// {aa},{bb},{cc},{dd}

String[] arrs=new String[]{"aa","bb","cc","dd"};
StringUtils.collectionToDelimitedString(Arrays.asList(arrs), ",");
// "aa,bb,cc,dd"
1
2
3
4
5
6
7

1.7 collectionToCommaDelimitedString

• 集合变成逗号连接的字符串
• collectionToDelimitedString(coll, ",");的简写

String[] arrs=new String[]{"aa","bb","cc","dd"};
StringUtils.collectionToDelimitedString(Arrays.asList(arrs));
// "aa,bb,cc,dd"
1
2
3

文件路径

1.1 unqualify

• 得到以.分割的最后一个值,常用来获取类名或者文件后缀

StringUtils.unqualify("cn.wolfcode.java");  // "java"
StringUtils.unqualify("cn/wolfcode/Hello.java");  // "java"
StringUtils.unqualify("cn/wolfcode/Hello.java", File.separatorChar);  // "Hello.java"

// 如果原字符串中没有.的话,就返回原数据
StringUtils.unqualify("Hello", File.separatorChar);  // "Hello"
1
2
3
4
5
6

1.2 getFilename

• 获取文件名

StringUtils.getFilename("mypath/myfile.txt");  // "myfile.txt"
1

1.3 getFilenameExtension

• 获取文件后缀名

StringUtils.getFilenameExtension("mypath/myfile.txt");  // "txt"
1

1.4 stripFilenameExtension

• 截取掉文件路径后缀

StringUtils.stripFilenameExtension("mypath/myfile.txt");  // "mypath/myfile"
1

1.5 applyRelativePath

• 找到给定的文件,和另一个相对路径的文件,返回第二个文件的全路径

StringUtils.applyRelativePath("d:/java/wolfcode/Test.java", "other/Some.java");
// d:/java/wolfcode/other/Some.java

StringUtils.applyRelativePath("d:/java/wolfcode/Test.java", "Some.java");
// d:/java/wolfcode/Some.java

// 不支持重新定位绝对路径和上级目录等复杂一些的相对路径写法
StringUtils.applyRelativePath("d:/java/wolfcode/Test.java", "../other/Some.java");
// d:/java/wolfcode/../other/Some.java
1
2
3
4
5
6
7
8
9

1.6 cleanPath

1.7 pathEquals

• 判断两个路径是否相同

StringUtils.pathEquals("d:\\java\\other\\Some.java", "d:/java/other/Some.java");  // true
1

转换为字符串数组

1.1 toStringArray

• 字符串集合转换为字符串数组

List<String> strings = Arrays.asList("1", "2");
String[] result_toStringArray = StringUtils.toStringArray(strings);
// {"1", "2"}
1
2
3

1.2 addStringToArray

• 把一个字符串添加到一个字符串数组中

StringUtils.addStringToArray(new String[] { "a", "b", "c" }, "d");
// { "a", "b", "c", "d"}
1
2

1.3 concatenateStringArrays

• 合并两个字符串数组

String[] arry1 = { "a", "b", "c" };
String[] arry2 ={ "a", "b", "c", "d" };
// 数组不能直接打印,需要通过Arrays.toString()进行转换
System.out.println(Arrays.toString(result_concatenateStringArrays));
// ["a", "b", "c", "a", "b", "c", "d"]
1
2
3
4
5

1.4 sortStringArray

• 字符串数组排序

StringUtils.sortStringArray(new String[]{"d","c","b","a"});  // ["a", "b", "c", "d"]
1

1.5 trimArrayElements

• 把字符串数组中所有字符串执行trim功能

StringUtils.trimArrayElements(new String[]{"d  ","   c"});  // ["d", "c"]
1

1.6 removeDuplicateStrings

• 去掉给定字符串数组中重复的元素，能保持原顺序

StringUtils.removeDuplicateStrings(new String[]{"a", "a", "b" ,"a", "c"});
// ["a", "b", "c"]
1
2

1.7 split

• 按照指定字符串分割字符串,只分隔第一次

StringUtils.split("www.wolfcode.cn", ".");
// ["www", "wolfcode.cn"]
1
2

1.8 delimitedListToStringArray

• 分割字符串，会把delimiter作为整体分隔符

StringUtils.delimitedListToStringArray("aa,ba,ca,da", "a,");
// ["a", "b", "c", "da"]

StringUtil.delimitedListToStringArray("h,e,l,l,o", ",");
// ["h", "e", "l", "l", "o"]
1
2
3
4
5

1.9 commaDelimitedListToStringArray

• 以,分隔字符串,是StringUtil.delimitedListToStringArray(XXX, ",");的简单写法

StringUtils.commaDelimitedListToStringArray("h,e,l,l,o");  // ["h", "e", "l", "l", "o"]
1

2. CollectionUtils

import org.springframework.util.CollectionUtils;

2.1 isEmpty

• 判断一个集合是否为空

CollectionUtils.isEmpty(new HashMap<>());  // true
CollectionUtils.isEmpty(new ArrayList<>());  // true
1
2

2.2 arrayToList

• 将数组转换为List

• ==注意:==该方法内部用Arrays.asList(ObjectUtils.toObjectArray(source));进行的转换,

  如果向转换之后的List进行元素的增删操作,会报错

String[] arr = {"1", "2"};
List objects = CollectionUtils.arrayToList(arr);  // ["1", "2"]
1
2

2.3 mergeArrayIntoCollection

• 将数组添加到集合当中

String[] arr = {"1", "2"};
List<String> list = new ArrayList<String>() {{
    add("A");
    add("B");
    add("C");
}};
CollectionUtils.mergeArrayIntoCollection(arr, list);  // ["A", "B", "C", "1", "2"]
1
2
3
4
5
6
7

2.4 containsInstance

• 判断集合中是否包含实例对象

Student student = new Student();
ArrayList<Object> list = new ArrayList<Object>() {{
    add(new Student());
    add(new Student());
    add(student);
}};

// 第二个参数student和第一行被new出来的是一个对象,因此是包含的结果
boolean result = CollectionUtils.containsInstance(list, student);
System.out.println(result);  // true
1
2
3
4
5
6
7
8
9
10

2.5 containsAny

• 只要两个集合中有任意一个元素相同,结果就是true

ArrayList<Object> list1 = new ArrayList<Object>() {{
    add("1");
    add("2");
    add("3");
}};

ArrayList<Object> list2 = new ArrayList<Object>() {{
    add("3");
    add("4");
}};


boolean result = CollectionUtils.containsAny(list1, list2);
System.out.println(result);  // true
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.6 findFirstMatch

• 返回第一个匹配的元素

ArrayList<Object> list1 = new ArrayList<Object>() {{
    add("1");
    add("2");
    add("3");
}};

ArrayList<Object> list2 = new ArrayList<Object>() {{
    add("1");
    add("2");
    add("2");
    add("2");
    add("3");
}};

Object firstMatch = CollectionUtils.findFirstMatch(list1, list2);
System.out.println(firstMatch);  // "1"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.7 hasUniqueObject

• 判断集合中是否只有一个对象

ArrayList<Object> list = new ArrayList<Object>() {{
    add("1");
    
    // 如果把下面的注释解开,结果就变为了false
    // add("2");
}};

boolean result = CollectionUtils.hasUniqueObject(list2);
System.out.println(result);  // true
1
2
3
4
5
6
7
8
9

2.8 findCommonElementType

• 返回集合中元素的类型
• 如果一个集合中有多种类型的元素的话,会返回null

ArrayList<Object> list2 = new ArrayList<Object>() {{
    
    // 如果把下面的注释解开,集合中就会有多种类型的元素,就会返回null
    // add("1");
    // add("2");
    add(123);
    add(22);
    add(234);
}};

Class<?> commonElementType = CollectionUtils.findCommonElementType(list2);
System.out.println(commonElementType);  // class java.lang.Integer
1
2
3
4
5
6
7
8
9
10
11
12

2.9 firstElement

• 返回第一个元素

ArrayList<Object> list2 = new ArrayList<Object>() {{
    add(123);
    add(22);
    add(234);
}};

Object o = CollectionUtils.firstElement(list2);
System.out.println(o);  // 123
1
2
3
4
5
6
7
8

3. NumberUtils

import org.springframework.util.NumberUtils;

3.1 convertNumberToTargetClass

• 将Number类型的数字转换为指定类型

Integer integer = NumberUtils.convertNumberToTargetClass(1.256, Integer.class);
System.out.println(integer);  // 1
1
2

3.2 parseNumber

• 将数字型字符串解析为 Number类型的数字

Integer integer = NumberUtils.parseNumber("1", Integer.class);
System.out.println(integer);  // 1

BigDecimal bigDecimal = NumberUtils.parseNumber("958412.2415", BigDecimal.class);
System.out.println(bigDecimal);  // 958412.2415
1
2
3
4
5

4. ObjectUtils

import org.springframework.util.ObjectUtils;

4.1 isEmpty

• 判断一个对象是否为空

Student student = null;
Map map = null;

System.out.println(ObjectUtils.isEmpty(student));  // true
System.out.println(ObjectUtils.isEmpty(map));  // true
1
2
3
4
5

4.2 isArray

• 判断一个对象是否是数组

Map map = null;
System.out.println(ObjectUtils.isArray(map));  // false

String[] arr = {"1", "2"};
System.out.println(ObjectUtils.isArray(arr));  // true
1
2
3
4
5

4.3 containsElement

• 判断数组中是否包含某元素

String[] arr = {"1", "2"};
System.out.println(ObjectUtils.containsElement(arr, "1"));  // true
System.out.println(ObjectUtils.containsElement(arr, "3"));  // false
1
2
3

4.4 addObjectToArray

• 向数组中添加元素

String[] arr = {"1", "2"};
// 返回一个新数组
String[] strings = ObjectUtils.addObjectToArray(arr, "111");
System.out.println(Arrays.toString(strings));  // [1, 2, 111]
1
2
3
4

5. FileCopyUtils

import org.springframework.util.FileCopyUtils;

5.1 copy(File in, File out)

• 将a.txt文件中的内容复制到b.txt中.
• 如果b.txt不存在,会报错.
• 如果b.txt中有文本,会被覆盖

FileCopyUtils.copy(
    new File("E:\\copyTest\\from\\a.txt"), 
    new File("E:\\copyTest\\to\\b.txt")
);
1
2
3
4

5.2 copy(InputStream in, OutputStream out)

• 如果b.txt不存在,会报错.
• 如果b.txt中有文本,会被覆盖

File in = new File("E:\\copyTest\\from\\a.txt")
InputStream fileInputStream = new FileInputStream(in);
File out = new File("E:\\copyTest\\to\\b.txt")
OutputStream fileOutputStream = new FileOutputStream(out);

FileCopyUtils.copy(fileInputStream, fileOutputStream);
1
2
3
4
5
6