StringUtils的用法_stringutils.trimallwhitespace

isEmpty是否为空

	//这是他的源码，可以看出"    "对这种字符串返回true
	public static boolean isEmpty(@Nullable Object str) {
		return (str == null || "".equals(str));
	}
1
2
3
4

hasText是否有文本内容，兼容空白字符

    public static void main(String[] args) {
        boolean sp = StringUtils.hasText("测试的   ");
        System.out.println(sp);

        //兼容空白字符串
        boolean b = StringUtils.hasText("     ");
        System.out.println(b);
    }
    【打印出】
    true
	false
1
2
3
4
5
6
7
8
9
10
11

containsWhitespace是否包含空白字符

    public static void main(String[] args) {
        //兼容每一个位置
        boolean sp = StringUtils.containsWhitespace("测 试的");
        System.out.println(sp);

        boolean whitespace = StringUtils.containsWhitespace("测试版的");
        System.out.println(whitespace);
    }
    【打印出】
    true
	false
1
2
3
4
5
6
7
8
9
10
11

trimWhitespace去除头和尾的空白字符，不兼容中间位置的空白字符

    public static void main(String[] args) {
        System.out.println("["+StringUtils.trimWhitespace("    测 试的    ")+"]");

        System.out.println( "["+StringUtils.trimWhitespace(" 测试 版 的 ")+"]");
    }
【打印出】
[测 试的]
[测试 版 的]
1
2
3
4
5
6
7
8

trimAllWhitespace去除所有位置的空白字符，兼容所有位置

    public static void main(String[] args) {
        System.out.println("["+StringUtils.trimAllWhitespace("    测 试的    ")+"]");

        System.out.println( "["+StringUtils.trimAllWhitespace(" 测试 版 的 ")+"]");
    }
    【打印出】
    [测试的]
	[测试版的]
1
2
3
4
5
6
7
8

trimLeadingWhitespace去除头部所有的空字符，尾部不会去除

    public static void main(String[] args) {
        System.out.println("["+StringUtils.trimLeadingWhitespace("    测 试的    ")+"]");

        System.out.println( "["+StringUtils.trimLeadingWhitespace("   测试 版 的 ")+"]");
    }
    【打印出】
    [测 试的    ]
	[测试 版 的 ]  
1
2
3
4
5
6
7
8

trimTrailingWhitespace去除尾部所有的空白字符，头部不会去除

    public static void main(String[] args) {
        System.out.println("["+StringUtils.trimTrailingWhitespace("    测 试的    ")+"]");

        System.out.println( "["+StringUtils.trimTrailingWhitespace("   测试 版 的 ")+"]");
    }
    【打印出】
    [    测 试的]
	[   测试 版 的]
1
2
3
4
5
6
7
8

trimLeadingCharacter删除匹配的首字符，若首字符匹配到了则删除，否则不会删

    public static void main(String[] args) {
    	//trimLeadingCharacter只会删除字符串的第一个字符，匹配到了就删除，匹配不到则不会删
        System.out.println("["+StringUtils.trimLeadingCharacter("test",'a')+"]");

        System.out.println( "["+StringUtils.trimLeadingCharacter("test",'t')+"]");
    }
    【打印出】
    [test]
	[est]
1
2
3
4
5
6
7
8
9

trimTrailingCharacter删除匹配的尾字符

    public static void main(String[] args) {
        System.out.println("["+StringUtils.trimTrailingCharacter("test",'a')+"]");

        System.out.println( "["+StringUtils.trimTrailingCharacter("test",'t')+"]");
    }
    【打印出】
    [test]
	[tes]
1
2
3
4
5
6
7
8

startsWithIgnoreCase是否以指定字符开头，忽略大小写

    public static void main(String[] args) {
        String str="test";
        boolean t = StringUtils.startsWithIgnoreCase(str, "TE");
        System.out.println(t);
    }
    【打印出】
    true
1
2
3
4
5
6
7

