字符串处理集锦

在我参与的项目里面，我总喜欢把对一些细节处理的代码放在叫utils的根包下面，碰到要用的时候就直接调用，节省了好多开发的时间。这些年来，我从网络收集和自己编码的有很多，有些我都不知道放在电脑什么位置了，把有些拿出来做个网络笔记免得以后什么都没有了，我这个人比较邋遢了，唉！

private static char[] ch = 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i','j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v','w', 'x', 'y', 'z' }; 
public static String RandStrings(int len) { 
  Random r = new Random(); 
  String tmp = ""; 
  for (int i = 0; i < len; i++) { 
     int d = r.nextInt(ch.length); 
     tmp = tmp + ch[d]; 
  } 
     return tmp; 
} 

         /** 
          * 
* 获取当前时间 
* 
* @param male 
* @return 
*/ 
public static Date getCurrentDateForDate() throws Exception { 
   SimpleDateFormat sf = new SimpleDateFormat("yyyy-mm-dd HH:ss:mm"); 
   Date date = sf.parse(Utils.getCurrentDate()); 
   return date; 
} 


/** 
* 把第一次出现html的字符串之前的字符串清除掉 
* 
* @param sourceString 
*            源字符串 
* @return 清除后的字符串 
*/ 
public static String SpecialString(String sourceString) { 
String w3chtml = ""; 
if (sourceString == null){ 
return w3chtml; 
}else{ 
int firstIndex = sourceString.indexOf("<html"); 
//System.out.println(firstIndex); 
if(firstIndex>=0){ 
w3chtml = sourceString.substring(firstIndex); 
} 
} 
return w3chtml; 
} 

/** 
* 获取此URL的协议名称 
* 
* @param sourceString 
*            源字符串 
* @return 处理后的字符串 
*/ 
public static String getProtocol(String url) { 
String result = ""; 
if (url == null){ 
return result; 
}else{ 
try{ 
URL myURL=new URL(url); 
result = myURL.getProtocol(); 
}catch (MalformedURLException e){ 
e.printStackTrace(); 
} 
} 
return result; 
} 

/** 
* 从访问的URL中获取网站的域名 
* 
* @param sourceString 
*            源字符串 
* @return 处理后的字符串 
*/ 
public static String getDomain(String sourceString) { 
String result = ""; 
if (sourceString == null){ 
return result; 
}else{ 
String[] domains = sourceString.split("/"); 
result = domains[0] + "//" + domains[1] + domains[2]; 
} 
return result; 
} 

/** 
* 从访问的URL中获取该URL的根目录 
* 
* @param sourceString 
*            源字符串 
* @return 处理后的字符串 
*/ 
public static String getLastPath(String sourceString) { 
String result = ""; 
String[] domains; 
if (sourceString == null){ 
return result; 
}else{ 
domains = sourceString.split("/"); 
result = domains[0]+"//"+domains[1]+domains[2]; 
} 
for(int i = 3;i < domains.length-1;i++){ 
result +="/" + domains[i]; 
} 
return result; 
} 

public static String getTruePath(String sourceString,int n) { 
String result = ""; 
String[] domains; 
if (sourceString == null){ 
return result; 
}else{ 
domains = sourceString.split("/"); 
result = domains[0]+"//"+domains[1]+domains[2]; 
} 
for(int i = 3;i < domains.length-1-n;i++){ 
result +="/" + domains[i]; 
} 
return result; 
} 

public static String getAppath(String sourceString) { 
String result = ""; 
String[] domains; 
if (sourceString == null){ 
return result; 
} 
domains = sourceString.split("[..]{2}+[^.]"); 
int i = domains.length; 
result = domains[i-1]; 

return result; 
} 

/** 
* 判断字符串是否以字母和数字开始 
* 
* @param sourceString 
*            源字符串 
* @return 处理后的结果 
*/ 
public static Boolean isLetterOrNumberStart(String sourceString) { 
Boolean result = false; 
String regex = "^[a-zA-Z_0-9]"; 
Pattern p = Pattern.compile(regex); 
Matcher m = p.matcher(sourceString); 
if (m.find()){ 
result = true; 
}else{ 
result = false; 
} 
return result; 
} 

