• String工具类

    1、第一个 

    1. package com.tigeriot.mqtt.util;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5. import java.util.StringTokenizer;
    6.  
    7. import com.alibaba.fastjson.JSON;
    8.  
    9. import org.springframework.util.StringUtils;
    10.  
    11. public class StringUtil {
    12. 	//
    13.  
    14. 	/**
    15. 	 * 将字符串的首字母转大写
    16. 	 * 
    17. 	 * @param str
    18. 	 *            需要转换的字符串
    19. 	 * @return
    20. 	 */
    21. 	public static String captureName(String str) {
    22. 		// 进行字母的ascii编码前移，效率要高于截取字符串进行转换的操作
    23. 		char[] cs = str.toCharArray();
    24. 		cs[0] -= 32;
    25. 		return String.valueOf(cs);
    26. 	}
    27.  
    28. 	/**
    29. 	 * 
    30. 	 * @param str_source
    31. 	 * @param str_target
    32. 	 * @return
    33. 	 */
    34. 	public static boolean isEquString(String str_source, String str_target) {
    35.  
    36. 		boolean flag = false;
    37. 		try {
    38.  
    39. 			if (str_target.equals(str_source)) {
    40. 				flag = true;
    41. 			}
    42. 		} catch (Exception e) {
    43. 			// TODO: handle exception
    44. 		}
    45.  
    46. 		return flag;
    47. 	}
    48.  
    49. 	///
    50. 	public static String getNameDepart(String realname) {
    51. 		try {
    52. 			// String mobile = "15888888888";
    53. 			String realname1 = null;
    54. 			char[] r = realname.toCharArray();
    55. 			// char[] m = mobile.toCharArray();
    56. 			if (r.length == 1) {
    57. 				realname1 = realname;
    58. 			}
    59. 			if (r.length == 2) {
    60. 				realname1 = realname.replaceFirst(realname.substring(1), "*");
    61. 			}
    62. 			if (r.length > 2) {
    63. 				realname1 = realname.replaceFirst(realname.substring(1, r.length - 1), "*");
    64. 			}
    65. 			// for (int i = 0; i < m.length; i++) {
    66. 			// if (i > 2 && i < 7) {
    67. 			// m[i] = '*';
    68. 			// }
    69. 			// }
    70. 			// String mobile1 = String.valueOf(m);
    71. 			// System.out.println(realname1);// 程*员
    72. 			// System.out.println(mobile1);// 158****8888
    73. 			return realname1;
    74. 		} catch (Exception e) {
    75. 			// TODO: handle exception
    76. 			return realname;
    77. 		}
    78.  
    79. 	}
    80.  
    81. 	///
    82. 	public static String decodeby10(String str) {
    83. 		StringBuffer out = new StringBuffer();
    84. 		if (str == null || ("".equals(str)))
    85. 			return "";
    86. 		char[] chars = str.toCharArray();
    87. 		for (int i = 0; i < chars.length; i++) {
    88. 			if ((chars[i] >= 19968 && chars[i] <= 40869) // 中日朝兼容形式的unicode编码范围：
    89. 															// U+4E00——U+9FA5
    90. 					|| (chars[i] >= 11904 && chars[i] <= 42191)// 中日朝兼容形式扩展
    91. 					|| (chars[i] >= 63744 && chars[i] <= 64255)// 中日朝兼容形式扩展
    92. 					|| (chars[i] >= 65072 && chars[i] <= 65103)// 中日朝兼容形式扩展
    93. 					|| (chars[i] >= 65280 && chars[i] <= 65519)// 全角ASCII、全角中英文标点、半宽片假名、半宽平假名、半宽韩文字母的unicode编码范围：U+FF00——U+FFEF
    94. 					|| (chars[i] >= 32 && chars[i] <= 126)// 半角字符的unicode编码范围：U+0020-U+007e
    95. 					|| (chars[i] >= 12289 && chars[i] <= 12319)// 全角字符的unicode编码范围：U+3000——U+301F
    96. 			) {
    97. 				out.append(chars[i]);
    98. 			}
    99. 		}
    100. 		String result = out.toString().trim();
    101. 		result = result.replaceAll("\\?", "").replaceAll("\\*", "").replaceAll("<|>", "").replaceAll("\\|", "")
    102. 				.replaceAll("/", "");
    103. 		return result;
    104. 	}
    105.  
    106. 	/**
    107. 	 * 
    108. 	 * 判断为 16进制字符串
    109. 	 * 
    110. 	 * @param str
    111. 	 * @return
    112. 	 */
    113. 	public static boolean isHexStr(String str) {
    114. 		boolean isHexFlg = true;
    115.  
    116. 		int i = 0;
    117. 		char c;
    118.  
    119. 		for (i = 0; i < str.length(); i++) {
    120. 			c = str.charAt(i);
    121.  
    122. 			if (!(((c >= '0') && (c <= '9')) || ((c >= 'A') && (c <= 'F')) || (c >= 'a') && (c <= 'f'))) {
    123. 				isHexFlg = false;
    124. 			}
    125. 		}
    126.  
    127. 		return isHexFlg;
    128. 	}
    129.  
    130. 	/*
    131. 	 * Convert byte[] to hex
    132. 	 * string.这里我们可以将byte转换成int，然后利用Integer.toHexString(int)来转换成16进制字符串。
    133. 	 * 
    134. 	 * @param src byte[] data
    135. 	 * 
    136. 	 * @return hex string
    137. 	 */
    138. 	public static String bytesToHexString(byte[] src) {
    139. 		StringBuilder stringBuilder = new StringBuilder("");
    140. 		if (src == null || src.length <= 0) {
    141. 			return null;
    142. 		}
    143. 		for (int i = 0; i < src.length; i++) {
    144. 			int v = src[i] & 0xFF;
    145. 			String hv = Integer.toHexString(v);
    146. 			if (hv.length() < 2) {
    147. 				stringBuilder.append(0);
    148. 			}
    149. 			stringBuilder.append(hv);
    150. 		}
    151. 		return stringBuilder.toString();
    152. 	}
    153.  
    154. 	/**
    155. 	 * Convert hex string to byte[]
    156. 	 * 
    157. 	 * @param hexString
    158. 	 *            the hex string
    159. 	 * @return byte[]
    160. 	 * 
    161. 	 *         2019年11月23日14:49:05
    162. 	 * 
    163. 	 *         16进制 字符串 转 16进制数组
    164. 	 */
    165. 	public static byte[] HexStringToHexBytes(String hexString)  {
    166. 		try {
    167. 			if (hexString == null || hexString.equals("")) {
    168. 				return null;
    169. 			}
    170.  
    171. 			if (!isHexStr(hexString)) {
    172. 				throw new Exception( "不合法的十六进制!");
    173. 			}
    174.  
    175. 			hexString = hexString.toUpperCase();
    176. 			int length = hexString.length() / 2;
    177. 			char[] hexChars = hexString.toCharArray();
    178. 			byte[] d = new byte[length];
    179. 			for (int i = 0; i < length; i++) {
    180. 				int pos = i * 2;
    181. 				d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
    182. 			}
    183. 			return d;
    184. 		} catch (Exception e) {
    185. 			// TODO: handle exception
    186. 			// return null;
    187. //			e.printStackTrace();
    188. 			System.out.println(e.getMessage());
    189. 		}
    190. 			return null;
    191. 	}
    192.  
    193. 	/**
    194. 	 * Convert char to byte
    195. 	 * 
    196. 	 * @param c
    197. 	 *            char
    198. 	 * @return byte
    199. 	 */
    200. 	private static byte charToByte(char c) {
    201. 		return (byte) "0123456789ABCDEF".indexOf(c);
    202. 	}
    203.  
    204. 	/**
    205. 	 * 
    206. 	 * 手机号码的加 *
    207. 	 */
    208.  
    209. 	// public static String createProxyTokenByParentId(String parentId) {
    210. 	//
    211. 	// String token = parentId + "00000000000000000000";
    212. 	//
    213. 	// return token;
    214. 	// }
    215.  
    216. 	/**
    217. 	 * 
    218. 	 * 手机号码的加 *
    219. 	 */
    220.  
    221. 	public static String getTel_PartContent(String tel) {
    222.  
    223. 		try {
    224. 			// 括号表示组，被替换的部分$n表示第n组的内容
    225. 			tel = tel.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    226. 			return tel;
    227. 		} catch (Exception e) {
    228. 			// TODO: handle exception
    229.  
    230. 			return "***err***";
    231. 		}
    232.  
    233. 	}
    234.  
    235. 	/**
    236. 	 * 将字符串以指定字符串切割后,分配到List中
    237. 	 * 
    238. 	 * @param strValue-->输入字符串
    239. 	 * @return List
    240. 	 */
    241. 	public static List getTokenizerList(String strValue, String delim) {
    242. 		List myList = new ArrayList();
    243. 		if (strValue == null) {
    244. 			return myList;
    245. 		}
    246. 		StringTokenizer stChat = new StringTokenizer(strValue, delim);
    247. 		int iLength = stChat.countTokens();
    248. 		for (int i = 0; i < iLength; i++) {
    249. 			String strTemp = stChat.nextToken();
    250. 			if (strTemp == null)
    251. 				strTemp = "";
    252. 			myList.add(strTemp);
    253. 		}
    254. 		return myList;
    255. 	}
    256.  
    257. 	/**
    258. 	 * 
    259. 	 * 将字节数组转为 HEX字符
    260. 	 * 
    261. 	 * @param b
    262. 	 */
    263. 	public static void printHexString(byte[] b) {
    264. 		for (int i = 0; i < b.length; i++) {
    265. 			String hex = Integer.toHexString(b[i] & 0xFF);
    266. 			if (hex.length() == 1) {
    267. 				hex = '0' + hex;
    268. 			}
    269. 			System.out.print(hex.toUpperCase() + "");// + " "
    270. 		}
    271. 		System.out.println("");
    272. 	}
    273.  
    274.  
    275. 	/**
    276. 	 *
    277. 	 * 将字节转为 HEX字符
    278. 	 *
    279. 	 * @param b
    280. 	 */
    281. 	public static String getHexString(byte b) {
    282. 		StringBuffer hex_str = new StringBuffer();
    283. 		try {
    284. 			String hex = Integer.toHexString(b & 0xFF);
    285. 			if (hex.length() == 1) {
    286. 				hex = '0' + hex;
    287. 			}
    288. 			hex_str.append(hex.toLowerCase());// + " "//转为小写
    289. 			return hex_str.toString();
    290. 		} catch (Exception e) {
    291. 			return null;
    292. 		}
    293. 	}
    294.  
    295. 	/**
    296. 	 * 
    297. 	 * 将字节数组转为 HEX字符
    298. 	 * 
    299. 	 * @param b
    300. 	 */
    301. 	public static String getHexString(byte[] b) {
    302. 		StringBuffer hex_str = new StringBuffer();
    303. 		try {
    304. 			for (int i = 0; i < b.length; i++) {
    305. 				String hex = Integer.toHexString(b[i] & 0xFF);
    306. 				if (hex.length() == 1) {
    307. 					hex = '0' + hex;
    308. 				}
    309. 				hex_str.append(hex.toLowerCase());// + " "//转为小写
    310. 			}
    311. 			return hex_str.toString();
    312. 		} catch (Exception e) {
    313. 			// TODO: handle exception
    314. 			return null;
    315. 		}
    316. 	}
    317.  
    318. 	/**
    319. 	 *
    320. 	 * 将字节数组转为 HEX字符
    321. 	 *
    322. 	 * @param hexString
    323. 	 */
    324. 	public static String[] getHexStringArr(String hexString) throws Exception {
    325. 		try {
    326. 			if (hexString == null || hexString.equals("")) {
    327. 				return null;
    328. 			}
    329.  
    330. 			if (!isHexStr(hexString)) {
    331. 				throw new Exception("不合法的十六进制!");
    332. 			}
    333. 			String[] strList = new String[hexString.length()/2];
    334. 			String [] temp = hexString.split("");
    335. 			int index = 0;
    336. 			for (int i = 0; i < temp.length; i+=2) {
    337. 				strList[index] = temp[i] + temp[i+1];
    338. 				index++;
    339. 			}
    340. 			return strList;
    341. 		} catch (Exception e) {
    342. 			// TODO: handle exception
    343. 			// return null;
    344. 			throw new Exception( "不合法的16进制!");
    345. 		}
    346. 	}
    347.  
    348. 	/**
    349. 	 * 
    350. 	 * 截取字符串后几位
    351. 	 */
    352. 	public static String subStr(String str, int n) {
    353. 		if (n < str.length()) {
    354. 			return str.substring(str.length() - n, str.length());
    355. 		} else {
    356. 			return str;
    357. 		}
    358.  
    359. 	}
    360.  
    361. 	/***
    362. 	 * 
    363. 	 * 去除空格
    364. 	 */
    365.  
    366. 	public static String StringTim(String str) {
    367. 		try {
    368. 			return str.replaceAll("\\s*", "").trim();
    369. 		} catch (Exception e) {
    370. 			e.printStackTrace();
    371. 			return "";
    372. 		}
    373.  
    374. 	}
    375.  
    376. 	/**
    377. 	 * 
    378. 	 * 抽取字符串里面的数字
    379. 	 * 
    380. 	 * @param str
    381. 	 * @return
    382. 	 */
    383. 	public static String getNumStr(String str) {
    384. 		str = str.trim();
    385. 		String str2 = "";
    386. 		if (str != null && !"".equals(str)) {
    387. 			for (int i = 0; i < str.length(); i++) {
    388. 				if (str.charAt(i) >= 48 && str.charAt(i) <= 57) {
    389. 					str2 += str.charAt(i);
    390. 				}
    391. 			}
    392. 		}
    393. 		return str2;
    394.  
    395. 	}
    396.  
    397. 	/**
    398. 	 * 
    399. 	 * 判断字符串是否是全数字
    400. 	 * 
    401. 	 * @param str
    402. 	 * @return
    403. 	 */
    404. 	public static boolean isNumStr(String str) {
    405. 		str = str.trim();
    406. 		boolean isNum = true;
    407. 		if (str != null && !"".equals(str)) {
    408. 			for (int i = 0; i < str.length(); i++) {
    409. 				if (str.charAt(i) >= 48 && str.charAt(i) <= 57) {
    410. 				} else {
    411. 					isNum = false;
    412. 				}
    413. 			}
    414. 		} else {
    415. 			isNum = false;
    416. 		}
    417.  
    418. 		return isNum;
    419. 	}
    420.  
    421. 	/**
    422. 	 * 字符串转化成为16进制字符串
    423. 	 * 
    424. 	 * @param s
    425. 	 * @return
    426. 	 */
    427. 	public static String strTo16(String s) {
    428. 		String str = "";
    429. 		for (int i = 0; i < s.length(); i++) {
    430. 			int ch = (int) s.charAt(i);
    431. 			String s4 = Integer.toHexString(ch);
    432. 			str = str + s4;
    433. 		}
    434. 		return str;
    435. 	}
    436.  
    437. 	/**
    438. 	 * 
    439. 	 * long 转 4个 HEX
    440. 	 * 
    441. 	 * @param i
    442. 	 * @return
    443. 	 */
    444. 	public static String getHex_4formLong(long i) {
    445. 		String hex4 = "00000000" + Long.toHexString(i);
    446.  
    447. 		int length = hex4.length();
    448.  
    449. 		return hex4.substring(length - 8, length);
    450.  
    451. 	}
    452.  
    453. 	/**
    454. 	 *
    455. 	 * long 转 4个 HEX
    456. 	 *
    457. 	 * @param i
    458. 	 * @return
    459. 	 */
    460. 	public static String getHex_4formInt(int i) {
    461. 		String hex4 = "00000000" + Integer.toHexString(i);
    462.  
    463. 		int length = hex4.length();
    464.  
    465. 		return hex4.substring(length - 8, length);
    466.  
    467. 	}
    468.  
    469. 	/**
    470. 	 * 
    471. 	 * long 转 4个 HEX
    472. 	 * 
    473. 	 * @param i
    474. 	 * @return
    475. 	 */
    476. 	public static String getHex_2formShort(short i) {
    477. 		String hex4 = "00000000" + Integer.toHexString(i);
    478.  
    479. 		int length = hex4.length();
    480.  
    481. 		return hex4.substring(length - 4, length);
    482.  
    483. 	}
    484.  
    485. 	/**
    486. 	 * 
    487. 	 * long 转 4个 HEX
    488. 	 * 
    489. 	 * @param i
    490. 	 * @return
    491. 	 */
    492. 	public static String getHex_1formShort(short i) {
    493. 		String hex4 = "00000000" + Integer.toHexString(i);
    494.  
    495. 		int length = hex4.length();
    496.  
    497. 		return hex4.substring(length - 2, length);
    498.  
    499. 	}
    500.  
    501. 	/**
    502. 	 * 
    503. 	 * long 转 1个 HEX
    504. 	 * 
    505. 	 * @param i
    506. 	 * @return
    507. 	 */
    508. 	public static String getHex_1formLong(byte i) {
    509. 		String hex4 = "00000000" + Integer.toHexString(i);
    510.  
    511. 		int length = hex4.length();
    512.  
    513. 		return hex4.substring(length - 2, length);
    514.  
    515. 	}
    516.  
    517. 	/**
    518. 	 * 16进制直接转换成为字符串(无需Unicode解码)
    519. 	 * 
    520. 	 * @param hexStr
    521. 	 * @return
    522. 	 */
    523. 	public static String hexStr_to_Str(String hexStr) {
    524. 		String str = "0123456789ABCDEF";
    525. 		char[] hexs = hexStr.toCharArray();
    526. 		byte[] bytes = new byte[hexStr.length() / 2];
    527. 		int n;
    528. 		for (int i = 0; i < bytes.length; i++) {
    529. 			n = str.indexOf(hexs[2 * i]) * 16;
    530. 			n += str.indexOf(hexs[2 * i + 1]);
    531. 			bytes[i] = (byte) (n & 0xff);
    532. 		}
    533. 		return new String(bytes);
    534. 	}
    535.  
    536. 	//
    537. 	/**
    538. 	 * 
    539. 	 * 判断一个字符串是否为url
    540. 	 * 
    541. 	 * @param str
    542. 	 *            String 字符串
    543. 	 * 
    544. 	 * @return boolean 是否为url
    545. 	 * 
    546. 	 * @author peng1 chen
    547. 	 * 
    548. 	 **/
    549.  
    550. 	public static boolean isURL(String str) {
    551.  
    552. 		// 转换为小写
    553.  
    554. 		str = str.toLowerCase();
    555.  
    556. 		String regex = "^((https|http|ftp|rtsp|mms|tcp)?://)" // https、http、ftp、rtsp、mms
    557.  
    558. 				+ "?(([0-9a-z_!~*'().&=+$%-]+: )?[0-9a-z_!~*'().&=+$%-]+@)?" // ftp的user@
    559.  
    560. 				+ "(([0-9]{1,3}\\.){3}[0-9]{1,3}" // IP形式的URL- 例如：199.194.52.184
    561.  
    562. 				+ "|" // 允许IP和DOMAIN（域名）
    563.  
    564. 				+ "([0-9a-z_!~*'()-]+\\.)*" // 域名- www.
    565.  
    566. 				+ "([0-9a-z][0-9a-z-]{0,61})?[0-9a-z]\\." // 二级域名
    567.  
    568. 				+ "[a-z]{2,6})" // first level domain- .com or .museum
    569.  
    570. 				+ "(:[0-9]{1,5})?" // 端口号最大为65535,5位数
    571.  
    572. 				+ "((/?)|" // a slash isn't required if there is no file name
    573.  
    574. 				+ "(/[0-9a-z_!~*'().;?:@&=+$,%#-]+)+/?)$";
    575.  
    576. 		return str.matches(regex);
    577.  
    578. 	}
    579.  
    580. 	/**
    581. 	 * ID数组json串转List
    582. 	 * 
    583. 	 * @param bindUserIds_req
    584. 	 * @return
    585. 	 */
    586. 	public static List getStringListByJsonStr(String bindUserIds_req) {
    587. 		List result = new ArrayList();
    588. 		try {
    589. 			if (bindUserIds_req != null) {
    590. 				result = JSON.parseArray(bindUserIds_req, String.class);
    591. 			}
    592. 		} catch (Exception e) {
    593. 			// TODO: handle exception
    594. 		}
    595. 		return result;
    596. 	}
    597.  
    598. 	/**
    599. 	 * 
    600. 	 * 
    601. 	 * @param args
    602. 	 */
    603. 	public static void main(String[] args) {
    604.  
    605. 		String str = "tcp://192.168.1.155";
    606. 		System.out.println(isURL(str));
    607.  
    608. 	}
    609.  
    610. 	public static boolean isNullOrEmpty(String s) {
    611. 		return s == null || s.isEmpty();
    612. 	}
    613. 	public static boolean isNotNullAndNotEmpty(String s) {
    614. 		return !isNullOrEmpty(s);
    615. 	}
    616.  
    617. //	public static String getHex_2formInt(Integer num) {
    618. //		try {
    619. //			return StringUtil.getHexString(MathUtil.intToBytes2(num));
    620. //		}catch (Exception e){
    621. //
    622. //		}
    623. //		return null;
    624. //	}
    625. }

    2、第二个

    1. package com.tigeriot.mqtt.util;
    2.  
    3. import cn.hutool.core.util.RandomUtil;
    4. import cn.hutool.crypto.digest.DigestUtil;
    5. import com.tigeriot.mqtt.common.CodeConst;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.springframework.util.StringUtils;
    8.  
    9. import java.security.SecureRandom;
    10. import java.util.ArrayList;
    11. import java.util.Arrays;
    12. import java.util.List;
    13. import java.util.Random;
    14.  
    15. @Slf4j
    16. public class StringHexUtil {
    17.  
    18.     /**
    19.      * 16进制字符串转字节数组
    20.      * @param hexStr
    21.      * @return
    22.      */
    23.     public static byte[] hexToByte(String hexStr){
    24.         if(StringUtils.isEmpty(hexStr) ||!isHexStr(hexStr)){
    25.             //判断失败
    26.  
    27.             return null;
    28.         }
    29.         return stringHexToBytes(hexStr);
    30.     }
    31.  
    32.  
    33.  
    34.     /**
    35.      * 实现字节数组转16进制字符串
    36.      * @param bytes
    37.      * @return
    38.      */
    39.     public static String byteToHex(byte[] bytes){
    40.  
    41.         StringBuilder hexString = new StringBuilder();
    42.  
    43.         for (byte b : bytes) {
    44.             String hex = Integer.toHexString(b & 0xFF);
    45.             if (hex.length() == 1) {
    46.                 hexString.append('0');
    47.             }
    48.             hexString.append(hex);
    49.         }
    50.  
    51.         return hexString.toString();
    52.     }
    53.  
    54.  
    55.  
    56.     /**
    57.      * 判断是否合格16进制数
    58.      * @param hexStr
    59.      * @return
    60.      */
    61.     public static boolean isHexStr(String hexStr){
    62.         String []s = {"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F","a","b","c","d","e","f"};
    63.         List list = Arrays.asList(s);
    64.         char [] chars = hexStr.toCharArray();
    65.         for (char c : chars) {
    66.             if(!list.contains(String.valueOf(c))){
    67.                 return false;
    68.             }
    69.         }
    70.         return true;
    71.     }
    72.  
    73.  
    74.     /**
    75.      * 实现 16进制 字符串转字节数组
    76.      * @param str
    77.      * @return
    78.      */
    79.     public static byte[] stringHexToBytes(String str){
    80.  
    81.                 char[] hexChars = str.toCharArray();
    82.                 byte[] bytes = new byte[hexChars.length / 2];
    83.  
    84.                 for (int i = 0; i < bytes.length; i++) {
    85.                     int highNibble = Character.digit(hexChars[i * 2], 16);
    86.                     int lowNibble = Character.digit(hexChars[i * 2 + 1], 16);
    87.                     bytes[i] = (byte) ((highNibble << 4) | lowNibble);
    88.                 }
    89.  
    90.  
    91.                 return bytes;
    92.  
    93.         }
    94.  
    95.  
    96.  
    97.  
    98.     /**
    99.      * 判断字符串是否 为空串 为null 为空格
    100.      * @param str
    101.      * @return
    102.      */
    103.     public static boolean isNotBlank(String str) {
    104.         return str != null && !str.isEmpty() && !str.trim().isEmpty();
    105.     }
    106.  
    107.  
    108.     /**
    109.      * 验证 clientID 是否合法
    110.      * @param clientID
    111.      * @return
    112.      */
    113.     public static RV validateClientID(String clientID){
    114.  
    115.  
    116.         if (!StringHexUtil.isNotBlank(clientID)){
    117.             log.info("您的clientID不能为空格，空串，null:"+clientID);
    118.             return RV.error(CodeConst.FAIL,"您的ClientID为空或空串",null);
    119.         } else if (clientID.length()!=15) {
    120.             log.info("您的clientID长度不为15:"+clientID);
    121.             return RV.error(CodeConst.FAIL,"您的clientID长度不为15",null);
    122.         } else if (!isNumeric(clientID)) {
    123.             log.info("您的clientID不是数字:"+clientID);
    124.             return RV.error(CodeConst.FAIL,"您的clientID不是数字",null);
    125.         } else {
    126.             return RV.ok(CodeConst.SUCCESS,"验证通过",null);
    127.         }
    128.  
    129.  
    130.  
    131.     }
    132.  
    133.  
    134.     /**
    135.      * 生成 n 位随机 0-9的数
    136.      * @param length
    137.      * @return
    138.      */
    139.     public static String generateRandomNumber(int length) {
    140.         Random random = new Random();
    141.         StringBuilder sb = new StringBuilder(length);
    142.         for (int i = 0; i < length; i++) {
    143.             int digit = random.nextInt(10);  // 生成0-9的随机数字
    144.             sb.append(digit);
    145.         }
    146.         return sb.toString();
    147.     }
    148.  
    149. //随机20位字符串
    150.     private static final String LOWERCASE_CHARACTERS = "abcdefghijklmnopqrstuvwxyz";
    151.     private static final String UPPERCASE_CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    152.     private static final String DIGITS = "0123456789";
    153.     private static final String ALL_CHARACTERS = LOWERCASE_CHARACTERS + UPPERCASE_CHARACTERS + DIGITS;
    154.  
    155.  
    156.     private static final SecureRandom RANDOM = new SecureRandom();
    157.  
    158.     /**
    159.      * 随机生成20位 包含大小写字母与数字的字符串
    160.      * @param length
    161.      * @return
    162.      */
    163.     public static String generateRandomString(int length) {
    164.         StringBuilder randomString = new StringBuilder(length);
    165.         // 确保至少包含一个小写字母、一个大写字母和一个数字字符
    166.         randomString.append(LOWERCASE_CHARACTERS.charAt(RANDOM.nextInt(LOWERCASE_CHARACTERS.length())));
    167.         randomString.append(UPPERCASE_CHARACTERS.charAt(RANDOM.nextInt(UPPERCASE_CHARACTERS.length())));
    168.         randomString.append(DIGITS.charAt(RANDOM.nextInt(DIGITS.length())));
    169.         // 生成剩余的字符
    170.         for (int i = 3; i < length; i++) {
    171.             randomString.append(ALL_CHARACTERS.charAt(RANDOM.nextInt(ALL_CHARACTERS.length())));
    172.         }
    173.         // 洗牌字符，使其顺序随机
    174.         return shuffleString(randomString.toString());
    175.     }
    176.  
    177.  
    178.  
    179.     /**
    180.      * 函数用于洗牌字符串中的字符
    181.      * @param input
    182.      * @return
    183.      */
    184.     private static String shuffleString(String input) {
    185.         char[] characters = input.toCharArray();
    186.         for (int i = characters.length - 1; i > 0; i--) {
    187.             int randomIndex = RANDOM.nextInt(i + 1);
    188.             char temp = characters[i];
    189.             characters[i] = characters[randomIndex];
    190.             characters[randomIndex] = temp;
    191.         }
    192.         return new String(characters);
    193.     }
    194.  
    195.  
    196.  
    197.  
    198.  
    199.     /**
    200.      * 验证字符串是不是纯数字
    201.      * @param str
    202.      * @return
    203.      */
    204.     public static boolean isNumeric(String str) {
    205.         if (str == null || str.length() == 0) {
    206.             return false;
    207.         }
    208.         for (int i = 0; i < str.length(); i++) {
    209.             if (!Character.isDigit(str.charAt(i))) {
    210.                 return false;
    211.             }
    212.         }
    213.         return true;
    214.     }
    215.  
    216.  
    217.     /**
    218.      * 将字符串实现SHA256加密算法
    219.      * @param str
    220.      */
    221.     public static String strToSha256(String str){
    222.  
    223.         return DigestUtil.sha256Hex(str);
    224.     }
    225.  
    226.     public static void main(String[] args) {
    227.  
    228.  
    229.         System.out.println(generateRandomString(20));
    230.     }
    231.  
    232.  
    233.  
    234. }

    需要导入依赖

    1.  
    2.         
    3.         <dependency>
    4.             <groupId>cn.hutoolgroupId>
    5.             <artifactId>hutool-allartifactId>
    6.             <version>5.8.18version>
    7.         dependency>

  • 相关阅读:
    二叉树的遍历
    什么是杜邦分析?杜邦分析法的公式及示例
    Vue模板语法上集（02）
    JS解混淆
    3. Apache HBase 为什么快？
    机械制造企业如何借助ERP系统，做好生产排产管理？
    如何使用 人像比对API
    cmake入门
    MySQL索引优化实战指南（InsCode AI 创作助手）
    内存管理——C++
  • 原文地址：https://blog.csdn.net/qq_53374893/article/details/134258727