package com.lunhan.xxx.common.util;
|
|
import com.lunhan.xxx.common.ConstantFactory;
|
import com.lunhan.xxx.common.security.MD5Util;
|
import org.apache.commons.lang3.EnumUtils;
|
import org.apache.commons.lang3.StringUtils;
|
|
import java.lang.reflect.Method;
|
import java.math.BigDecimal;
|
import java.nio.charset.Charset;
|
import java.util.*;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
import java.util.stream.Collectors;
|
|
/**
|
* 字符串处理类
|
* @author linliu
|
* @date 2018-12-28
|
*/
|
public final class StringUtil {
|
//region 常量
|
private static final String REGX_MOBILEPHONE = "^((\\+86)|(\\(\\+86\\))-)?[0-9]{11}$";
|
|
private static final String REGX_TELEPHONE = "^((\\+86)|(\\(\\+86\\))-)?(((0[1,2]{1}\\d{1})?-?\\d{8})|((0[3-9]{1}\\d{2})?-?\\d{7,8}))$";
|
|
private static final String REGX_IDCARD = "^([0-9]{17}[0-9X]{1})|([0-9]{15})$";
|
|
private static final String REGX_WEBURL = "^(((file|gopher|news|nntp|telnet|http|ftp|https|ftps|sftp)://)|(www\\.))+(([a-zA-Z0-9\\._-]+\\.[a-zA-Z]{2,6})|([0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}))(/[a-zA-Z0-9\\&%_\\./-~-]*)?$";
|
|
private static final String REGX_EMAIL = "^\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$";
|
|
private static final String REGX_MONEY = "^\\d{1,12}(?:\\.\\d{1,4})?$";
|
|
private static final String DEFAULT = "utf-8";
|
//endregion
|
|
private StringUtil() {
|
throw new IllegalStateException("Utility class");
|
}
|
|
/**
|
* 从当前对象移除头尾指定字符
|
* @author xiangyuanzhang
|
* @date 2018-12-25
|
* @param source 原始字符串
|
* @param trimChar 移除字符串
|
*/
|
public String trim(String source, String trimChar) {
|
if(source==null){
|
return "";
|
}
|
source = source.trim();
|
if(source.isEmpty()){
|
return "";
|
}
|
String beginChar = source.substring(0, 1);
|
if (beginChar.equalsIgnoreCase(trimChar)) {
|
source = source.substring(1, source.length());
|
}
|
String endChar = source.substring(source.length() - 1, source.length());
|
if (endChar.equalsIgnoreCase(trimChar)) {
|
source = source.substring(0, source.length() - 1);
|
}
|
return source;
|
}
|
|
/**
|
* 从当前对象移除头部指定字符
|
* @author xiangyuanzhang
|
* @date 2018-12-25
|
* @param source 原始字符串
|
* @param trimChar 移除字符串
|
*/
|
public String trimStart(String source, String trimChar) {
|
if(source==null){
|
return "";
|
}
|
source = source.trim();
|
if(source.isEmpty()){
|
return "";
|
}
|
String beginChar = source.substring(0, 1);
|
if (beginChar.equalsIgnoreCase(trimChar)) {
|
source = source.substring(1, source.length());
|
}
|
return source;
|
}
|
|
/**
|
* 从当前对象移除尾部指定字符
|
* @author xiangyuanzhang
|
* @date 2018-12-25
|
* @param source 原始字符串
|
* @param trimChar 移除字符串
|
*/
|
public String trimEnd(String source, String trimChar) {
|
if(source==null){
|
return "";
|
}
|
source = source.trim();
|
if(source.isEmpty()){
|
return "";
|
}
|
String endChar = source.substring(source.length() - 1, source.length());
|
if (endChar.equalsIgnoreCase(trimChar)) {
|
source = source.substring(0, source.length() - 1);
|
}
|
return source;
|
}
|
|
/**
|
* 字符串枚举值转成枚举对象
|
* @author linliu
|
* @date 2018-12-24
|
* @param enumType 枚举类型
|
* @param value 枚举值
|
* @param <T> 枚举类型
|
* @return 枚举对象
|
*/
|
public static <T extends Enum<T>> T parseEnum(Class<T> enumType, String value) {
|
if(isNullOrEmpty(value)) {
|
return null;
|
}
|
|
T result = null;
|
try {
|
T[] values = enumType.getEnumConstants();
|
Method getValue = enumType.getMethod("getValue");
|
|
for (T e : values) {
|
if(getValue.invoke(e).toString().equals(value)) {
|
result = e;
|
break;
|
}
|
}
|
} catch (Exception e) {
|
//TODO log
|
}
|
return result;
|
}
|
|
/**
|
* 字符串枚举值转成枚举对象
|
* @author linliu
|
* @date 2018-12-24
|
* @param enumType 枚举类型
|
* @param name 枚举名称
|
* @param <T> 枚举类型
|
* @return 枚举对象
|
*/
|
public static <T extends Enum<T>> T parseEnumByName(Class<T> enumType, String name) {
|
if(isNullOrEmpty(name)) {
|
return null;
|
}
|
|
T result = null;
|
try {
|
result = EnumUtils.getEnum(enumType, name);
|
} catch (Exception e) {
|
//TODO log
|
}
|
return result;
|
}
|
|
/**
|
* 判断枚举是否申明了传入枚举值
|
* @author linliu
|
* @date 2018-12-24
|
* @param enumType 枚举类型
|
* @param value 枚举值
|
* @param <T> 枚举类型
|
* @return 是否包含
|
*/
|
public static <T extends Enum<T>> boolean isEnum(Class<T> enumType, String value) {
|
return (null != parseEnum(enumType, value));
|
}
|
|
/**
|
* 判断枚举是否申明了传入枚举值
|
* @author linliu
|
* @date 2018-12-24
|
* @param enumType 枚举类型
|
* @param name 枚举名称
|
* @param <T> 枚举类型
|
* @return 是否包含
|
*/
|
public static <T extends Enum<T>> boolean isEnumName(Class<T> enumType, String name) {
|
return EnumUtils.isValidEnum(enumType, name);
|
}
|
|
/**
|
* 字符串是否为空
|
* @author linliu
|
* @date 2018-12-25
|
* @param str 字符串
|
* @return 是否为空
|
*/
|
public static boolean isNullOrEmpty(String str){
|
return (str==null || str.equals("") || str.replace(" ","").length() == 0);
|
}
|
|
/**
|
* 字符串非空
|
* @author linliu
|
* @date 2018-12-25
|
* @param str 字符串
|
* @return 是否非空
|
*/
|
public static boolean isNotNullOrEmpty(String str){
|
return !isNullOrEmpty(str);
|
}
|
|
/**
|
* 集合，使用英文逗号“,”拼接成一个字符串
|
* @param list 集合
|
*/
|
public static String join(Collection<String> list){
|
return StringUtil.join(list, ",");
|
}
|
/**
|
* 集合，使用指定的字符，拼接成一个字符串
|
* @param list 集合
|
* @param separator 拼接字符
|
*/
|
public static String join(Collection<String> list, String separator){
|
if(ListUtil.isNullOrEmpty(list)){
|
return "";
|
}
|
return StringUtils.join(list.toArray(), separator);
|
}
|
/**
|
* 数组，使用英文逗号“,”拼接成一个字符串
|
* @param array 数组
|
*/
|
public static String join(String[] array){
|
return StringUtil.join(array, ",");
|
}
|
/**
|
* 数组，使用指定的字符，拼接成一个字符串
|
* @param array 数组
|
* @param separator 拼接字符
|
*/
|
public static String join(String[] array, String separator){
|
if(array == null){
|
return "";
|
}
|
return StringUtils.join(array, separator);
|
}
|
|
/**
|
* 集合，使用英文逗号“,”拼接成一个字符串
|
* @param list 集合
|
*/
|
public static String joinNumber(Collection<Number> list){
|
return StringUtil.joinNumber(list, ",");
|
}
|
/**
|
* 集合，使用指定的字符，拼接成一个字符串
|
* @param list 集合
|
* @param separator 拼接字符
|
*/
|
public static String joinNumber(Collection<Number> list, String separator){
|
if(ListUtil.isNullOrEmpty(list)){
|
return "";
|
}
|
return StringUtils.join(list.toArray(), separator);
|
}
|
/**
|
* 数组，使用英文逗号“,”拼接成一个字符串
|
* @param array 数组
|
*/
|
public static String joinNumber(Number[] array){
|
return joinNumber(array, ",");
|
}
|
/**
|
* 数组，使用指定的字符，拼接成一个字符串
|
* @param array 数组
|
* @param separator 拼接字符
|
*/
|
public static String joinNumber(Number[] array, String separator){
|
if(array == null){
|
return "";
|
}
|
return StringUtils.join(array, separator);
|
}
|
|
/**
|
* base64解码(utf-8编码)
|
* @author linliu
|
* @date 2019-06-14
|
* @param str 密文字符串
|
* @return 解码后的明文
|
*/
|
public static String base64Encode(String str) {
|
return base64Encode(str, DEFAULT);
|
}
|
/**
|
* base64解码
|
* @author linliu
|
* @date 2019-06-14
|
* @param str 密文字符串
|
* @param encoding 编码格式[默认utf-8]
|
* @return 解码后的明文
|
*/
|
public static String base64Encode(String str, String encoding) {
|
if(isNullOrEmpty(str)) {
|
return "";
|
}
|
if(isNullOrEmpty(encoding)) {
|
encoding = DEFAULT;
|
}
|
byte[] bytes = str.getBytes(Charset.forName(encoding));
|
return Base64.getEncoder().encodeToString(bytes);
|
}
|
|
/**
|
* base64解码(utf-8编码)
|
* @author linliu
|
* @date 2019-06-14
|
* @param str 密文字符串
|
* @return 解码后的明文
|
*/
|
public static String base64Decode(String str) {
|
return base64Decode(str, DEFAULT);
|
}
|
/**
|
* base64解码
|
* @author linliu
|
* @date 2019-06-14
|
* @param str 密文字符串
|
* @param encoding 编码格式[默认utf-8]
|
* @return 解码后的明文
|
*/
|
public static String base64Decode(String str, String encoding) {
|
if(isNullOrEmpty(str)) {
|
return "";
|
}
|
if(isNullOrEmpty(encoding)) {
|
encoding = DEFAULT;
|
}
|
byte[] bytes = Base64.getDecoder().decode(str);
|
return new String(bytes, Charset.forName(encoding));
|
}
|
|
/**
|
* 传入字符串是否是有效的手机号码
|
* @param str 字符串
|
*/
|
public static boolean isMobilePhone(String str) {
|
return Pattern.matches(REGX_MOBILEPHONE, str);
|
}
|
|
/**
|
* 传入字符串是否是有效的座机号码
|
* @param str 字符串
|
*/
|
public static boolean isTelPhone(String str) {
|
return Pattern.matches(REGX_TELEPHONE, str);
|
}
|
|
/**
|
* 传入字符串是否是有效的身份证号码
|
* @param str 字符串
|
*/
|
public static boolean isIdCard(String str) {
|
return Pattern.matches(REGX_IDCARD, str);
|
}
|
|
/**
|
* 传入字符串是否是有效的网址
|
* @param str 字符串
|
*/
|
public static boolean isWebUrl(String str) {
|
return Pattern.matches(REGX_WEBURL, str);
|
}
|
|
/**
|
* 传入字符串是否是有效的电子邮件邮箱地址
|
* @param str 字符串
|
*/
|
public static boolean isEmail(String str) {
|
return Pattern.matches(REGX_EMAIL, str);
|
}
|
|
/**
|
* 传入字符串是否是有效的金额
|
* @param str 字符串
|
*/
|
public static boolean isMoney(String str) {
|
return Pattern.matches(REGX_MONEY, str);
|
}
|
|
/**
|
* 是否满足正则表达式规则
|
* @author linliu
|
* @date 2019-01-04
|
* @param str 字符串
|
* @param regex 正则表达式
|
* @return 是否匹配
|
*/
|
public static Boolean isMatch(String str,String regex) {
|
if(StringUtil.isNullOrEmpty(str)) {
|
return Boolean.FALSE;
|
}
|
return Pattern.matches(regex, str);
|
}
|
|
/**
|
* 正则获取Xml中的内容
|
* @author xiangyuanzhang
|
* @date 2019-01-09
|
* @param xml 传入的xml字符串
|
* @param label 指定的标签中的内容
|
*/
|
public static String regexXml(String xml, String label) {
|
String context = "";
|
String rgex = "<" + label + ">(.*?)</" + label + ">";
|
Pattern pattern = Pattern.compile(rgex,Pattern.CASE_INSENSITIVE);
|
Matcher m = pattern.matcher(xml);
|
List<String> list = new ArrayList<>();
|
int i = 1;
|
while (m.find()) {
|
list.add(m.group(i));
|
i++;
|
}
|
if (!list.isEmpty()) {
|
context = list.get(0);
|
}
|
return context;
|
}
|
|
/**
|
* 获取<![CDATA 中内容
|
* @author xiangyuanzhang
|
* @date 2019-01-14
|
* @param str
|
* @return
|
*/
|
public static String getCDATAContent(String str) {
|
Pattern p = Pattern.compile(".*<!\\[CDATA\\[(.*)\\]\\]>.*");
|
Matcher m = p.matcher(str);
|
if(m.matches()) {
|
return m.group(1);
|
}
|
return str;
|
}
|
|
/**
|
* 将传入字符串转成 Integer 类型
|
* @param str 字符串
|
*/
|
public static int parseInt(String str) {
|
return Integer.parseInt(str);
|
}
|
|
/**
|
* 将传入字符串转成 Long 类型
|
* @param str 字符串
|
*/
|
public static long parseLong(String str) {
|
return Long.parseLong(str);
|
}
|
|
/**
|
* 将传入字符串转成精度为2位小数的 BigDecimal 类型
|
* @param str 字符串
|
*/
|
public static BigDecimal parseBigDecimal(String str) {
|
return parseBigDecimal(str, Integer.parseInt("2"));
|
}
|
|
/**
|
* 将传入字符串转成指定精度的 BigDecimal 类型
|
* @param str 字符串
|
*/
|
public static BigDecimal parseBigDecimal(String str, Integer length) {
|
BigDecimal bd = new BigDecimal(str);
|
return bd.setScale(length, BigDecimal.ROUND_HALF_UP);
|
}
|
|
/**
|
* 传入字符串是否是有效的 BigDecimal
|
* @param str 字符串
|
*/
|
public static boolean isBigDecimal(String str) {
|
try{
|
if(isNullOrEmpty(str)) {
|
return false;
|
}
|
new BigDecimal(str);
|
return true;
|
}catch (NumberFormatException e){
|
return false;
|
}
|
}
|
|
/**
|
* 将传入指定格式的字符串转成 Calendar 类型（默认“yyyy-MM-dd HH:mm:ss”）
|
* @param str 时间字符串
|
* @param format 时间格式
|
*/
|
public static Calendar parseDate(String str, String... format) {
|
String f = ConstantFactory.STR_DATE_FULL;
|
if(format.length>0) {
|
f = format[0];
|
}
|
return CalendarUtil.fromStr(str, f);
|
}
|
|
/**
|
* md5加密
|
* @param content 待加密明文字符串
|
*/
|
public static String md5(String content) {
|
return MD5Util.encrypt(content);
|
}
|
|
/**
|
* 集合，使用英文逗号“,”拼接成一个字符串
|
* @param list 集合
|
*/
|
public static String joinInt(List<Integer> list){
|
return joinInt(list, ",");
|
}
|
/**
|
* 集合，使用指定的字符，拼接成一个字符串
|
* @param list 集合
|
* @param separator 拼接字符
|
*/
|
public static String joinInt(List<Integer> list, String separator){
|
if(ListUtil.isNullOrEmpty(list)){
|
return "";
|
}
|
return StringUtils.join(list.toArray(), separator);
|
}
|
|
/**
|
* 数组，使用英文逗号“,”拼接成一个字符串
|
* @param array 数组
|
*/
|
public static String joinInt(Integer[] array){
|
return joinInt(array, ",");
|
}
|
/**
|
* 数组，使用指定的字符，拼接成一个字符串
|
* @param array 数组
|
* @param separator 拼接字符
|
*/
|
public static String joinInt(Integer[] array, String separator){
|
if(array == null){
|
return "";
|
}
|
return StringUtils.join(array, separator);
|
}
|
|
/**
|
* 将传入字符串按指定分隔符，拆分成数组
|
* @param str 字符串
|
* @param splitChar 分隔符
|
*/
|
public static String[] split(String str, String splitChar) {
|
if(StringUtil.isNullOrEmpty(str)) {
|
return new String[0];
|
}
|
return str.split(splitChar);
|
}
|
/**
|
* 将传入字符串按英文逗号“,”分隔，拆分成数组
|
* @param str 字符串
|
*/
|
public static String[] split(String str) {
|
if(StringUtil.isNullOrEmpty(str)) {
|
return new String[0];
|
}
|
return str.split("\\,");
|
}
|
|
/**
|
* 将传入字符串按指定分隔符，拆分成集合
|
* @param str 字符串
|
* @param splitChar 分隔符
|
*/
|
public static List<String> splitList(String str, String splitChar) {
|
if(StringUtil.isNullOrEmpty(str)) {
|
return new ArrayList<>();
|
}
|
return ListUtil.toList(split(str, splitChar));
|
}
|
/**
|
* 将传入字符串按英文逗号“,”分隔，拆分成集合
|
* @param str 字符串
|
*/
|
public static List<String> splitList(String str) {
|
if(StringUtil.isNullOrEmpty(str)) {
|
return new ArrayList<>();
|
}
|
return splitList(str, ",");
|
}
|
|
/**
|
* 将传入字符串按指定分隔符，拆分成集合
|
* @param str 字符串
|
* @param splitChar 分隔符
|
*/
|
public static List<Integer> splitIntList(String str, String splitChar) {
|
if(StringUtil.isNullOrEmpty(str)) {
|
return new ArrayList<>();
|
}
|
return ListUtil.toIntList(splitList(str, splitChar));
|
}
|
/**
|
* 将传入字符串按英文逗号“,”分隔，拆分成集合
|
* @param str 字符串
|
*/
|
public static List<Integer> splitIntList(String str) {
|
if(StringUtil.isNullOrEmpty(str)) {
|
return new ArrayList<>();
|
}
|
return splitIntList(str, ",");
|
}
|
|
/**
|
* 将传入字符串按指定分隔符，拆分成集合
|
* @param str 字符串
|
* @param splitChar 分隔符
|
*/
|
public static List<Long> splitLongList(String str, String splitChar) {
|
if(StringUtil.isNullOrEmpty(str)) {
|
return new ArrayList<>();
|
}
|
return ListUtil.toLongList(splitList(str, splitChar));
|
}
|
/**
|
* 将传入字符串按英文逗号“,”分隔，拆分成集合
|
* @param str 字符串
|
*/
|
public static List<Long> splitLongList(String str) {
|
if(StringUtil.isNullOrEmpty(str)) {
|
return new ArrayList<>();
|
}
|
return splitLongList(str, ",");
|
}
|
|
/**
|
* 集合，使用英文逗号“,”拼接成一个字符串
|
* @param list 集合
|
*/
|
public static String joinLong(Collection<Long> list) {
|
return StringUtil.joinLong(list, ",");
|
}
|
/**
|
* 集合，使用指定的字符，拼接成一个字符串
|
* @param list 集合
|
* @param separator 拼接字符
|
*/
|
public static String joinLong(Collection<Long> list, String separator) {
|
if(ListUtil.isNullOrEmpty(list)){
|
return "";
|
}
|
return StringUtils.join(list.toArray(), separator);
|
}
|
|
/**
|
* 数组，使用英文逗号“,”拼接成一个字符串
|
* @param array 数组
|
*/
|
public static String joinLong(Long[] array) {
|
return joinLong(array, ",");
|
}
|
/**
|
* 数组，使用指定的字符，拼接成一个字符串
|
* @param array 数组
|
* @param separator 拼接字符
|
*/
|
public static String joinLong(Long[] array, String separator){
|
if(array == null){
|
return "";
|
}
|
return StringUtils.join(array, separator);
|
}
|
|
/**
|
* 将字符串按英文逗号“,”分割，拆分成日期集合
|
* @param str
|
* @param dateFormat
|
* @return
|
*/
|
public static List<Date> splitListDate(String str, String dateFormat) {
|
return splitListDate(str, dateFormat, ",");
|
}
|
/**
|
* 将字符串按指定分隔符，拆分成日期集合
|
* @param str 字符串
|
* @param dateFormat 日期格式
|
* @return
|
*/
|
public static List<Date> splitListDate(String str, String dateFormat, String separator) {
|
if(StringUtil.isNullOrEmpty(str)) {
|
return new ArrayList<>();
|
}
|
List<String> lstDate = splitList(str, separator);
|
return lstDate.stream().map(d -> {
|
try {
|
return CalendarUtil.fromStr(d, dateFormat).getTime();
|
} catch (Exception e) {
|
return null;
|
}
|
}).collect(Collectors.toList());
|
}
|
|
/**
|
* 按指定字符串分割字符串
|
* @author linliu
|
* @date 2019-06-19
|
* @param str 字符串
|
* @param onceQuantity 拆分后单个字符串的字符数
|
*/
|
public static String[] split(String str, Integer onceQuantity) {
|
if(StringUtil.isNullOrEmpty(str)) {
|
return new String[]{};
|
}
|
if(Integer.valueOf(0).compareTo(onceQuantity)>-1) {
|
onceQuantity = str.length();
|
}
|
int size = str.length() / onceQuantity;
|
String[] result = new String[size];
|
if(size==1) {
|
result[0] = str;
|
return result;
|
}
|
for (int idx=0; idx<size; idx++) {
|
result[idx] = substring(str, onceQuantity*idx, onceQuantity*(idx+1));
|
}
|
return result;
|
}
|
|
/**
|
* 按指定字符串分割字符串
|
* @author linliu
|
* @date 2019-06-19
|
* @param str 字符串
|
* @param onceQuantity 拆分后单个字符串的字符数
|
*/
|
public static List<String> splitList(String str, Integer onceQuantity) {
|
if(StringUtil.isNullOrEmpty(str)) {
|
return new ArrayList<>();
|
}
|
if(Integer.valueOf(0).compareTo(onceQuantity)>-1) {
|
onceQuantity = str.length();
|
}
|
int size = str.length() / onceQuantity;
|
List<String> result = new ArrayList<>();
|
if(size==1) {
|
result.add(str);
|
return result;
|
}
|
if(str.length()%onceQuantity != 0) {
|
size += 1;
|
}
|
for (int idx=0; idx<size; idx++) {
|
result.add(substring(str, onceQuantity*idx, onceQuantity*(idx+1)));
|
}
|
return result;
|
}
|
|
/**
|
* 分割字符串，如果开始位置大于字符串长度，返回空
|
* @author linliu
|
* @date 2019-06-19
|
* @param str 原始字符串
|
* @param start 开始位置
|
* @param end 结束位置
|
*/
|
public static String substring(String str, Integer start, Integer end) {
|
if (StringUtil.isNullOrEmpty(str) || start > str.length()) {
|
return "";
|
}
|
if (end > str.length()) {
|
return str.substring(start, str.length());
|
} else {
|
return str.substring(start, end);
|
}
|
}
|
|
/**
|
* 截取字符串长度
|
* @param content 字符串
|
* @param length 截取长度
|
*/
|
public static String cutStr(String content, Integer length) {
|
return StringUtil.substring(content, 0, length);
|
}
|
|
/**
|
* 判断是否为空，如果为空返回空字符串
|
* @param str 字符串
|
*/
|
public static String getStringDefault(String str) {
|
if (StringUtil.isNullOrEmpty(str)) {
|
return "";
|
}
|
return str;
|
}
|
|
/**
|
* 将小驼峰字符串转为_连接的
|
* @param input 字符串
|
*/
|
public static String camelCaseToUnderscore(String input) {
|
if (input == null) {
|
return null;
|
}
|
|
StringBuilder result = new StringBuilder();
|
boolean prevIsLowerCase = false;
|
|
for (char c : input.toCharArray()) {
|
if (Character.isUpperCase(c)) {
|
if (prevIsLowerCase) {
|
result.append('_');
|
}
|
result.append(Character.toLowerCase(c));
|
prevIsLowerCase = false;
|
} else {
|
result.append(c);
|
prevIsLowerCase = true;
|
}
|
}
|
|
return result.toString();
|
}
|
|
/**
|
* 字符串转16进制字符
|
* @param input 字符串
|
*/
|
public static String toHexString(String input) {
|
StringBuilder str = new StringBuilder();
|
for (int i = 0; i < input.length(); i++) {
|
int ch = input.charAt(i);
|
String s4 = Integer.toHexString(ch);
|
str.append(s4);
|
}
|
return str.toString();
|
}
|
}
|
