java开发中的工具函数(Util)---字符串处理(二)

最新推荐文章于 2022-07-28 15:19:17 发布

以墨言智

最新推荐文章于 2022-07-28 15:19:17 发布

阅读量734

点赞数

分类专栏：我的代码整理总结_old 文章标签：源代码 util

本文链接：https://blog.csdn.net/wu631464569/article/details/52314509

版权

我的代码整理总结_old 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

日期： 2016-8-25

内容：字符串处理的基本方法。

一、 J2EE开发过程中的一些字符串操作工具类整理;

1、源代码：

package com.onlyone.www.util.util_char;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符及其字符串操作工具类
 * @author cj(copy jobs)
 *
 */
public class StringOperationUtil {

	/**
	 * 功能描述: 将执行的字符串转换为用下划线分割的字符串：
	 * 比如： HelloWOrld转换之后的字符串就是hello_world;
	 * @param targetStr 需要转换的字符串
	 * @return 返回结果
	 */
	public static String camelToSnake(final String targetStr) {
		String convertedStr =
				targetStr.replaceAll("([A-Z]+)([A-Z][a-z])", "$1_$2").replaceAll("([a-z])([A-Z])", "$1_$2"); 
		return convertedStr.toLowerCase();
	}
	
	/**
	 * 功能描述： 判断一个字符串是不是为空,当为空的时候就返回true否则返回false
	 * @param value 需要判断的字符串
	 * @return 返回boolean值
	 */
	public static boolean isEmpty(final String value)
	{
		return (value == "") || (value.length() == 0);
	}
	
	/**
	 * 功能描述： 判断一个字符串是不是为空,当为空的时候就返回false否则返回true
	 * @param value
	 * @return
	 */
	public static boolean isNotEmpty(final String value)
	{
		return (value != null) && (value.length() > 0);
	}
	
	/**
	 * 功能描述: 假如字符串不为空或者全部为空格组成的话返回false，假如为空字符串的话返回true
	 * @param value 判断的字符串
	 * @return 返回的boolean值
	 */
	public static boolean isBlankOrWhSpace(final String value)
	{
		return isEmpty(value) || value.matches("^\\s$");
	}
	
	/**
	 * 判断字符串是不是为空：返回false，否则假如为空或者或者全部由空格组成返回true
	 * @param value
	 * @return
	 */
	public static boolean isBlankOrAllSpace(final String value)
	{
		return isEmpty(value) || value.matches("^\\s|^[\\s\\p{Zs}]+$");
	}
	
	/**
	 * 判断指定的对象是不是为空:这里没有局限于一个字符串了，而是可以传递一个对象
	 * @param str
	 * @return
	 */
	public static boolean isEmpty(final Object str)
	{
		return (str == null) || ((str instanceof CharSequence) && str.toString().isEmpty());
	}
	
	
	/**
	 * 功能描述: 将指定的字符串转换为驼峰式的大小写:比如Hello_world_welcome_to_home---->helloWorldWelcomeToHome;
	 * @param targetStr 需要转化的字符创
	 * @return 转换之后的字符串
	 */
	public static String snakeToCamel(final String targetStr)
	{
		Pattern pattern = Pattern.compile("_([a-z])");
		Matcher matcher = pattern.matcher(targetStr.toLowerCase());
		
		//初始化一个字符容器
		StringBuffer sb = new StringBuffer(targetStr.length());
		
		while(matcher.find())
		{
			matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
		}
		matcher.appendTail(sb);
		
		return sb.toString();
	}
	
	/**
	 * 将字符串转换为无隐式转换
	 * @param value
	 * @return
	 * @throws ClassCastException
	 */
	public static String valueOf(final Object value) throws ClassCastException {
		if (value == null) {
			return null;
		} else if (value instanceof CharSequence) {
			if (value.toString().isEmpty()) {
				return null;
			}
			return value.toString();
		} else {
			throw new ClassCastException();
		}
	}
	
	/**
	 * 功能描述: 将指定的字符串用指定的连接字符连接起来
	 * @param slashStr
	 * @param strings
	 * @return
	 */
	public static String combineStr(final String slashStr, final String... args)
	{
		//初始化一个放字符的容器
		StringBuilder sb = new StringBuilder();
		
		for(int i = 0;i<args.length;i++)
		{
			if(!isBlankOrWhSpace(args[i]))
			{
				if(i == args.length - 1)
				{
					//假如是最后一个字符串就直接添加在末尾而不需要添加分割符
					sb.append(args[i]);
				}
				else
				{
					//在添加字符串之后再添加指定的分割符号
					sb.append(args[i]).append(slashStr);
				}
			}
		}
		return sb.toString().trim();
	}
}

aaa

2、源代码测试:

package com.onlyone.www.util.util_char;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.onlyone.www.util.util_date.DateOperationUtil;

/**
 * 字符串实体类测试
 * @author peixun
 *
 */
public class StringOperationUtilTest {

	//初始化一个变量
	public StringOperationUtil stringOperationUtil;
	
	@Before
	public void before()
	{
		System.out.println("准备执行测试: "+StringOperationUtil.class);
		//将变量实例化
		stringOperationUtil = new StringOperationUtil();
	}
	
	@After
	public void after()
	{
		System.out.println(StringOperationUtil.class+"类执行完成！");
	}
	
