Java最全的字符串工具类,例如是否空,去空,截取字符串,下划线转驼峰命名,是否包含字符串

Java字符串工具类,例如是否空,去空,截取字符串,下划线转驼峰命名,是否包含字符串,直接上代码,以作备忘。

StringUtils.java
  1. /**
  2. * 字符串工具类
  3. *
  4. * @author admin
  5. */
  6. public class StringUtils extends org.apache.commons.lang3.StringUtils
  7. {
  8. /** 空字符串 */
  9. private static final String NULLSTR = "";
  10. /** 下划线 */
  11. private static final char SEPARATOR = '_';
  12. /**
  13. * 获取参数不为空值
  14. *
  15. * @param value defaultValue 要判断的value
  16. * @return value 返回值
  17. */
  18. public static <T> T nvl(T value, T defaultValue)
  19. {
  20. return value != null ? value : defaultValue;
  21. }
  22. /**
  23. * * 判断一个Collection是否为空, 包含List,Set,Queue
  24. *
  25. * @param coll 要判断的Collection
  26. * @return true:为空 false:非空
  27. */
  28. public static boolean isEmpty(Collection<?> coll)
  29. {
  30. return isNull(coll) || coll.isEmpty();
  31. }
  32. /**
  33. * * 判断一个Collection是否非空,包含List,Set,Queue
  34. *
  35. * @param coll 要判断的Collection
  36. * @return true:非空 false:空
  37. */
  38. public static boolean isNotEmpty(Collection<?> coll)
  39. {
  40. return !isEmpty(coll);
  41. }
  42. /**
  43. * * 判断一个对象数组是否为空
  44. *
  45. * @param objects 要判断的对象数组
  46. ** @return true:为空 false:非空
  47. */
  48. public static boolean isEmpty(Object[] objects)
  49. {
  50. return isNull(objects) || (objects.length == 0);
  51. }
  52. /**
  53. * * 判断一个对象数组是否非空
  54. *
  55. * @param objects 要判断的对象数组
  56. * @return true:非空 false:空
  57. */
  58. public static boolean isNotEmpty(Object[] objects)
  59. {
  60. return !isEmpty(objects);
  61. }
  62. /**
  63. * * 判断一个Map是否为空
  64. *
  65. * @param map 要判断的Map
  66. * @return true:为空 false:非空
  67. */
  68. public static boolean isEmpty(Map<?, ?> map)
  69. {
  70. return isNull(map) || map.isEmpty();
  71. }
  72. /**
  73. * * 判断一个Map是否为空
  74. *
  75. * @param map 要判断的Map
  76. * @return true:非空 false:空
  77. */
  78. public static boolean isNotEmpty(Map<?, ?> map)
  79. {
  80. return !isEmpty(map);
  81. }
  82. /**
  83. * * 判断一个字符串是否为空串
  84. *
  85. * @param str String
  86. * @return true:为空 false:非空
  87. */
  88. public static boolean isEmpty(String str)
  89. {
  90. return isNull(str) || NULLSTR.equals(str.trim());
  91. }
  92. /**
  93. * * 判断一个字符串是否为非空串
  94. *
  95. * @param str String
  96. * @return true:非空串 false:空串
  97. */
  98. public static boolean isNotEmpty(String str)
  99. {
  100. return !isEmpty(str);
  101. }
  102. /**
  103. * * 判断一个对象是否为空
  104. *
  105. * @param object Object
  106. * @return true:为空 false:非空
  107. */
  108. public static boolean isNull(Object object)
  109. {
  110. return object == null;
  111. }
  112. /**
  113. * * 判断一个对象是否非空
  114. *
  115. * @param object Object
  116. * @return true:非空 false:空
  117. */
  118. public static boolean isNotNull(Object object)
  119. {
  120. return !isNull(object);
  121. }
  122. /**
  123. * * 判断一个对象是否是数组类型(Java基本型别的数组)
  124. *
  125. * @param object 对象
  126. * @return true:是数组 false:不是数组
  127. */
  128. public static boolean isArray(Object object)
  129. {
  130. return isNotNull(object) && object.getClass().isArray();
  131. }
  132. /**
  133. * 去空格
  134. */
  135. public static String trim(String str)
  136. {
  137. return (str == null ? "" : str.trim());
  138. }
  139. /**
  140. * 截取字符串
  141. *
  142. * @param str 字符串
  143. * @param start 开始
  144. * @return 结果
  145. */
  146. public static String substring(final String str, int start)
  147. {
  148. if (str == null)
  149. {
  150. return NULLSTR;
  151. }
  152. if (start < 0)
  153. {
  154. start = str.length() + start;
  155. }
  156. if (start < 0)
  157. {
  158. start = 0;
  159. }
  160. if (start > str.length())
  161. {
  162. return NULLSTR;
  163. }
  164. return str.substring(start);
  165. }
  166. /**
  167. * 截取字符串
  168. *
  169. * @param str 字符串
  170. * @param start 开始
  171. * @param end 结束
  172. * @return 结果
  173. */
  174. public static String substring(final String str, int start, int end)
  175. {
  176. if (str == null)
  177. {
  178. return NULLSTR;
  179. }
  180. if (end < 0)
  181. {
  182. end = str.length() + end;
  183. }
  184. if (start < 0)
  185. {
  186. start = str.length() + start;
  187. }
  188. if (end > str.length())
  189. {
  190. end = str.length();
  191. }
  192. if (start > end)
  193. {
  194. return NULLSTR;
  195. }
  196. if (start < 0)
  197. {
  198. start = 0;
  199. }
  200. if (end < 0)
  201. {
  202. end = 0;
  203. }
  204. return str.substring(start, end);
  205. }
  206. /**
  207. * 格式化文本, {} 表示占位符<br>
  208. * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
  209. * 如果想输出 {} 使用 \\转义 { 即可,如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
  210. * 例:<br>
  211. * 通常使用:format("this is {} for {}", "a", "b") -> this is a for b<br>
  212. * 转义{}: format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
  213. * 转义\: format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
  214. *
  215. * @param template 文本模板,被替换的部分用 {} 表示
  216. * @param params 参数值
  217. * @return 格式化后的文本
  218. */
  219. public static String format(String template, Object... params)
  220. {
  221. if (isEmpty(params) || isEmpty(template))
  222. {
  223. return template;
  224. }
  225. return StrFormatter.format(template, params);
  226. }
  227. /**
  228. * 字符串转set
  229. *
  230. * @param str 字符串
  231. * @param sep 分隔符
  232. * @return set集合
  233. */
  234. public static final Set<String> str2Set(String str, String sep)
  235. {
  236. return new HashSet<String>(str2List(str, sep, true, false));
  237. }
  238. /**
  239. * 字符串转list
  240. *
  241. * @param str 字符串
  242. * @param sep 分隔符
  243. * @param filterBlank 过滤纯空白
  244. * @param trim 去掉首尾空白
  245. * @return list集合
  246. */
  247. public static final List<String> str2List(String str, String sep, boolean filterBlank, boolean trim)
  248. {
  249. List<String> list = new ArrayList<String>();
  250. if (StringUtils.isEmpty(str))
  251. {
  252. return list;
  253. }
  254. // 过滤空白字符串
  255. if (filterBlank && StringUtils.isBlank(str))
  256. {
  257. return list;
  258. }
  259. String[] split = str.split(sep);
  260. for (String string : split)
  261. {
  262. if (filterBlank && StringUtils.isBlank(string))
  263. {
  264. continue;
  265. }
  266. if (trim)
  267. {
  268. string = string.trim();
  269. }
  270. list.add(string);
  271. }
  272. return list;
  273. }
  274. /**
  275. * 下划线转驼峰命名
  276. */
  277. public static String toUnderScoreCase(String str)
  278. {
  279. if (str == null)
  280. {
  281. return null;
  282. }
  283. StringBuilder sb = new StringBuilder();
  284. // 前置字符是否大写
  285. boolean preCharIsUpperCase = true;
  286. // 当前字符是否大写
  287. boolean curreCharIsUpperCase = true;
  288. // 下一字符是否大写
  289. boolean nexteCharIsUpperCase = true;
  290. for (int i = 0; i < str.length(); i++)
  291. {
  292. char c = str.charAt(i);
  293. if (i > 0)
  294. {
  295. preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
  296. }
  297. else
  298. {
  299. preCharIsUpperCase = false;
  300. }
  301. curreCharIsUpperCase = Character.isUpperCase(c);
  302. if (i < (str.length() - 1))
  303. {
  304. nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
  305. }
  306. if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
  307. {
  308. sb.append(SEPARATOR);
  309. }
  310. else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
  311. {
  312. sb.append(SEPARATOR);
  313. }
  314. sb.append(Character.toLowerCase(c));
  315. }
  316. return sb.toString();
  317. }
  318. /**
  319. * 是否包含字符串
  320. *
  321. * @param str 验证字符串
  322. * @param strs 字符串组
  323. * @return 包含返回true
  324. */
  325. public static boolean inStringIgnoreCase(String str, String... strs)
  326. {
  327. if (str != null && strs != null)
  328. {
  329. for (String s : strs)
  330. {
  331. if (str.equalsIgnoreCase(trim(s)))
  332. {
  333. return true;
  334. }
  335. }
  336. }
  337. return false;
  338. }
  339. /**
  340. * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空,则返回空字符串。 例如:HELLO_WORLD->HelloWorld
  341. *
  342. * @param name 转换前的下划线大写方式命名的字符串
  343. * @return 转换后的驼峰式命名的字符串
  344. */
  345. public static String convertToCamelCase(String name)
  346. {
  347. StringBuilder result = new StringBuilder();
  348. // 快速检查
  349. if (name == null || name.isEmpty())
  350. {
  351. // 没必要转换
  352. return "";
  353. }
  354. else if (!name.contains("_"))
  355. {
  356. // 不含下划线,仅将首字母大写
  357. return name.substring(0, 1).toUpperCase() + name.substring(1);
  358. }
  359. // 用下划线将原始字符串分割
  360. String[] camels = name.split("_");
  361. for (String camel : camels)
  362. {
  363. // 跳过原始字符串中开头、结尾的下换线或双重下划线
  364. if (camel.isEmpty())
  365. {
  366. continue;
  367. }
  368. // 首字母大写
  369. result.append(camel.substring(0, 1).toUpperCase());
  370. result.append(camel.substring(1).toLowerCase());
  371. }
  372. return result.toString();
  373. }
  374. /**
  375. * 驼峰式命名法 例如:user_name->userName
  376. */
  377. public static String toCamelCase(String s)
  378. {
  379. if (s == null)
  380. {
  381. return null;
  382. }
  383. s = s.toLowerCase();
  384. StringBuilder sb = new StringBuilder(s.length());
  385. boolean upperCase = false;
  386. for (int i = 0; i < s.length(); i++)
  387. {
  388. char c = s.charAt(i);
  389. if (c == SEPARATOR)
  390. {
  391. upperCase = true;
  392. }
  393. else if (upperCase)
  394. {
  395. sb.append(Character.toUpperCase(c));
  396. upperCase = false;
  397. }
  398. else
  399. {
  400. sb.append(c);
  401. }
  402. }
  403. return sb.toString();
  404. }
  405. @SuppressWarnings("unchecked")
  406. public static <T> T cast(Object obj)
  407. {
  408. return (T) obj;
  409. }
  410. }