endsWithIgnoreCase是否以指定字符结尾，忽略大小写

    public static void main(String[] args) {
        String str="test";
        boolean t = StringUtils.endsWithIgnoreCase(str, "EST");
        System.out.println(t);
    }
    【打印出】
    true
1
2
3
4
5
6
7

substringMatch确定字符串的某个索引是否是这个字符

    public static void main(String[] args) {
        String str="spring-${admin}.xml";
        //第7位是否是$
        boolean t = StringUtils.substringMatch(str, 7,"$");
        System.out.println(t);
    }
    【打印出】
    true
1
2
3
4
5
6
7
8

countOccurrencesOf获取字符串在字符串中出现的次数

    public static void main(String[] args) {
        String str="spring-${admin}-spring.xml";
        
        int i = StringUtils.countOccurrencesOf(str, "spring");
        System.out.println(i);
    }
    【打印出】
    2
1
2
3
4
5
6
7
8

delete删除指定的内容

    public static void main(String[] args) {
        String str="spring-${admin}-spring.xml";
        
        String st = StringUtils.delete(str, "admin");
        System.out.println(st);
    }
    【打印出】
    spring-${}-spring.xml
1
2
3
4
5
6
7
8

deleteAny删除匹配到的字符

    public static void main(String[] args) {
        String str="spring-${admin}-spring.xml";
        
        String st = StringUtils.deleteAny(str, "silm");
        System.out.println(st);
    }
    【打印出】
    prng-${adn}-prng.x
1
2
3
4
5
6
7
8

quote给字符串首尾添加单引号

    public static void main(String[] args) {
        String str="tableName";
        
        String st = StringUtils.quote(str);
        System.out.println(st);
    }
    【打印出】
    'tableName'
1
2
3
4
5
6
7
8

quoteIfString如果是字符串就拼接在首尾拼接单引号

    public static void main(String[] args) {
        Integer num=10;
        
        Object st = StringUtils.quoteIfString(num);
        System.out.println(st);
    }
    【打印出】
    10  // 打印出10 没有拼接单引号
1
2
3
4
5
6
7
8

unqualify获取最后一个 " . "之后的内容

    public static void main(String[] args) {
       String fileName="htttp://127.0.0.1/serviceDir/人员.xls";
        String unqualify = StringUtils.unqualify(fileName);
        System.out.println(unqualify);
    }
    【打印出】
    xls
1
2
3
4
5
6
7

unqualify重载方法，获取最后一个指定的字符之后的内容

    public static void main(String[] args) {
       String fileName="htttp://127.0.0.1/serviceDir/人员.xls";
        String unqualify = StringUtils.unqualify(fileName,'/');
        System.out.println(unqualify);
    }
    【打印出】
    人员.xls
1
2
3
4
5
6
7

capitalize将字符串首字母大写

public static void main(String[] args) {
        String str="test";
        String capitalize = StringUtils.capitalize(str);
        System.out.println(capitalize);
    }
    【打印出】
    Test
1
2
3
4
5
6
7

uncapitalize将字符串首字母小写

    public static void main(String[] args) {
        String str="PathMatchingResourcePatternResolverController";
        String capitalize = StringUtils.uncapitalize(str);
        System.out.println(capitalize);
    }
    【打印出】
    pathMatchingResourcePatternResolverController
1
2
3
4
5
6
7

getFilename根据路径获取文件名称，就是获取最后一个 / 之后的内容

    public static void main(String[] args) {
       String fileName="htttp://127.0.0.1/serviceDir/user.人员.xls";
        String unqualify = StringUtils.getFilename(fileName);
        System.out.println(unqualify);
    }
    【打印出】
    user.人员.xls
1
2
3
4
5
6
7

getFilenameExtension根据路径获取文件后缀，就是取最有一个 . 之后的内容

    public static void main(String[] args) {
       String fileName="htttp://127.0.0.1/serviceDir/user.人员.xls";
        String unqualify = StringUtils.getFilenameExtension(fileName);
        System.out.println(unqualify);
    }
    【打印出】
    xls
1
2
3
4
5
6
7

