/**
* 版权所有:厦门市巨龙软件工程有限公司
* Copyright 2009 Xiamen Dragon Software Eng. Co. Ltd.
* All right reserved.
*====================================================
* 文件名称: StringUtils.java
* 修订记录:
* No 日期 作者(操作:具体内容)
* 1. Mar 3, 2009 何志昭(创建:创建文件)
* 2004-11-16 陈雄华更改了splitString方法、增加了toVisualString方法、增加了subStringCount方法
* 2. Mar 3, 2009 根据dragonsoft_checks.xml规范进行调整
*====================================================
* 类描述:
*
*/
package com.luqj.util;
import java.security.MessageDigest;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
*
* 字符串处理工具类.
* <blockquote>
* <b>数字格式化样式</b>
* <table border=0 cellspacing=3 cellpadding=0 width="90%">
*
* |
* Symbol
* |
*
* Location
* |
*
* Localized
* |
*
* Meaning
* |
*
*
*
* 0 |
*
* Number
* |
*
* Yes
* |
*
* Digit
* |
*
*
*
* #
* |
*
* Number
* |
*
* Yes
* |
*
* Digit, zero shows as absent
* |
*
*
*
* .
* |
*
* Number
* |
*
* Yes
* |
*
* Decimal separator or monetary decimal separator
* |
*
*
*
* -
* |
*
* Number
* |
*
* Yes
* |
*
* Minus sign
* |
*
*
*
* ,
* |
*
* Number
* |
*
* Yes
* |
*
* Grouping separator
* |
*
*
*
* E |
*
* Number
* |
*
* Yes
* |
*
* Separates mantissa and exponent in scientific notation.
*
* Need not be quoted in prefix or suffix.
* |
*
*
*
* ;
* |
*
* Subpattern boundary
* |
*
* Yes
* |
*
* Separates positive and negative subpatterns
* |
*
*
*
* %
* |
*
* Prefix or suffix
* |
*
* Yes
* |
*
* Multiply by 100 and show as percentage
* |
*
*
*
* \u2030
* |
*
* Prefix or suffix
* |
*
* Yes
* |
*
* Multiply by 1000 and show as per mille
* |
*
*
*
* ¤
* (
*
* \u00A4
*
* )
* |
*
* Prefix or suffix
* |
*
* No
* |
*
* Currency sign, replaced by currency symbol. If
* doubled, replaced by international currency symbol.
* If present in a pattern, the monetary decimal separator
* is used instead of the decimal separator.
* |
*
*
*
* '
* |
*
* Prefix or suffix
* |
*
* No
* |
*
* Used to quote special characters in a prefix or suffix,
* for example,
*
* "'#'#"
*
* formats 123 to
*
* "#123"
*
* . To create a single quote
* itself, use two in a row:
*
* "# o''clock"
*
* .
* |
*
* </table>
*
* <b>符号(Symbol)通常是组合在一起使用的,例如下表</b>
* <table border=0 cellspacing=3 cellpadding=0 width="90%">
*
* |
* 输入
* |
*
* 格式
* |
*
* 输出
* |
*
*
* |
* 1234.123456
* |
*
* 0 |
*
* 1234
* |
*
*
*
* 0.00
* |
*
* 1234.12
* |
*
*
*
* 0.###
* |
*
* 1234.123
* |
*
*
*
* 0.0000
* |
*
* 1234.1235
* |
*
*
*
* 00000000.00
* |
*
* 00001234.12
* |
*
*
*
* ,000.00
* |
*
* 1,234.12
* |
*
*
*
* ,00.00000000
* |
*
* 12,34.12345600
* |
*
*
*
* 0.00%
* |
*
* 123412.35%
* |
*
*
* |
* 1234.100056
* |
*
* 0 |
*
* 1234
* |
*
*
*
* 0.00
* |
*
* 1234.10
* |
*
*
*
* 0.##
* |
*
* 1234.1
* |
*
*
*
* (人民币),000.00
* |
*
* (人民币)1,234.10
* |
*
*
*
* ,000.########
* |
*
* 1,234.100056
* |
*
* </table>
*
* 注:0与#功能类似,区别在于用0表示位数时,格式化后的首尾的0会显示,而用#表示位数时,首尾的0不显示
* </blockquote>
*
*
*
*
* - JDK版本:
*
* - 1.4
*
*
* @author 涂传滨,伊新煦,陈雄华,谢计生
* @version 1.0
* @since 1.0
* @see DecimalFormat
*/
public final class StringUtils {
/** 字符长度 */
public static final int CHAR_LEN = 1;
/** 字节长度 */
public static final int BYTE_LEN = 2;
final static SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyyMMddHHmmss");;
public static boolean notBlank(String str) {
return !isBlank(str);
}
public static boolean notBlank(String... strings) {
if (strings == null || strings.length == 0) {
return false;
}
for (String str : strings) {
if (isBlank(str)) {
return false;
}
}
return true;
}
public static boolean hasText(String text) {
if (text == null)
return false;
for (int i = 0; i < text.length(); i++) {
if (!Character.isWhitespace(text.charAt(i)))
return true;
}
return false;
}
public static String parseDateToString(Object obj){
String dateStr = null;
if(obj == null){
return null;
}
if(obj.getClass().getName().equals("java.sql.Date")){
Date date = (Date) obj;
return String.valueOf(date.getTime());
}else if(obj.getClass().getName().equals("java.sql.Timestamp")){
Timestamp date = (Timestamp) obj;
return String.valueOf(date.getTime());
}else if(obj.getClass().getName().equals("java.sql.Time")){
Time date = (Time) obj;
return String.valueOf(date.getTime());
}else{
return String.valueOf(obj);
}
/*if(obj.getClass().getName().equals("java.sql.Date")||
obj.getClass().getName().equals("java.sql.Timestamp")||
obj.getClass().getName().equals("java.sql.Time")){
try {
Date date = (Date) obj;
date.getTime();
dateStr = DATE_FORMAT.format(obj);
} catch (ArrayIndexOutOfBoundsException e) {
// TODO Auto-generated catch block
e.printStackTrace();
logger.error("出现异常的数据"+obj);
throw new ArrayIndexOutOfBoundsException("数组越界"+obj);
}
}else{
return (String)obj;
}
*/
//return dateStr;
}
public static String uuid(){
return UUID.randomUUID().toString().replaceAll("-", "");
}
public static String lowerFirst(String v){
return v.replaceFirst(v.substring(0,1), v.substring(0,1).toLowerCase());
}
public static String upFirst(String v){
return v.replaceFirst(v.substring(0,1), v.substring(0,1).toUpperCase());
}
/**
* 数字字符串转化为整数
*
* @param intStr
* String 待转化的数字字符串
* @param intDef
* int 当intStr为空或空字符串时返回的缺省值
* @return int 返回由数字字符串转化成的数字,当intStr为空或空字符串时,返回缺省值intDef
*/
public static int getInt(String intStr, int intDef) {
if (null == intStr || "".equals(intStr.trim())) {
return intDef;
}
int intRetu = intDef;
Double db = new Double(intStr);
intRetu = db.intValue();
return intRetu;
}
/**
* 数字字符串转化为整数,在转化时发生异常,则返回0
*
* @param intStr
* String 待转化的数字字符串
* @return int 返回由数字字符串转化成的整数,当intStr为空或空字符串时,返回0
*/
public static int getInt(String intStr) {
return getInt(intStr, 0);
}
/**
* 数字字符串转化为双精数字
*
* @param dbstr
* String 待转化的数字字符串
* @param dbDef
* double 当dbstr为空或空字符串时返回的缺省值
* @return double 返回由数字字符串转化成的数字,当dbstr为空或空字符串时,则返回缺省值dbDef
*/
public static double getDouble(String dbstr, double dbDef) {
if (null == dbstr || "".equals(dbstr.trim())) {
return dbDef;
}
double dbRetu = dbDef;
Double db = new Double(dbstr);
dbRetu = db.doubleValue();
return dbRetu;
}
/**
* 数字字符串转化为双精数字,在转化时发生异常,则返回0
*
* @param dbstr
* String 待转化的数字字符串
* @return double 返回由数字字符串转化成的数字,当dbstr为空或空字符串时,则返回0。
*/
public static double getDouble(String dbstr) {
return getDouble(dbstr, 0);
}
/**
* 数字字符串转化为长整型
*
* @param longstr
* String 待转化的数字字符串
* @param longDef
* long 当longstr为空或空字符串时返回的缺省值
* @return long 返回由数字字符串转化成的数字,当longstr为空或空字符串时,则返回缺省值longDef
*/
public static long getLong(String longstr, long longDef) {
if (null == longstr || "".equals(longstr.trim())) {
return longDef;
}
long longRetu = longDef;
Double db = new Double(longstr);
longRetu = db.longValue();
return longRetu;
}
/**
* 数字字符串转化为长整型,在转化时发生异常,则返回0
*
* @param longstr
* String 待转化的数字字符串
* @return long 返回由数字字符串转化成的数字,当longstr为空或空字符串时,则返回0。
*/
public static long getLong(String longstr) {
return getLong(longstr, 0);
}
/**
* 字符串转化为布尔型
*
* @param booleanstr
* String 待转化的字符串
* @param booleanDef
* boolean 当字符串为空或为null时返回的值
* @return boolean 返回转化化的布尔值,只有当booleanstr为字符串“true”(忽略大小写)时才返回true,
* 如果在转化时发生异常(只有为null时),则返回缺省值booleanDef
*/
public static boolean getBoolean(String booleanstr, boolean booleanDef) {
if (null == booleanstr) {
return booleanDef;
}
boolean booleanRetu = booleanDef;
if ("true".equalsIgnoreCase(booleanstr.trim())) {
booleanRetu = true;
}
return booleanRetu;
}
/**
* 字符串转化为布尔型.
* 只有当booleanstr为字符串“true”(忽略大小写)时才返回true,其它都返回false, 包括booleanstr为null
*
* @param booleanstr
* String 待转化的字符串
* @return boolean 返回转化化的布尔值,
*/
public static boolean getBoolean(String booleanstr) {
return getBoolean(booleanstr, false);
}
/**
* 双精数字格式化,返回字符串
*
* @param db
* double 待格式化的双精数字
* @param fmt
* String 格式化样式,参见类说明,
* fmt非法时,db将按原样转化为字符串后返回。
* @return String 格式化后的数字,以字符串方式返回
*/
public static String getNumFormat(double db, String fmt) {
String retu = "";
if (null == fmt || "".equals(fmt.trim())) {
return Double.toString(db);
}
try {
DecimalFormat decimalformat = new DecimalFormat(fmt);
retu = decimalformat.format(db);
decimalformat = null;
} catch (IllegalArgumentException iaex) {
// ialog.error(ex.getMessage());
retu = Double.toString(db);
}
return retu;
}
/**
* 双精数字格式化,把入参中的双精数格式化为带两位小数的数字字符串
*
* @param db
* double 待格式化的双精数字
* @return String 格式化为两位小数的数字字符串
*/
public static String getNumFormat(double db) {
return getNumFormat(db, "0.00");
}
/**
* 数字字符串格式化,返回字符串
*
* @param numStr
* String 待格式化的数字字符串,
* 如果numStr参数不是的数字则不进行格式化,按原样返回
* @param fmt
* String 格式化样式,参见类说明
* fmt非法时,将把numStr按原样返回。
* @return String 格式化后的字符串
*/
public static String getNumFormat(String numStr, String fmt) {
double db = getDouble(numStr, 0);
return getNumFormat(db, fmt);
}
/**
* 数字字符串格式化,把入参中的数字字符串格式化为带两位小数的数字字符串
*
* @param numStr
* String 待格式化的数字字符串,
* 如果numStr参数不是的数字则不进行格式化,按原样返回
* @return String 格式化为两位小数的数字字符串
*/
public static String getNumFormat(String numStr) {
return getNumFormat(numStr, "0.00");
}
/**
* 普通字符串转化为网页中可显示的,如回车转化为<br>.
*
* @param str
* String 待转化的字符串
* @return String 转化后的字符串
*/
public static String htmlEncode(String str) {
String retu = null;
if (null == str || "".equals(str.trim())) {
retu = str;
} else {
String html = str;
//StringUtils tool = new StringUtils();
html = replaceString(html, "&", "&");
html = replaceString(html, "<", "<");
html = replaceString(html, ">", ">");
html = replaceString(html, "\r\n", "\n");
html = replaceString(html, "\n", "
");
html = replaceString(html, "\t", " ");
html = replaceString(html, " ", " ");
html = replaceString(html, "\"", """);
retu = html;
html = null;
}
return retu;
}
/**
* 字符串替换,把str字符串中的所有oldStr子串替换为newStr字串
*
* @param sourceStr
* String 将被替换的字符串,为null时不执行任何替换操作
* @param oldStr
* String 将被替换的子串,为null或为空字符串时不执行替换操作
* @param newStr
* String 将被替换成的子串,为null时不执行替换操作
* @param isIgnoreCase
* boolean 是否忽略大小写,true表忽略大小写,false表大小写敏感。
* @return String 替换后的字符串
*/
public static String replaceString(String sourceStr, String oldStr, String newStr, boolean isIgnoreCase) {
if (sourceStr == null || oldStr == null || oldStr.equals("")) {
return null;
}
String strRetStr = sourceStr;
int pos = strRetStr.indexOf(oldStr);
while (pos != -1) {
strRetStr = strRetStr.substring(0, pos) + newStr + strRetStr.substring(pos + oldStr.length());
pos = strRetStr.indexOf(oldStr, pos + newStr.length());
}
return strRetStr;
}
/**
* 字符串替换,把str字符串中的所有oldStr子串替换为newStr字串(大小写敏感)
*
* @param sourceStr
* String 将被替换的字符串,为null时不执行任何替换操作
* @param oldStr
* String 将被替换的子串,为null或为空字符串时不执行替换操作
* @param newStr
* String 将被替换成的子串,为null时不执行替换操作
* @return String 替换后的字符串
*/
public static String replaceString(String sourceStr, String oldStr, String newStr) {
return replaceString(sourceStr, oldStr, newStr, false);
}
/**
* 字符串按指定分隔符分解为一个数组(大小写敏感).
* 例子:
* String[] array = StringUtils.splictString("AA/BBB/CCC//DDDD//" , "/" );
*
* 结果:
* array[0]="AA" array[1]="BBB" array[2]="CCC" array[3]="DDDD"
*
* @param sourceStr
* String 源字符串
* @param splitStr
* String 分隔符
* @param isTrim
* boolean
* @return String[] 字符串数组,
* 源字符串为null或为空字符串时,返回长度为1的数组,元素值为空字符串
* 分隔符为null或为空字符串时,返回长度为1的数组,元素值为源字符串
*/
public static String[] splitString(String sourceStr, String splitStr, boolean isTrim) {
String newSourceStr = sourceStr;
String newSplitStr = splitStr;
if (newSourceStr == null || newSplitStr == null) {
return null;
}
if (isTrim) // 去掉开始和结束的分隔符
{
// 开头的间隔符去掉
while (newSourceStr.indexOf(newSplitStr) == 0) {
newSourceStr = newSourceStr.substring(newSplitStr.length());
}
// 尾部的间隔符去掉
while (newSourceStr.indexOf(newSplitStr, newSourceStr.length() - newSplitStr.length()) > -1) {
newSourceStr = newSourceStr.substring(0, sourceStr.length() - newSplitStr.length());
}
}
if (newSourceStr.equals("") || newSplitStr.equals("")) {
return null;
}
return splitString(newSourceStr, newSplitStr);
}
/**
* 功能简述 :把字符串放入一个数组
*
* @param sourceStr
* 要被放入的字符串
* @param splitStr
* 间隔符
* @return 转换后的数组,sourceStr或splitStr = null 或 "" 返回null
*/
public static String[] splitString(String sourceStr, String splitStr) {
String newSourceStr = sourceStr;
String newSplitStr = splitStr;
if (newSourceStr == null || newSplitStr == null) {
return null;
}
if (newSourceStr.equals("") || newSplitStr.equals("")) {
return null;
}
int intArraySize = subStringCount(newSourceStr, newSplitStr);
// 如果为-1则返回
if (intArraySize == -1) {
return null;
}
newSourceStr += newSplitStr;
String[] strRetArr = new String[intArraySize + 1];
int intpos = newSourceStr.indexOf(newSplitStr);
int intArrayPos = 0;
while (intpos != -1) {
strRetArr[intArrayPos++] = newSourceStr.substring(0, intpos);
newSourceStr = newSourceStr.substring(intpos + newSplitStr.length());
intpos = newSourceStr.indexOf(newSplitStr);
}
return strRetArr;
}
/**
* 功能简述 :把字符串放入一个数组
* @param sourceStr
* 要被放入的字符串
* @param splitStr
* 间隔符
* @return 转换后的List,sourceStr或splitStr = null 或 "" 返回元素个数为0的List
*/
public static List splitString2List(String sourceStr, String splitStr) {
String[] tempArr = splitString(sourceStr, splitStr);
List resultList = new ArrayList();
if (tempArr != null) {
for (int i = 0; i < tempArr.length; i++) {
resultList.add(tempArr[i]);
}
}
return resultList;
}
/**
* 功能简述 :把字符串放入一个数组
*
* @param sourceStr
* 要被放入的字符串
* @param splitStr
* 间隔符
* @param isTrim
* boolean
* @return 转换后的List,sourceStr或splitStr = null 或 "" 返回元素个数为0的List
*/
public static List splitString2List(String sourceStr, String splitStr, boolean isTrim) {
String[] tempArr = splitString(sourceStr, splitStr, isTrim);
List resultList = new ArrayList();
if (tempArr != null) {
for (int i = 0; i < tempArr.length; i++) {
resultList.add(tempArr[i]);
}
}
return resultList;
}
/**
* 功能简述 :在一个字符串中查找字符串个数(不区分大小写)
*
* @param sourceStr
* 要被查询的字符串
* @param subStr
* 要查找的字符串
* @return 找到的个数
*/
public static int subStringCount(String sourceStr, String subStr) {
// 如果是空指针则返回-1
if (sourceStr == null || subStr == null) {
return -1;
}
if (sourceStr.equals("") || subStr.equals("")) {
return -1;
}
int result = 0;
int intPos = sourceStr.toUpperCase().indexOf(subStr.toUpperCase());
while (intPos != -1) {
result++;
intPos = sourceStr.toUpperCase().indexOf(subStr.toUpperCase(), intPos + subStr.length());
}
return result;
}
/**
* 用指定的分隔符把字符串数组合并成一个字符串. 数组为null或长度为0时返回空字符串
* 例子:
* String[] array = {"1",null,"","3"};
* StringUtils.arrayToString(array,"|");
* 返回结果:1|||3
*
* @param array
* String[] 待合并的数组
* @param splitStr
* String 数组各元素合并后,它们之间的分隔符,为null时用空字符串代替
* @return String 合并后的字符串
*/
public static String arrayToString(String[] array, String splitStr) {
if (null == array || 0 == array.length) {
return "";
}
String newSplitStr = splitStr;
if (null == newSplitStr) {
newSplitStr = "";
}
StringBuffer strBuf = new StringBuffer("");
int len = array.length;
for (int i = 0; i < len - 1; i++) {
strBuf.append((null == array[i]) ? "" : array[i]).append(newSplitStr);
}
strBuf.append((null == array[len - 1]) ? "" : array[len - 1]);
return strBuf.toString();
}
/**
* 用默认分隔符 | 把字符串数组合并成一个字符串. 数组为null或长度为0时返回空字符串
*
* @param array
* String[] 待合并的数组
* @return String 合并后的字符串
*/
public static String arrayToString(String[] array) {
return arrayToString(array, "|");
}
/**
* 判断字符串是否为null或为空字符串(包括只含空格的字符串)
*
* @param str
* String 待检查的字符串
* @return boolean 如果为null或空字符串(包括只含空格的字符串)则返回true,否则返回false
*/
public static boolean isNullBlank(String str) {
return (null == str || "".equals(str.trim())) ? true : false;
}
/**
* 从字符串中得到指定位置的子串(按分隔符分隔,大小写敏感).
* 例子:
* StringUtils.decomposeString("a||b|c|d","|",1);
* StringUtils.decomposeString("a||b|c|d","|",2);
* StringUtils.decomposeString("a||b|c|d","|",3);
* StringUtils.decomposeString("a||b|c|d","|",4);
* StringUtils.decomposeString("a||b|c|d","|",5);
* 返回结果:
* a,空字符串,b,c,d
*
* @param sourceStr
* String 源字符串
* @param splitStr
* String 分隔符
* @param pos
* int 位置,从1开始
* @return String 返回指定位置的子串。
* 当分隔符为null或为空字符串时返回源字符串;
* 当源字符串为null或为空字符串时返回空字符串;
* 当指定位置小于1或大于分隔符个数-1时返回空字符串。
*/
public static String decomposeString(String sourceStr, String splitStr, int pos) {
String retu = "";
String newSourceStr = sourceStr;
if (null == newSourceStr || "".equals(newSourceStr.trim())) {
return "";
}
if (pos <= 0) {
return "";
}
if (null == splitStr || "".equals(splitStr)) {
return sourceStr;
}
newSourceStr = newSourceStr + splitStr;
String tmpStr = newSourceStr;
int splitLen = splitStr.length();
int tmpLen = tmpStr.length();
for (int i = 0; i < pos - 1; i++) {
int tmpPosi = tmpStr.indexOf(splitStr);
if (tmpPosi < 0 || tmpPosi + splitLen >= tmpLen) {
tmpStr = splitStr;
break;
} else {
tmpStr = tmpStr.substring(tmpPosi + splitLen);
}
}
retu = tmpStr.substring(0, tmpStr.indexOf(splitStr));
return retu;
}
/**
* 从字符串中得到指定位置的子串(按分隔符 | 分隔).
*
* @param sourceStr
* String 源字符串
* @param pos
* int 位置,从1开始
* @return String 返回指定位置的子串。
* 当分隔符为null或为空字符串时返回源字符串;
* 当源字符串为null或为空字符串时返回空字符串;
* 当指定位置小于1或大于分隔符个数-1时返回空字符串。
*/
public static String decomposeString(String sourceStr, int pos) {
return decomposeString(sourceStr, "|", pos);
}
/**
* 删除指定的前导、后导子串(大小写敏感).
* 例子:
* StringUtils.trim("and and username = '123' and password = 'abc' and
* ","and ");
* 结果:username = '123' and password = 'abc'
*
* @param sourceStr
* String 待删除的字符串
* @param removeChar
* char 子串
* @return String 处理后的字符串
*/
public static String trim(String sourceStr, char removeChar) {
if (sourceStr == null) {
return null;
}
String newSourceStr = sourceStr;
newSourceStr = newSourceStr.trim();
int loIntBegin = 0;
int loIntEnd = 0;
int loIntLen = newSourceStr.length();
for (int i = 0; i < loIntLen; i++) {
if (newSourceStr.charAt(i) == removeChar) {
loIntBegin++;
} else {
break;
}
}
for (int i = 0; i < loIntLen; i++) {
if (newSourceStr.charAt(loIntLen - 1 - i) == removeChar) {
loIntEnd++;
} else {
break;
}
}
return newSourceStr.substring(loIntBegin, loIntLen - loIntEnd);
}
/**
* 删除指定的前导、后导子串(大小写敏感).
* 例子:
* StringUtils.trim("and and username = '123' and password = 'abc' and
* ","and ");
* 结果:username = '123' and password = 'abc'
*
* @param sourceStr
* String 待删除的字符串
* @param removeChar
* char 子串
* @param end
* true 只trim末尾,false 只trim头部
* @return String 处理后的字符串
*/
public static String trim(String sourceStr, char removeChar, boolean end) {
if (sourceStr == null) {
return null;
}
String newSourceStr = sourceStr;
newSourceStr = newSourceStr.trim();
int loIntBegin = 0;
int loIntEnd = 0;
int loIntLen = newSourceStr.length();
for (int i = 0; i < loIntLen; i++) {
if (newSourceStr.charAt(i) == removeChar) {
loIntBegin++;
} else {
break;
}
}
for (int i = 0; i < loIntLen; i++) {
if (newSourceStr.charAt(loIntLen - 1 - i) == removeChar) {
loIntEnd++;
} else {
break;
}
}
if (end) {
return newSourceStr.substring(0, loIntLen - loIntEnd);
} else {
return newSourceStr.substring(loIntBegin);
}
}
/**
*
* 将字符串截短到特定的长度,一个中文是两个字节的长度,但是是1个字符的长度,例:
* 1)truncate("巨龙软件公司",2,CHAR_LEN) = "巨龙"
* 2)truncate("巨龙软件公司",2,BYTE_LEN) = "巨"
* 3)truncate("dragonsoft",2,CHAR_LEN) = "dr"
* 4)truncate("dragonsoft",2,BYTE_LEN) = "dr"
*
*
* @param str
* String 需要截的字符串
* @param len
* int 截到的目标长度
* @param lenType
* int 长度类型,字符长度{@link CHAR_LEN},字符长度{@link BYTE_LEN}
* @return String
*/
public static String truncate(String str, int len, int lenType) {
if (str == null) {
return str;
}
// 字符长度
if (lenType == CHAR_LEN) {
if (str.length() <= len) {
return str;
} else {
return str.substring(0, len);
}
} else // 字节长度
{
StringBuffer sb = new StringBuffer();
int temp = 0;
for (int i = 0; i < str.length(); i++) {
if (i < len) // 是否到指定的长度
{
temp = ("" + str.charAt(i)).getBytes().length;
if (i + temp <= len) {
sb.append(str.charAt(i));
} else {
break;
}
} else {
break;
}
}
return sb.toString();
}
}
/**
* 从源字符串中从第一个字符开始取出给定长度的字串.
* 源字符串长度大于len时,尾巴追加一个appendStr串
*
* @param sourceStr
* String 源字符串
* @param len
* int 取出的长度
* @param appendStr
* String 追加的字符串(常用的appendStr为...)
* @return String 取出的子串
*/
public static String substring(String sourceStr, int len, String appendStr) {
if (null == sourceStr || "".equals(sourceStr)) {
return sourceStr;
}
if (len <= 0) {
return "";
}
String newappendStr = appendStr;
if (null == newappendStr) {
newappendStr = "";
}
int sourceLen = sourceStr.length();
if (len >= sourceLen) {
return sourceStr;
} else {
return sourceStr.substring(0, len) + newappendStr;
}
}
/**
* 产生指定长度随机字符串(包括字母及数字).
*
* @param length
* int 随机字符串长度
* @return String 随机字符串
*/
public static String random(int length) {
String retu = "";
int d1;
int d2;
char[] letters = initLetters();
//int[] numbers = initNumbers();
for (int i = 0; i < length; i++) {
// d1 = ((int) (Math.random() * 10) % 2);
d1 = (int) (Math.random() * 10) % 2;
if (d1 == 0) { // use a letter
// d2 = ((int) (Math.random() * 100) % 52);
d2 = (int) (Math.random() * 100) % 52;
retu += letters[d2];
} else if (d1 == 1) { // use a number
retu += (int) (Math.random() * 10);
}
}
return retu;
}
/**
* 产生纯字母的随机字符串
*
* @param length
* int 随机字符串长度
* @return String 随机字符串
*/
public static String randomString(int length) {
String retu = "";
int d2;
char[] letters = initLetters();
for (int i = 0; i < length; i++) {
// d2 = ((int) (Math.random() * 100) % 52);
d2 = (int) (Math.random() * 100) % 52;
retu += letters[d2];
}
return retu;
}
/**
* 产生纯数字随机字符串
*
* @param length
* int 随机字符串长度
* @return String 随机字符串
*/
public static String randomNumber(int length) {
String retu = "";
//int[] numbers = initNumbers();
for (int i = 0; i < length; i++) {
retu += (int) (Math.random() * 10);
}
return retu;
}
/**
* 内部方法,产生字母数组
*
* @return char[]
*/
private static char[] initLetters() {
char[] ca = new char[52];
for (int i = 0; i < 26; i++) {
ca[i] = (char) (65 + i);
}
for (int i = 26; i < 52; i++) {
ca[i] = (char) (71 + i);
}
return ca;
}
/**
* 内部方法,产生数字数组
*
* @return int[]
*/
/*private static int[] initNumbers() {
int[] na = new int[10];
for (int i = 0; i < 10; i++) {
na[i] = i;
}
return na;
}*/
/**
* 对字符串进行加减密处理.
*
* @param source
* String 待加减密处理的字符串
* @param flag
* boolean true表进行加密,false表进行减密
* @return String 处理后的字符串.
* source为空则返回原字符串source,
* 如果source中含有中文字符则对这一中文字符不处理.
*/
public static String encrypt(String source, boolean flag) {
if (null == source || "".equals(source.trim())) {
return source;
}
String lsKEY1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz~!@#$%^&*(),.;[]{}";
String lsKEY2 = "&*()AD;[BFLCGH]{PQ}EI!JKRYZ1MSTXNO23UV,.Wcd45ef6lm7g@h0a#$nij8ob%^ptvz9ku~qrswxy";
char[] chSource = source.toCharArray();
StringBuffer strBuf = new StringBuffer(chSource.length);
int pos;
int len = chSource.length;
for (int i = 0; i < len; i++) {
if (flag) { // 加密
pos = lsKEY1.indexOf(chSource[i]);
if (pos >= 0) {
strBuf.append(lsKEY2.substring(pos, pos + 1));
} else {
strBuf.append(chSource[i]);
}
} else { // 减密
pos = lsKEY2.indexOf(chSource[i]);
if (pos >= 0) {
strBuf.append(lsKEY1.substring(pos, pos + 1));
} else {
strBuf.append(chSource[i]);
}
}
}
return strBuf.toString();
}
/**
* 将null字符串转换为空串,方便HTML的显示
*
* @param sourceStr
* 待处理的字符串
* @return String 处理的的字符串
*/
public static String toVisualString(String sourceStr) {
if (sourceStr == null || sourceStr.equals("")) {
return "";
} else {
return sourceStr;
}
}
/**
* 将字段填充到指定的长度
*
* @param sourceStr
* String 操作字符串
* @param length
* int 指定长度
* @param withChar
* char 填充的字符
* @param isPadToEnd
* boolean 是否填充在字符的尾部 true :是 ,false:填充在头部
* @return String
*/
public static String pad(String sourceStr, int length, char withChar, boolean isPadToEnd) {
if (sourceStr == null) {
return null;
}
if (sourceStr.length() >= length) {
return sourceStr;
}
StringBuffer sb = new StringBuffer(sourceStr);
for (int i = 0; i < length - sourceStr.length(); i++) {
if (isPadToEnd) {
sb.append(withChar);
} else {
sb.insert(0, withChar);
}
}
return sb.toString();
}
/**
* 首字母大写
* @return
*/
public static String capToUpper(String str){
if (str == null) {
return null;
}
if(str.length()<0){
return "";
}
return str.substring(0,1).toUpperCase()+str.substring(1);
}
/**
* main
*
* @param args
* String[]
* @author:Administrator
*/
/**
* 将身份证号码转换为18位
*
* @param xIdCode
* String
* @return String
*/
public static String idTo18(String xIdCode) {
return IdentificationNumberUtils.id15ToId18(xIdCode);
}
/**
* 将身份证号转换为15位
*
* @param xIdCode
* String
* @return String
*/
public static String idTo15(String xIdCode) {
return IdentificationNumberUtils.id18ToId15(xIdCode);
}
/**
* getIdCheckBit
*
* @param xId
* id
* @return String
* @author:Administrator
*/
private static String getIdCheckBit(String xId) {
return IdentificationNumberUtils.getIdCheckBit(xId);
}
/**
* MD5加密算法
*
* @更新时间:Apr 22, 2008
* @更新作者:Ryan Wong
* @param s
* String
* @return String
*/
public static String md5(String s) {
char[] hexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
try {
byte[] strTemp = s.getBytes();
MessageDigest mdTemp = MessageDigest.getInstance("MD5");
mdTemp.update(strTemp);
byte[] md = mdTemp.digest();
int j = md.length;
char[] str = new char[j * 2];
int k = 0;
for (int i = 0; i < j; i++) {
byte byte0 = md[i];
str[k++] = hexDigits[byte0 >>> 4 & 0xf];
str[k++] = hexDigits[byte0 & 0xf];
}
return new String(str);
} catch (Exception e) {
return null;
}
}
/**
* 取得字符串中间的几位
*
* @更新时间:Apr 22, 2008
* @更新作者:Ryan Wong
* @param strsource
* str_source
* @param midlength
* midlength
* @return String
*/
public static String getMidString(String strsource, int midlength) {
String strMid = "";
int length = strsource.length();
if (midlength > length) {
return null;
}
if (length % 2 == 0) {
if (midlength % 2 != 0) {
return null;
}
strMid = strsource.substring(length / 2 - midlength / 2, length / 2 + midlength / 2);
} else {
if (midlength % 2 == 0) {
return null;
}
strMid = strsource.substring((length - 1) / 2 - (midlength - 1) / 2, (length - 1) / 2
+ (midlength - 1) / 2 + 1);
}
return strMid;
}
public static boolean isNotBlank(String value){
return (value!=null) && !value.equals("");
}
public static boolean isBlank(String value){
return (value==null) || value.equals("");
}
/**
* getStringToInt
* @param value String
* @param defaultInt int
* @return int
* @author:Administrator
*/
public static int getStringToInt(String value, int defaultInt) {
int i = defaultInt;
if (isNotBlank(value) ) {
Integer intObject = getStringByInt(value);
if(intObject!=null){
return intObject.intValue();
}
}
return i;
}
/**
* 字符串替换
* @param value String
* @param replaceChar String
* @return String
* @author:Administrator
*/
public static String replaceStr(String value, String replaceChar) {
String returnValue = "";
if (isNotBlank(value)) {
returnValue = value.replaceAll("[" + replaceChar + "]", "");
}
return returnValue;
}
/**
* getNullByString
* @param value String
* @return String
* @author:Administrator
*/
public static String getNullByString(String value) {
String values = "";
if (isNotBlank(value)) {
values = value.trim();
}
return values;
}
/**
* getNullByString
* @param value String
* @param defaultValue String
* @return String
* @author:Administrator
*/
public static String getNullByString(String value, String defaultValue) {
String values = "";
if (isNotBlank(value)) {
values = value;
} else {
values = defaultValue;
}
return values;
}
/**
* getStringByInt
* @param value String
* @return Integer
* @author:Administrator
*/
public static Integer getStringByInt(String value) {
Integer intValue = null;
if (isNotBlank(value) ) {
try{
intValue = Integer.valueOf(value);
} catch(NumberFormatException ex){
}
}
return intValue;
}
/**
* getStringByMaxLen
* @param value String
* @param maxLen int
* @return String
* @author:Administrator
*/
public static String getStringByMaxLen(String value, int maxLen) {
String returnValue = "";
if (isNotBlank(value)) {
returnValue = value.length() > maxLen ? value.substring(0, maxLen) : value;
}
return returnValue;
}
/**
* getCheckBoxValueByStr
* @param value String
* @return String
* @author:Administrator
*/
public static String getCheckBoxValueByStr(String value) {
String returnValue = "";
if (isNotBlank(value)) {
if (value.equals("on")) {
returnValue = "1";
} else {
returnValue = "0";
}
}
return returnValue;
}
/**
* 删除字符两端的空字符串
*
* @author cailj
* @param str
* @return
*/
public static String trim(String str) {
return str != null ? str.trim() : null;
}
/**
* 进行字符规格化(全角转半角,大写转小写处理)
* @param input
* @return char
*/
public static char[] regularize(char[] input){
for(int i = 0; i < input.length; i ++){
input[i] = regularize(input[i]);
}
return input;
}
/**
* 进行字符规格化(全角转半角,大写转小写处理)
* @param input
* @return char
*/
public static char regularize(char input){
if (input == 12288) {
input = (char) 32;
}else if (input > 65280 && input < 65375) {
input = (char) (input - 65248);
}else if (input >= 'A' && input <= 'Z') {
input |= 32;
}
return input;
}
/**
* 进行字符规格化(全角转半角,大写转小写处理)
* @param input
* @return char
*/
public static String regularize(String input){
if(StringUtils.isBlank(input)) return "";
char[] inputChars = input.toCharArray();
for(int i = 0; i < inputChars.length; i ++){
inputChars[i] = regularize(inputChars[i]);
}
return new String(inputChars);
}
/**
* 字符反转
* eg: reverse(abc) = cba
* @param str
* @return
*/
public static String reverse(String str) {
char[] chrs = str.toCharArray();
int n = chrs.length - 1;
for (int j = (n-1) >> 1; j >= 0; --j) {
char temp = chrs[j];
char temp2 = chrs[n - j];
chrs[j] = temp2;
chrs[n - j] = temp;
}
return new String(chrs, 0, chrs.length);
}
/**
* 字符串是否是 数字类型
* @param str
* @return
*/
public static boolean isNumber(String str){
if(isInteger(str)||isFloat(str)){
return true;
}else{
return false;
}
}
/**
* 判断字符串是否为浮点型
* @param str
* @return
*/
public static boolean isFloat(String str){
if(StringUtils.isNullBlank(str))return false;
Pattern pattern= Pattern.compile("^[-\\+]?\\d+\\.{0,1}[\\d]+$");
return pattern.matcher(str).matches();
}
/**
* 判断字符串是否是整数
* @param str
* @return
*/
public static boolean isInteger(String str){
if(StringUtils.isNullBlank(str))return false;
Pattern pattern = Pattern.compile("^[-\\+]?[\\d]+$");
return pattern.matcher(str).matches();
}
/**
* 忽略正则关键字
* @param keyword 正在表达式关键字 例如"\t","\d","*"等
* @return 返回正则表达式
*/
public static String ignoreRegexKeyword(String keyword){
return "\\Q"+keyword+"\\E";
}
/**
*
* @param str
* @param character
* @return
*/
public static String removeLastCharacter(String str, String character){
if(str==null||str.length()==0){
return str;
}
int en=-1;
if((en=str.lastIndexOf(character))>=0&&(en+character.length()==str.length())){
return str.substring(0,en);
}else{
return str;
}
}
public static String ignoreKeyword(String txt){
if(txt==null){
return null;
}
String str=ignoreKeyword(txt,"n");
str=ignoreKeyword(str,"t");
return str;
}
public static String ignoreKeyword(Object object){
return ignoreKeyword(String.valueOf(object));
}
public static String ignoreKeyword(String txt, String keyWord){
if(txt==null){
return null;
}
if(txt.length()==0||isBlank(keyWord)){
return txt;
}
return txt.replaceAll("\\"+keyWord,"\\\\"+keyWord);
}
/**
* 下划线转驼峰法
* @param line 源字符串
* @param smallCamel 大小驼峰,是否为小驼峰
* @return 转换后的字符串
*/
public static String underline2Camel(String line, boolean smallCamel){
if(line==null||"".equals(line)){
return "";
}
StringBuffer sb=new StringBuffer();
Pattern pattern= Pattern.compile("([A-Za-z\\d]+)(_)?");
Matcher matcher=pattern.matcher(line);
while(matcher.find()){
String word=matcher.group();
sb.append(smallCamel&&matcher.start()==0? Character.toLowerCase(word.charAt(0)): Character.toUpperCase(word.charAt(0)));
int index=word.lastIndexOf('_');
if(index>0){
sb.append(word.substring(1, index).toLowerCase());
}else{
sb.append(word.substring(1).toLowerCase());
}
}
return sb.toString();
}
/**
* 驼峰法转下划线
* @param line 源字符串
* @return 转换后的字符串
*/
public static String camel2Underline(String line){
if(line==null||"".equals(line)){
return "";
}
line= String.valueOf(line.charAt(0)).toUpperCase().concat(line.substring(1));
StringBuffer sb=new StringBuffer();
Pattern pattern= Pattern.compile("[A-Z]([a-z\\d]+)?");
Matcher matcher=pattern.matcher(line);
while(matcher.find()){
String word=matcher.group();
sb.append(word.toUpperCase());
sb.append(matcher.end()==line.length()?"":"_");
}
return sb.toString();
}
//IOS端version比较大小 param1>param2 返回 1 =返回0 <返回-1
public static int compareVersion(String versionClient,String versionServe){
//版本长度
String[] cArr = versionClient.split("\\.");
String[] sArr = versionServe.split("\\.");
int diff = cArr.length-sArr.length;
int result = 0;
//补齐长度
if(diff>0){
sArr = align(sArr,cArr,diff);
}else{
cArr = align(cArr,sArr,-diff);
}
for(int i=0;i0){
param2 = align(param2,param1,diff2);
}else{
param1 = align(param1,param2,-diff2);
}
int param11 = Integer.parseInt(StringUtils.arrayToString(param1,""));
int param22 = Integer.parseInt(StringUtils.arrayToString(param2,""));
if(param11>param22){
result = 1;
break;
}else if(param11