字符串格式化类 StrFormatter.java

  1. /**
  2. * 字符串格式化
  3. *
  4. * @author pricre
  5. */
  6. public class StrFormatter
  7. {
  8. public static final String EMPTY_JSON = "{}";
  9. public static final char C_BACKSLASH = '\\';
  10. public static final char C_DELIM_START = '{';
  11. public static final char C_DELIM_END = '}';
  12. /**
  13. * 格式化字符串<br>
  14. * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
  15. * 如果想输出 {} 使用 \\转义 { 即可,如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
  16. * 例:<br>
  17. * 通常使用:format("this is {} for {}", "a", "b") -> this is a for b<br>
  18. * 转义{}: format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
  19. * 转义\: format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
  20. *
  21. * @param strPattern 字符串模板
  22. * @param argArray 参数列表
  23. * @return 结果
  24. */
  25. public static String format(final String strPattern, final Object... argArray)
  26. {
  27. if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray))
  28. {
  29. return strPattern;
  30. }
  31. final int strPatternLength = strPattern.length();
  32. // 初始化定义好的长度以获得更好的性能
  33. StringBuilder sbuf = new StringBuilder(strPatternLength + 50);
  34. int handledPosition = 0;
  35. int delimIndex;// 占位符所在位置
  36. for (int argIndex = 0; argIndex < argArray.length; argIndex++)
  37. {
  38. delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);
  39. if (delimIndex == -1)
  40. {
  41. if (handledPosition == 0)
  42. {
  43. return strPattern;
  44. }
  45. else
  46. { // 字符串模板剩余部分不再包含占位符,加入剩余部分后返回结果
  47. sbuf.append(strPattern, handledPosition, strPatternLength);
  48. return sbuf.toString();
  49. }
  50. }
  51. else
  52. {
  53. if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH)
  54. {
  55. if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH)
  56. {
  57. // 转义符之前还有一个转义符,占位符依旧有效
  58. sbuf.append(strPattern, handledPosition, delimIndex - 1);
  59. sbuf.append(Convert.utf8Str(argArray[argIndex]));
  60. handledPosition = delimIndex + 2;
  61. }
  62. else
  63. {
  64. // 占位符被转义
  65. argIndex--;
  66. sbuf.append(strPattern, handledPosition, delimIndex - 1);
  67. sbuf.append(C_DELIM_START);
  68. handledPosition = delimIndex + 1;
  69. }
  70. }
  71. else
  72. {
  73. // 正常占位符
  74. sbuf.append(strPattern, handledPosition, delimIndex);
  75. sbuf.append(Convert.utf8Str(argArray[argIndex]));
  76. handledPosition = delimIndex + 2;
  77. }
  78. }
  79. }
  80. // 加入最后一个占位符后所有的字符
  81. sbuf.append(strPattern, handledPosition, strPattern.length());
  82. return sbuf.toString();
  83. }
  84. }

来源:https://blog.csdn.net/jlq_diligence/article/details/118255760
posted @ 2022-05-08 21:00  程序员小明1024  阅读(724)  评论(0编辑  收藏  举报