	@Test
	public void testDateOperationUtil()
	{
		//调用函数
		String test1 = stringOperationUtil.camelToSnake("HelloWorldFuckYoueMother");
		
		//打印输出
		System.out.println(test1);
	}
	
	@Test
	public void testDateOperationUtil_isEmpty()
	{
		//调用函数：不为空的情况
		boolean test1 = stringOperationUtil.isEmpty("helloworld!");
		
		//为空的情况
		boolean test2 = stringOperationUtil.isEmpty("");
		
		//打印输出
		System.out.println("字符串不为空的时候应该打印出 false　：　　"+test1+"\n"+"字符串为空的时候应该打印出 true ： "+test2);
	}
	
	@Test
	public void testDateOperationUtil_isNotEmpty()
	{
		//调用函数：不为空的情况
		boolean test1 = stringOperationUtil.isNotEmpty("helloworld!");
		
		//为空的情况
		boolean test2 = stringOperationUtil.isNotEmpty("");
		
		//打印输出
		System.out.println("字符串不为空的时候应该打印出 true　：　　"+test1+"\n"+"字符串为空的时候应该打印出 false ： "+test2);
	}
	
	@Test
	public void testDateOperationUtil_isBlankOrWhSpace()
	{
		//调用函数：不为空的情况
		boolean test1 = stringOperationUtil.isBlankOrWhSpace("helloworld!");
		
		//为全部空格的情况
		boolean test2 = stringOperationUtil.isBlankOrWhSpace("    ");
		
		//为全部空的情况
		boolean test3 = stringOperationUtil.isBlankOrWhSpace("");
		
		//打印输出
		System.out.println("字符串不为空的时候应该打印出 false　：　　"+test1+"\n"+"字符串为空格组成的时候应该打印出 false ： "+test2+"\n"+"字符串为空的时候应该打印出 true ： "+test3);
	
		//打印的结果
		//字符串不为空的时候应该打印出 false　：　　false
		//字符串为空格组成的时候应该打印出 false ： false
		//字符串为空的时候应该打印出 true ： true
	}
	
	@Test
	public void testDateOperationUtil_isBlankOrAllSpace()
	{
		//调用函数：不为空的情况
		boolean test1 = stringOperationUtil.isBlankOrAllSpace("helloworld!");
		
		//为全部空格的情况
		boolean test2 = stringOperationUtil.isBlankOrAllSpace("    ");
		
		//为全部空的情况
		boolean test3 = stringOperationUtil.isBlankOrAllSpace("");
		
		//打印输出
		System.out.println("字符串不为空的时候应该打印出 false　：　　"+test1+"\n"+"字符串为空格组成的时候应该打印出 false ： "+test2+"\n"+"字符串为空的时候应该打印出 true ： "+test3);
		
		//打印的结果
		//字符串不为空的时候应该打印出 false　：　　false
		//字符串为空格组成的时候应该打印出 false ： true
		//字符串为空的时候应该打印出 true ： true
	}
	
	
	@Test
	public void testDateOperationUtil_isEmptyObject()
	{
		
		//声明一个Integer对象:
		Integer test4 = new Integer(10);
		
		
		//声明一个空的List
		List<Integer> list1 = new ArrayList<Integer>();
		
		//声明一个空的Map
		Map<String,Object> map = new HashMap<String,Object>();
		
		//判断函数调用
		System.out.println("带值对象调用: "+stringOperationUtil.isEmpty(test4)+"\n不带纸的list调用: "+stringOperationUtil.isEmpty(list1)+"\n不带值得map调用: "+stringOperationUtil.isEmpty(map));
		
		/**************************以下为字符串调用****************************/
		//调用函数：不为空的情况
		boolean test1 = stringOperationUtil.isEmpty("helloworld!");
		
		//为全部空格的情况
		boolean test2 = stringOperationUtil.isEmpty("    ");
		
		//为全部空的情况
		boolean test3 = stringOperationUtil.isEmpty("");
		
		//打印输出
		System.out.println("字符串不为空的时候应该打印出 false　：　　"+test1+"\n"+"字符串为空格组成的时候应该打印出 false ： "+test2+"\n"+"字符串为空的时候应该打印出 true ： "+test3);
		
		//打印的结果
		//字符串不为空的时候应该打印出 false　：　　false
		//字符串为空格组成的时候应该打印出 false ： false
		//字符串为空的时候应该打印出 true ： true
	}
	
	@Test
	public void testDateOperationUtil_snakeToCamel()
	{
		String testChar = "Hello_world_welcome_to_home";
		//调用函数：不为空的情况
		String test1 = stringOperationUtil.snakeToCamel(testChar);
		
		//打印输出
		System.out.println("将字符串： "+testChar+"\n转换之后的字符串： "+test1);
		
		//运行结果
		//将字符串： Hello_world_welcome_to_home
		//转换之后的字符串： helloWorldWelcomeToHome
	}

	
	@Test
	public void testDateOperationUtil_combineStr()
	{
		//调用函数：不为空的情况
		String test1 = stringOperationUtil.combineStr("_","hello","world","welcome","to","home");
		
		//打印输出
		System.out.println("连接之后的字符串为 ： "+test1);
		
		//运行结果
		//将字符串： Hello_world_welcome_to_home
		//转换之后的字符串： helloWorldWelcomeToHome
	}
}