/** 
* 判断字符串是否以一个"/"开始且紧跟后面一个不能也为"/" 
* 
* @param sourceString 
*            源字符串 
* @return 处理后的结果 
*/ 
public static Boolean isSlashStart(String sourceString) { 
Boolean result = false; 
String regex = "^[/]{1}+[^/]"; 
Pattern p = Pattern.compile(regex); 
Matcher m = p.matcher(sourceString); 
if (m.find()){ 
result = true; 
}else{ 
result = false; 
} 
return result; 
} 

/** 
* 判断字符串"js"结尾 
* 
* @param sourceString 
*            源字符串 
* @return 处理后的结果 
*/ 
public static Boolean isJsFile(String sourceString) { 
Boolean result = false; 
int len = sourceString.length(); 
if ("js".equals(sourceString.substring(len-2, len))){ 
result = true; 
}else{ 
result = false; 
} 
return result; 
} 

public static int DoubleDotNum(String url){ 
int num = 0; 
String[] ads=url.split("[..]{2}+[^.]"); 
int len = ads.length; 
if(len>0) num=len-1; 
return num; 
} 



/** 
* 把空值转换为空字符串 
* 
* @param srcString 
*            源字符串 
* @return 非null字符串 
*/ 
public static String nullToString(String srcString) { 
if (srcString == null) 
return new String(""); 
else 
return srcString; 
} 

/** 
* @param value 
* @param len 
* @return String 
*/ 
public static String limitString(String value){ 
if (value == null) value = ""; 
String v1 = ""; 
int l = value.length(); 
if (l > 6){ 
v1 = value.substring(0, 5) + "***"; 
if (l > 9) v1 += value.substring(9); 
} 
else{ 
v1 = value; 
} 
return v1; 
} 

/** 
* 将UNICODE转化为utf-8编码(&#xxxx) 
* 
* @param srcString 
*            源字符串 
* 
* @return String UTF8标记字符串 
*/ 
public static String toUTF8(String srcString) { 
char temChr; 
int ascChr; 
String rtStr = new String(""); 
if (srcString == null) 
srcString = ""; 
for (int i = 0; i < srcString.length(); i++) { 
temChr = srcString.charAt(i); 
ascChr = temChr + 0; 
rtStr += "&#x" + Integer.toHexString(ascChr) + ";"; 
} 
return rtStr; 
} 

/** 
* 把空值替换为指定字符串 
* 
* @param srcString 
*            源字符串 
* @param toString 
*            用于替换的字符串 
* @return 非null字符串 
*/ 
public static String nullToString(String srcString, String toString) { 
if (srcString == null) 
return toString; 
else 
return srcString; 
} 

/** 
* 把字符创转换为布尔类型，默认返回defaultValue 
* 
* @param srcString 
*            源字符串("true"/"false") 
* @param defaultValue 
*            默认值 
* @return boolean 是否为真 
*/ 
public static boolean toBoolean(String srcString, boolean defaultValue) { 
if (srcString == null) 
return false; 
if (srcString.trim().toLowerCase().equals("true")) 
return true; 
else 
return false; 
} 

/** 
* 按 fromCharset 编码读取，以 toCharset 编码格式输出字符串 
* 
* @param srcString 
*            源字符串 
* @param fromCharset 
*            读取方式编码(UTF-8/GBK/GB2312) 
* @param toCharset 
*            输出字符编码(UTF-8/GBK/GB2312) 
* @return String Charset指定字符串 
*/ 
public static String toCharset(String srcString, String fromCharset, 
String toCharset) { 
if (srcString == null) return null; 
try { 
return new String(srcString.getBytes(fromCharset), toCharset); 
} catch (Exception e) { 
return null; 
} 
} 