stripFilenameExtension去除文件路径中的后置

    public static void main(String[] args) {
       String fileName="htttp://127.0.0.1/serviceDir/人员.xls";
        String unqualify = StringUtils.stripFilenameExtension(fileName);
        System.out.println(unqualify);
    }
    【打印出】
    htttp://127.0.0.1/serviceDir/人员
1
2
3
4
5
6
7

applyRelativePath操作路径，就是最有一个 / 之后的内容替换

    public static void main(String[] args) {
        //过第一个文件的全路径，返回第二个文件的全路径，其实就是最后 / 后面的替换操作
        String path="https://editor.csdn.net/md?not_checkout=1&articleId=128062423";
        String url = StringUtils.applyRelativePath(path, "666677777");
        System.out.println(url);

        String filePath="D:/workspace/spring-source-1.0-SNAPSHOT.jar";
        String file = StringUtils.applyRelativePath(filePath, "test.zip");
        System.out.println(file);
    }
    【打印出】
    https://editor.csdn.net/666677777
	D:/workspace/test.zip
1
2
3
4
5
6
7
8
9
10
11
12
13

cleanPath路径格式化，相对路径转成标准的绝对路径

    public static void main(String[] args) {
        //   ../相当于上级目录，表示相对路径
        //   cleanPath：就是来解决相对问题，从而得到一个更为科学的绝对路径
        String cleanPath = StringUtils.cleanPath("D:/opt/itext/../../test3.doc");
        System.out.println(cleanPath);
    }
    【打印出】
    D:/test3.doc
1
2
3
4
5
6
7
8

pathEquals比较2个文件的路径是否相等，内部用了cleanPath格式化

    public static void main(String[] args) {
       String fileName="http://127.0.0.1/serviceDir/人员.xls";
       String fileName2="http://127.0.0.1/serviceDir/人员.xls";
       boolean b = StringUtils.pathEquals(fileName, fileName2);
       System.out.println(b);

       String fileName3="http://127.0.0.1/serviceDir/user/test/../../人员.xls";
       boolean b1 = StringUtils.pathEquals(fileName, fileName3);
       System.out.println(b1);
    }
    【打印出】
    true
	http://127.0.0.1/serviceDir/人员.xls
	true
1
2
3
4
5
6
7
8
9
10
11
12
13
14

toStringArray将集合转成String类型的数组

    public static void main(String[] args) {
        List<String> list = Arrays.asList("张三", "李四", "王五");
        String[] array = StringUtils.toStringArray(list);
        for (String s : array) {
            System.out.println(s);
        }
    }
    【打印出】
    张三
	李四
	王五
1
2
3
4
5
6
7
8
9
10
11

addStringToArray向数组追加元素

    public static void main(String[] args) {
        //向数组中追加字符串，并返回一个新数组
        String [] str={"张三"};
        String[] newsArray = StringUtils.addStringToArray(str, "李四");
        for (String s : newsArray) {
            System.out.println(s);
        }
    }
    【打印出】
    张三
	李四
1
2
3
4
5
6
7
8
9
10
11

concatenateStringArrays：2个数组合并，不会去重

    public static void main(String[] args) {
        String [] array1={"张三","李四"};
        String [] array2={"王五","赵六","李四"};
        String[] strings = StringUtils.concatenateStringArrays(array1, array2);
        System.out.println("合并之后的数组长度："+strings.length);
        for (String string : strings) {
            System.out.println(string);
        }
    }
    【打印出】
合并之后的数组长度：5   //其中2个李四，没有去重功能
张三
李四
王五
赵六
李四
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

mergeStringArrays:2个数组合并，并自动去重

    public static void main(String[] args) {
        String [] array1={"张三","李四"};
        String [] array2={"王五","赵六","李四"};
        String[] strings = StringUtils.mergeStringArrays(array1, array2);
        System.out.println("合并之后的数组长度："+strings.length);
        for (String string : strings) {
            System.out.println(string);
        }
    }
    【打印出】
    合并之后的数组长度：4  //李四去重了
	张三 
	李四
	王五
	赵六
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