/** 
* 把字符串转换为双精度数，默认返回defaultValue 
* 
* @param srcString 
*            源字符串 
* @param defaultValue 
*            默认数值 
* @return double 双精度数 
*/ 
public static double toDouble(String srcString, double defaultValue) { 
double dReturn = 0.0D; 
if (srcString == null || srcString.trim().length() < 1) return defaultValue; 
try { 
srcString = srcString.trim().replaceAll(",", ""); 
dReturn = Double.valueOf(srcString.trim()).doubleValue(); 
} catch (NumberFormatException e) { 
dReturn = defaultValue; 
} 
return dReturn; 
} 

/** 
* 把字符串转换为浮点数，默认返回defaultValue 
* 
* @param srcString 
*            源字符串 
* @param defaultValue 
*            默认数值 
* @return float 浮点数 
*/ 
public static float toFloat(String srcString, float defaultValue) { 
float fReturn = 0.0F; 
if (srcString == null || srcString.trim().length() < 1) return defaultValue; 
try { 
srcString = srcString.trim().replaceAll(",", ""); 
Double Dv = new Double(Double.valueOf(srcString).doubleValue()); 
fReturn = Dv.floatValue(); 
} catch (NumberFormatException e) { 
fReturn = defaultValue; 
} 
return fReturn; 
} 

/** 
* 把字符串转换为整数，默认返回defaultValue 
* 
* @param srcString 
*            源字符串 
* @param defaultValue 
*            默认数值 
* @return int 取得的数值 
*/ 
public static int toInt(String srcString, int defaultValue) { 
int iReturn = 0; 
if (srcString == null || srcString.trim().length() < 1) return defaultValue; 
try { 
srcString = srcString.trim().replaceAll(",", ""); 
Double Dv = new Double(Double.valueOf(srcString).doubleValue()); 
iReturn = Dv.intValue(); 
} catch (NumberFormatException e) { 
iReturn = defaultValue; 
} 
return iReturn; 
} 

/** 
* 把字符串转换为整数（四舍五入），默认返回defaultValue 
* 
* @param srcString 
*            源字符串 
* @param defaultValue 
*            默认数值 
* @return int 取得的数值 
*/ 
public static int toIntRound(String srcString, int defaultValue) { 
int iReturn = 0; 
if (srcString == null || srcString.trim().length() < 1) return defaultValue; 
try { 
srcString = srcString.trim().replaceAll(",", ""); 
float fv = Float.valueOf(srcString).floatValue(); 
iReturn = Math.round(fv); 
} catch (NumberFormatException e) { 
iReturn = defaultValue; 
} 
return iReturn; 
} 

/** 
* 把某种编码字符串转换为Unicode字符串 
* 
* @param srcString 
*            源字符串 
* @param fromCharset 
*            读取方式编码(UTF-8/GBK/GB2312) 
* @return String 被格式化的Unicode字符串 
*/ 
public static String toUnicode(String srcString, String fromCharset) { 
return toCharset(srcString, fromCharset, "ISO-8859-1"); 
} 

/** 
* 以默认编码格式对Unicode字符进行转换 
* 
* @param srcString 
*            源字符串 
* @return String 默认字符编码字符串 
*/ 
public static String unicodeToString(String srcString) { 
try { 
return new String(srcString.getBytes("ISO-8859-1")); 
} catch (Exception e) { 
return null; 
} 
} 

/** 
* 按 Unicode 编码读取，以 toCharset 编码格式输出字符串 
* 
* @param srcString 
*            源字符串 
* @param toCharset 
*            输出字符编码(UTF-8/GBK/GB2312) 
* @return String Charset指定字符串 
*/ 
public static String unicodeToString(String srcString, String toCharset) { 
return toCharset(srcString, "ISO-8859-1", toCharset); 
} 

/** 
* 字符处理类 
*/ 
public StringUtil() { 

} 

 

复制到编辑器里面的，懒得整理格式了，我这个人比较懒惰，没有办法，所有现在水平还是那么的烂，呵呵！找到这个文章的你们觉得有用，就挑上看得上的用吧，我是无私地贡献一下代码而已。