trimArrayElements删除数组中每个字符串元素的头部和尾部的空格

    public static void main(String[] args) {
        String [] array2={"王五 "," 赵六 "," 李   四 "};
        String[] strings = StringUtils.trimArrayElements(array2);
        for (String string : strings) {
            System.out.println(string);
        }
    }
    【打印出】
    王五
	赵六
	李   四

1
2
3
4
5
6
7
8
9
10
11
12

removeDuplicateStrings删除数组中重复的字符串，有去重功能

    public static void main(String[] args) {
        String [] array2={"王五 ","赵六"," 李   四 ","李四","赵六"};
        String[] strings = StringUtils.removeDuplicateStrings(array2);
        for (String string : strings) {
            System.out.println(string);
        }
    }
    【打印出】 //删掉了重复的赵六
    王五 
	赵六
	 李   四 
	李四
1
2
3
4
5
6
7
8
9
10
11
12

splitArrayElementsIntoProperties以指定的字符，将数组转成Properties

    public static void main(String[] args) {
        String[] array={"name:张三","age:18","address:江苏常州"};
        Properties properties = StringUtils.splitArrayElementsIntoProperties(array, ":");
        System.out.println(properties);
        System.out.println(properties.getProperty("name"));
    }
    【打印出】
    {address=江苏常州, name=张三, age=18}
	张三
1
2
3
4
5
6
7
8
9

    public static void main(String[] args) {
        String[] array={"name:张三江苏","age:18","address:江苏常州"};
        //还有一个重载的方法，可以指定转换后要删除的元素内容
        Properties properties = StringUtils.splitArrayElementsIntoProperties(array, ":","江苏");
        System.out.println(properties);
        System.out.println(properties.getProperty("name"));
    }
    【打印出】
    {address=常州, name=张三, age=18}
	张三

1
2
3
4
5
6
7
8
9
10
11

collectionToDelimitedString将集合以指定字符拼接成字符串

public static void main(String[] args) {
        List<String> list = Arrays.asList("张三", "李四", "王五");
        String str = StringUtils.collectionToDelimitedString(list, "/");
        System.out.println(str);
    }
    【打印出】
    张三/李四/王五
1
2
3
4
5
6
7

//collectionToDelimitedString的重载方法，先指定好前后缀，然后再拼接
    public static void main(String[] args) {
        List<String> list = Arrays.asList("baidu", "aliyun", "huaweiyun");
        String ster = StringUtils.collectionToDelimitedString(list, ",", "https://", ".com");
        System.out.println(ster);
    }
    【打印出】
    //观察结果，是先把集合中的每一个元素的开头拼接https://  结尾拼接 .com  之后。再把每个元素拼接的结果以“，”间隔连接起来
    https://baidu.com,https://aliyun.com,https://huaweiyun.com
1
2
3
4
5
6
7
8
9

collectionToCommaDelimitedString将集合以“，”方式拼接成字符串

    public static void main(String[] args) {
        List<String> list = Arrays.asList("张三", "李四", "王五");
        String str = StringUtils.collectionToCommaDelimitedString(list);
        System.out.println(str);
    }
    【打印出】
    张三,李四,王五
1
2
3
4
5
6
7

collectionToDelimitedString将集合以指定字符拼接

public static void main(String[] args) {
        List<String> list = Arrays.asList("张三", "李四", "王五");
        String str = StringUtils.collectionToDelimitedString(list, "/");
        System.out.println(str);
    }
    【打印出】
    张三/李四/王五
1
2
3
4
5
6
7

commaDelimitedListToStringArray将“，”分割的字符串转成数组

    public static void main(String[] args) {
        String str="张三,李四,王五,李四";
        String[] array = StringUtils.commaDelimitedListToStringArray(str);
        for (String s : array) {
            System.out.println(s);
        }
    }
    【打印出】
    张三
	李四
	王五
	李四
1
2
3
4
5
6
7
8
9
10
11
12