///
// 字符串处理方法大全
// Created on 2010-8-19
// author xuzhijing
///
package com.xuzhijing.common.util;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Iterator;
import java.util.StringTokenizer;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.StringUtils;
import com.xuzhijing.common.exception.EncodingException;
import com.xuzhijing.common.exception.IllegalArgumentOfException;
///
// 字符串处理方法大全
// 主要方法包括:
// <ul>
// <li>unicodeToGB -由"GBK"码转换为"ISO8859_1"码
// <li>GBToUnicode -由"ISO8859_1"码转换为"GBK"码
// <li>replace - 在字符串中进行查找替换,给出替换后的字符串(update)
// <li>split - 使用给定的分隔符拆分字符串成字符串数组(new);
// <li>join - 组合数据结构中所有元素成一个字符串(new);
// <li>repeat - 重复多次组合成新的字符串(new);
// <li>is... - 检查字符串中包含的字符的类型(new);
// <li>defaultString - 返回默认的字符串,将null变为空白字符(new);
// <li>htmlEncode - 在字符串中替换html标记所用的六个特殊字符:& \ " ' < >
// <li>return2Br - 将字符串中的换行符"\n"转换为html换行标记"<br>"
// <li>blank2NBSP - 将字符串中的空格" "转换为html的空格标记"&nbsp;"
// <li>urlEncodeNPath - 能解决一些路径中的文件名包含中文的问题
// <li>cutShort - 使用省略号(...)将过长的字符串截短
// <li>htmlCutShort - 使用省略号(...)将过长的字符串截短并转码html中的特殊字符
// <li>escapeHtml - 使用HTML entities中出现的字符,将字符串中的需要转换的字符全部逃逸
// <li>Html - escapeHtml的反操作
// <li>escapeXml - 使用XML entities中出现四个常用的字符,将字符串中的需要转换的字符全部逃逸
// <li>Xml - escapeXml的反操作
// <li>toToken - 除去字符串中的所有逗号分割符
// <li>toToken - 除去字符串中的所有指定的分割符
// <li>leftTrim - 将字符串左边的所有空格去掉。
// <li>rightTrim - 将字符串右边的所有空格去掉。
// <li>leftTrim - 将字符串左边的所有空格去掉。
// <li>reverseString - 反转字符串。
// </ul>
///
public class StringUtil {
public StringUtil() {}
/
// 转换中文字符集,由"GBK"码转换为"ISO8859_1"码。
//
// param sSource 需要转换的字符串。
// return 返回转换后的字符串。
///
public static String unicodeToGB(String sSource) throws EncodingException {
try {
String S_Desc = "";
if (sSource != null && !sSource.trim().equals("")) {
byte b_Proc [] = sSource.getBytes("GBK");
S_Desc = new String(b_Proc, "ISO8859_1");
}
return S_Desc;
}catch(UnsupportedEncodingException e) {
EncodingException encode = new EncodingException(e.getMessage());
encode.setMessageCode("resource_StringUtil_002");
encode.setExtandMessage("GBK");
throw encode;
}
}
/
// 转换中文字符集,由"ISO8859_1"码转换为"GBK"码。
//
// param sSource 需要转换的字符串。
// return 返回转换后的字符串。
///
public static String GBToUnicode(String sSource) throws EncodingException {
try {
String S_Desc = "";
if (sSource != null && !sSource.trim().equals("")) {
byte b_Proc [] = sSource.getBytes("ISO8859_1");
S_Desc = new String(b_Proc, "GBK");
}
return S_Desc;
}catch(UnsupportedEncodingException e) {
EncodingException encode = new EncodingException(e.getMessage());
encode.setMessageCode("resource_StringUtil_002");
encode.setExtandMessage("GBK");
throw encode;
}
}
/
// 在字符串中进行查找替换,给出替换后的字符串.
//
// 如果是null 传入将返回不替换而返回原字符串.
// 例子:
// <pre>
// StringUtil.replace(null, //, //) = null
// StringUtil.replace("", //, //) = ""
// StringUtil.replace("aba", null, null) = "aba"
// StringUtil.replace("aba", null, null) = "aba"
// StringUtil.replace("aba", "a", null) = "aba"
// StringUtil.replace("aba", "a", "") = "aba"
// StringUtil.replace("aba", "a", "z") = "zbz"
// </pre>
//
// param text text to search and replace in, may be null
// param repl the String to search for, may be null
// param with the String to replace with, may be null
// return the text with any replacements processed,
// <code>null</code> if null String input
///
public static String replace(String text, String repl, String with) {
return StringUtils.replace(text,repl,with);
}
/
// 在字符串中替换html标记所用的六个特殊字符:& \ " ' < >
//
// param sSource 要替换的字符串。
// return 返回替换后的字符串。
///
public static String htmlEncode(String sSource) {
String sTemp = sSource;
sTemp = replace(sTemp, "&", "&");
sTemp = replace(sTemp, """, """);
sTemp = replace(sTemp, "'", "'");
sTemp = replace(sTemp, "<", "<");
sTemp = replace(sTemp, ">", ">");
return sTemp;
}
/
// 将字符串中的换行符"\n"转换为html换行标记"<br>"
//
// param sSource 要替换的字符串。
// return 返回替换后的字符串。
///
public static String return2Br(String sSource) {
return replace(sSource, "\n", "<br>");
}
/
// 将字符串中的空格" "转换为html的空格标记"&nbsp;"
//
// param sSource 要替换的字符串。
// return 返回替换后的字符串。
///
public static String blank2NBSP(String sSource) {
return replace(sSource, " ", " ");
}
/
// 使用给定的分隔符将传入的字符串分割成字符串数组.
//
// 分隔符不包括在返回的字符串数组中.相邻的分隔符作为一个分隔符处理
//
// A <code>null</code> input String returns <code>null</code>.
// 例子:
// <pre>
// StringUtil.split(null, //) = null
// StringUtil.split("", //) = []
// StringUtil.split("a.b.c", '.') = ["a", "b", "c"]
// StringUtil.split("a..b.c", '.') = ["a", "b", "c"]
// StringUtil.split("a:b:c", '.') = ["a:b:c"]
// StringUtil.split("a\tb\nc", null) = ["a", "b", "c"]
// StringUtil.split("a b c", ' ') = ["a", "b", "c"]
// </pre>
//
// param str the String to parse, may be null
// param separatorChar the character used as the delimiter,
// <code>null</code> splits on whitespace
// return an array of parsed Strings, <code>null</code> if null String input
///
public static String[] split(String str, char separatorChar) {
return StringUtils.split(str,separatorChar);
}
/
// 使用给定的分隔符将传入的字符串分割成字符串数组.
// 分隔符不包括在返回的字符串数组中.相邻的分隔符作为一个分隔符处理
//
// <p>A <code>null</code> input String returns <code>null</code>.
// A <code>null</code> separatorChars splits on whitespace.</p>
// 例子:
// <pre>
// StringUtil.split(null, //) = null
// StringUtil.split("", //) = []
// StringUtil.split("abc def", null) = ["abc", "def"]
// StringUtil.split("abc def", " ") = ["abc", "def"]
// StringUtil.split("abc def", " ") = ["abc", "def"]
// StringUtil.split("ab:cd:ef", ":") = ["ab", "cd", "ef"]
// </pre>
//
// param str the String to parse, may be null
// param separatorChars the characters used as the delimiters,
// <code>null</code> splits on whitespace
// return an array of parsed Strings, <code>null</code> if null String input
///
public static String[] split(String str, String separatorChars) {
return StringUtils.split(str, separatorChars);
}
/
// 把一个传入的字符串重复 <code>repeat</code> 次,然后组成一个新的字符串.
// 例子:
// <pre>
// StringUtil.repeat(null, 2) = null
// StringUtil.repeat("", 0) = ""
// StringUtil.repeat("", 2) = ""
// StringUtil.repeat("a", 3) = "aaa"
// StringUtil.repeat("ab", 2) = "abab"
// StringUtil.repeat("a", -2) = ""
// </pre>
//
// param str the String to repeat, may be null
// param repeat number of times to repeat str, negative treated as zero
// return a new String consisting of the original String repeated,
// <code>null</code> if null String input
///
public static String repeat(String str, int repeat) {
return StringUtils.repeat(str,repeat);
}
/
// <p>将提供的数组中的元素组合成一个字符串.</p>
//
// <p>No separator is added to the joined String.
// Null objects or empty strings within the array are represented by
// empty strings.</p>
// 例子:
// <pre>
// StringUtil.join(null) = null
// StringUtil.join([]) = ""
// StringUtil.join([null]) = ""
// StringUtil.join(["a", "b", "c"]) = "abc"
// StringUtil.join([null, "", "a"]) = "a"
// </pre>
//
// param array the array of values to join together, may be null
// return the joined String, <code>null</code> if null array input
///
public static String join(Object[] array) {
return StringUtils.join(array);
}
/
// <p>将提供的数组中的元素组合成一个字符串.</p>
//
// <p>No delimiter is added before or after the list.
// Null objects or empty strings within the array are represented by
// empty strings.</p>
// 例子:
// <pre>
// StringUtil.join(null, //) = null
// StringUtil.join([], //) = ""
// StringUtil.join([null], //) = ""
// StringUtil.join(["a", "b", "c"], ';') = "a;b;c"
// StringUtil.join(["a", "b", "c"], null) = "abc"
// StringUtil.join([null, "", "a"], ';') = ";;a"
// </pre>
//
// param array the array of values to join together, may be null
// param separator the separator character to use
// return the joined String, <code>null</code> if null array input
///
public static String join(Object[] array, char separator) {
return StringUtils.join(array,separator);
}
/
// <p>将提供的数组中的元素组合成一个字符串.</p>
//
// <p>No delimiter is added before or after the list.
// A <code>null</code> separator is the same as an empty String ("").
// Null objects or empty strings within the array are represented by
// empty strings.</p>
// 例子:
// <pre>
// StringUtil.join(null, //) = null
// StringUtil.join([], //) = ""
// StringUtil.join([null], //) = ""
// StringUtil.join(["a", "b", "c"], "--") = "a--b--c"
// StringUtil.join(["a", "b", "c"], null) = "abc"
// StringUtil.join(["a", "b", "c"], "") = "abc"
// StringUtil.join([null, "", "a"], ',') = ",,a"
// </pre>
//
// param array the array of values to join together, may be null
// param separator the separator character to use, null treated as ""
// return the joined String, <code>null</code> if null array input
///
public static String join(Object[] array, String separator) {
return StringUtils.join(array,separator);
}
/
// <p>将提供的 <code>Iterator</code>中的元素组合成一个字符串.</p>
//
// <p>No delimiter is added before or after the list. Null objects or empty
// strings within the iteration are represented by empty strings.</p>
//
// <p>See the examples here: {link #join(Object[],char)}. </p>
//
// param iterator the <code>Iterator</code> of values to join together, may be null
// param separator the separator character to use
// return the joined String, <code>null</code> if null iterator input
///
public static String join(Iterator<String> iterator, char separator) {
return StringUtils.join(iterator,separator);
}
/
// <p>将提供的 <code>Iterator</code>中的元素组合成一个字符串.</p>
//
// <p>No delimiter is added before or after the list.
// A <code>null</code> separator is the same as an empty String ("").</p>
//
// <p>See the examples here: {link #join(Object[],String)}. </p>
//
// param iterator the <code>Iterator</code> of values to join together, may be null
// param separator the separator character to use, null treated as ""
// return the joined String, <code>null</code> if null iterator input
///
public static String join(Iterator<String> iterator, String separator) {
return StringUtils.join(iterator,separator);
}
/
// <p>检查是否字符串仅包含字母.</p>
//
// <p><code>null</code> will return <code>false</code>.
// An empty String ("") will return <code>true</code>.</p>
// 例子:
// <pre>
// StringUtil.isAlpha(null) = false
// StringUtil.isAlpha("") = true
// StringUtil.isAlpha(" ") = false
// StringUtil.isAlpha("abc") = true
// StringUtil.isAlpha("ab2c") = false
// StringUtil.isAlpha("ab-c") = false
// </pre>
//
// param str the String to check, may be null
// return <code>true</code> if only contains letters, and is non-null
///
public static boolean isAlpha(String str) {
return StringUtils.isAlpha(str);
}
/
// <p>检查是否字符串仅包含字母或数字.</p>
//
// <p><code>null</code> will return <code>false</code>.
// An empty String ("") will return <code>true</code>.</p>
// 例子:
// <pre>
// StringUtil.isAlphanumeric(null) = false
// StringUtil.isAlphanumeric("") = true
// StringUtil.isAlphanumeric(" ") = false
// StringUtil.isAlphanumeric("abc") = true
// StringUtil.isAlphanumeric("ab c") = false
// StringUtil.isAlphanumeric("ab2c") = true
// StringUtil.isAlphanumeric("ab-c") = false
// </pre>
//
// param str the String to check, may be null
// return <code>true</code> if only contains letters or digits,
// and is non-null
///
public static boolean isAlphanumeric(String str) {
return StringUtils.isAlphanumeric(str);
}
/
// <p>检查是否字符串仅包含数字,浮点数不是一个数字,所以返回false.</p>
//
// <p><code>null</code> will return <code>false</code>.
// An empty String ("") will return <code>true</code>.</p>
// 例子:
// <pre>
// StringUtil.isNumeric(null) = false
// StringUtil.isNumeric("") = true
// StringUtil.isNumeric(" ") = false
// StringUtil.isNumeric("123") = true
// StringUtil.isNumeric("12 3") = false
// StringUtil.isNumeric("ab2c") = false
// StringUtil.isNumeric("12-3") = false
// StringUtil.isNumeric("12.3") = false
// </pre>
//
// param str the String to check, may be null
// return <code>true</code> if only contains digits, and is non-null
///
public static boolean isNumeric(String str) {
return StringUtils.isNumeric(str);
}
/
// <p>检查是否字符串仅包含空白.</p>
//
// <p><code>null</code> will return <code>false</code>.
// An empty String ("") will return <code>true</code>.</p>
// 例子:
// <pre>
// StringUtil.isWhitespace(null) = false
// StringUtil.isWhitespace("") = true
// StringUtil.isWhitespace(" ") = true
// StringUtil.isWhitespace("abc") = false
// StringUtil.isWhitespace("ab2c") = false
// StringUtil.isWhitespace("ab-c") = false
// </pre>
//
// param str the String to check, may be null
// return <code>true</code> if only contains whitespace, and is non-null
///
public static boolean isWhitespace(String str) {
return StringUtils.isWhitespace(str);
}
/
// <p>返回原字符串,当传入的字符串是<code>null</code>时, 返回空字符串("").</p>
// 例子:
// <pre>
// StringUtil.defaultString(null) = ""
// StringUtil.defaultString("") = ""
// StringUtil.defaultString("bat") = "bat"
// </pre>
//
// param str the String to check, may be null
// return the passed in String, or the empty String if it
// was <code>null</code>
///
public static String defaultString(String str) {
return StringUtils.defaultString(str);
}
/
// <p>返回原字符串,当传入的字符串是<code>null</code>或者为空字符串时, 返回输入的默认值.</p>
// 例子:
// <pre>
// StringUtil.defaultString(null, "null") = "null"
// StringUtil.defaultString("", "null") = "null"
// StringUtil.defaultString("bat", "null") = "bat"
// </pre>
//
// param str the String to check, may be null
// param defaultStr the default String to return
// if the input is <code>null</code>, may be null
// return the passed in String, or the default if it was <code>null</code> or empty string.
///
public static String defaultString(String str, String defaultStr) {
if(str==null || str.equals("")){
return defaultStr;
}else {
return str;
}
}
/
//将路径中的文件名单独取出并用URLEncode编码然后组成新的路径,能解决一些路径中的文件名包含中文的问题
//
//param path 路径字符串
//return 返回编码后的路径字符串,如果参数为空或者长度为0返回0长度字符串
///
public static String urlEncodeNPath(String path) {
String fileName = "", prefix = "", suffix = "";
if (path == null || path.trim().length() == 0)
return "";
int intDot = path.lastIndexOf(".");
int intSlash = path.lastIndexOf("/");
//取最靠后的正斜杠或者反斜杠
intSlash = (intSlash >= path.lastIndexOf("\")) ? intSlash : path.lastIndexOf("\");
if (intSlash == -1)
intSlash = 0;
else
intSlash = intSlash + 1;
if (intDot > intSlash)
suffix = path.substring(intDot, path.length());
//CisConstants.printMsg("suffix: " + suffix);
prefix = path.substring(0, intSlash);
//CisConstants.printMsg("prefix: " + prefix);
if (intDot > intSlash)
fileName = path.substring(intSlash, intDot);
else
fileName = path.substring(intSlash, path.length());
//CisConstants.printMsg("filename: " + fileName);
String temp="";
try {
temp=prefix + URLEncoder.encode(fileName,"GBK") + suffix;
} catch (Exception e) {}
return temp;
}
/
// 使用省略号(...)将过长的字符串截短。
//
// 使用注意:
// 如果str的长度短于maxWidth个字符个数,返回str本身.
// 如果str的长度长于maxWidth个字符个数,将被截短到(substring(str, 0, max-3) + "...")
// 如果maxWidth小于4, 异常IllegalArgumentException将会抛出.
// 返回的字符串的长度永远不会长于maxWidth
//
// <pre>
// StringUtil.cutShort(null, //) = null
// StringUtil.cutShort("", 4) = ""
// StringUtil.cutShort("abcdefg", 6) = "abc..."
// StringUtil.cutShort("abcdefg", 7) = "abcdefg"
// StringUtil.cutShort("abcdefg", 8) = "abcdefg"
// StringUtil.cutShort("abcdefg", 4) = "a..."
// StringUtil.cutShort("abcdefg", 3) = IllegalArgumentException
// </pre>
//
// param str 要被截短的字符串,可以为 null
// param maxWidth 截短后字符串的最大长度, 但必须大于等于 4
// return 截短后的字符串, 如果传入null字符串则返回<code>null</code>
// throws IllegalArgumentException 如果长度小于 4
///
public static String cutShort(String str, int maxWidth)throws IllegalArgumentOfException {
try{
return StringUtils.abbreviate(str, 0, maxWidth);
}catch(IllegalArgumentException e) {
IllegalArgumentOfException ille = new IllegalArgumentOfException(e.getMessage());
ille.setMessageCode("resource_StringUtil_001");
throw ille;
}
}
/
// 使用省略号(...)将过长的字符串截短并转码html中的特殊字符
// param str 要被截短的字符串,可以为 null
// param maxWidth 截短后字符串的最大长度, 但必须大于等于 4
// return 截短后并转码了html中的特殊字符的字符串, 如果传入null字符串则返回<code>null</code>
// throws IllegalArgumentException 如果长度小于 4
///
public static String htmlCutShort(String str, int maxWidth)throws IllegalArgumentOfException{
try {
return htmlEncode(cutShort(str, maxWidth));
}catch(IllegalArgumentException e) {
IllegalArgumentOfException ille = new IllegalArgumentOfException(e.getMessage());
ille.setMessageCode("resource_StringUtil_001");
throw ille;
}
}
/
// 使用HTML entities中出现的字符,将字符串中的需要转换的字符全部逃逸.
// 例如: <tt>"bread" & "butter"</tt> => <tt>&quot;bread&quot; &amp; &quot;butter&quot;</tt>.
//
// <p>支持所有的已知的 HTML 4.0 entities.</p>
//
// param str 需要进行HTML逃逸字符出来的字符串,可能为 null
// return 返回已经进行逃逸处理后的字符串, 如果输入参数为null字符串则返回null
//
// see #Html(String)
// see </br><a href="http://hotwired.lycos.com/webmonkey/reference/special_characters/">ISO Entities</a>
// see </br><a href="http://www.w3.org/TR/REC-html32#latin1">HTML 3.2 Character Entities for ISO Latin-1</a>
// see </br><a href="http://www.w3.org/TR/REC-html40/sgml/entities.html">HTML 4.0 Character entity references</a>
// see </br><a href="http://www.w3.org/TR/html401/charset.html#h-5.3">HTML 4.01 Character References</a>
// see </br><a href="http://www.w3.org/TR/html401/charset.html#code-position">HTML 4.01 Code positions</a>
/
public static String escapeHtml(String str) {
return StringEscapeUtils.escapeHtml(str);
}
/
// 反逃逸操作(解码).
//例如, 字符串 "&lt;Fran&ccedil;ais&gt;"
// 操作后将返回 "<Français>"
//如果entity不被识别,将逐字返回到结果字符串. 例:"&gt;&zzzz;x" 将变为
// ">&zzzz;x".
//
// param str 将被反逃逸的字符串, 可能为 null
// return 返回已经进行反逃逸处理后的字符串, 如果输入参数为null字符串则返回null
// see #escapeHtml(String)
/
public static String Html(String str) {
return StringEscapeUtils.Html(str);
}
/
// 使用XML entities中出现四个常用的字符,将字符串中的需要转换的字符全部逃逸.
//
// <p>例如: <tt>"bread" & "butter"</tt> =>
// <tt>&quot;bread&quot; &amp; &quot;butter&quot;</tt>.
// </p>
//
// <p>仅支持逃逸这四个基本的 XML entities (gt, lt, quot, amp).
// 不支持 DTDs 或扩展的实体(entities).</p>
//
// param str 需要进行逃逸操作的字符串, 可能为 null
// return 返回已经进行逃逸处理后的字符串, 如果输入参数为null字符串则返回null
// see #Xml(java.lang.String)
/
public static String escapeXml(String str) {
return StringEscapeUtils.escapeXml(str);
}
/
// 将字符串中包含 XML entity 的部分转换成实际的相应的Unicode字符.
// 仅支持逃逸这四个基本的 XML entities (gt, lt, quot, amp).
// 不支持 DTDs 或 扩展的实体(entities).
//
// param str 需要进行反逃逸操作的字符串, 可能为 null
// return 返回已经进行反逃逸处理后的字符串, 如果输入参数为null字符串则返回null
// see #escapeXml(String)
/
public static String Xml(String str) {
return StringEscapeUtils.Xml(str);
}
/
// 把字符串中html标记所用的六个特殊字符替换回正常字符:&quot;(") &#039;(')
// &lt;(<) &gt;(>) &amp;(&) 。
//
// param sSource 要替换的字符串。
// return 返回替换后的字符串。
///
public static String htmlDecode(String sSource) {
String sTemp = sSource;
sTemp = replace(sTemp, """, """);
sTemp = replace(sTemp, "'", "'");
sTemp = replace(sTemp, "<", "<");
sTemp = replace(sTemp, ">", ">");
sTemp = replace(sTemp, "&", "&");
return sTemp;
}
/
// 除去字符串中的所有逗号分割符(,)
//
// param s 需要处理的字符串
// return 不含有逗号的字符串
///
public static String toToken(String s) {
if (s==null || s.trim().equals(""))
return s;
String newStr = new String("");
StringTokenizer st = new StringTokenizer(s, ",");
while (st.hasMoreTokens()) {
newStr = newStr + st.nextToken();
}
return newStr;
}
/
// 除去字符串中的所有指定的分割符
//
// param s 需要处理的字符串
// return 不含有逗号的字符串
///
public static String toToken(String s,String val) {
if (s==null || s.trim().equals(""))
return s;
if (val==null || val.equals(""))
return s;
String newStr = new String("");
StringTokenizer st = new StringTokenizer(s, val);
while (st.hasMoreTokens()) {
newStr = newStr + st.nextToken();
}
return newStr;
}
/
// 将字符串左边的所有空格去掉。
//
// param str:将要被处理的字符串
// return 左边没有空格的字符串
///
public static String leftTrim(String str){
if (str==null || str.equals("")) return str;
StringBuilder sbf = new StringBuilder(str);
while (sbf.charAt(0)==' ') {
sbf = sbf.deleteCharAt(0);
}
return sbf.toString();
}
/
// 将字符串右边的所有空格去掉。
// param str:将要被处理的字符串
// return 右边没有空格的字符串
///
public static String rightTrim(String str){
if (str==null || str.equals("")) return str;
StringBuilder sbf = new StringBuilder(str);
while (sbf.charAt(sbf.length()-1)==' ') {
sbf = sbf.deleteCharAt(sbf.length()-1);
}
return sbf.toString();
}
/
// 将字符串反转。
// param str: 将要反转的字符串。
// return 返回经过反转处理的字符串。
///
public static String reverseString(String str){
if (str==null || str.equals("")) return str;
StringBuilder sbf = new StringBuilder(str);
return sbf.reverse().toString();
}
/
// -----------------------------------
// author 胡勇
// -----------------------------------
// 判断字符参数是否为空值
///
public static boolean isNullValue(String value) {
return value == null || value.trim().equals("");
}
/
// 解决split方法无法截取的字符串
// author 马明铭
// param str 需要截取的字符串
// param val 按某个字符截取
// return 返回截取后的长度
///
public static int getLength(String str,String val){
int length = 0;
StringTokenizer st = new StringTokenizer(str,val);
length = st.countTokens();
return length;
}
/
// description 解决split方法无法截取的字符串
// author 马明铭
// param str 需要截取的字符串
// param val 按某个字符截取
// return 返回截取后的字符串数组
///
public static String[] getString(String str,String val){
StringTokenizer st = new StringTokenizer(str,val);
String[] arrayContent = new String[st.countTokens()];
int i = 0;
while(st.hasMoreTokens()){
arrayContent[i] = st.nextToken();
i++;
}
return arrayContent;
}
/
// author 张涛
// param o
// return str
// 功能 把传进的字符串进行替换。其中 '' 替换成 ‘’ "" 替换成 “” < 替换成 < > 替换成 >
///
public static String adjustString(Object o) {
String str = "";
if (o != null)
str = o.toString();
else
return str;
boolean singleTag = false;
boolean doubleTag = false;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (c == '\'') {
if (!singleTag)
c = '‘';
else
c = '’';
singleTag = !singleTag;
sb.append(c);
continue;
}
if (c == '"') {
if (!doubleTag)
c = '“';
else
c = '”';
doubleTag = !doubleTag;
sb.append(c);
continue;
}
if (c == '<') {
sb.append("<");
continue;
}
if (c == '>') {
sb.append(">");
continue;
}
sb.append(c);
}
str = sb.toString();
return str;
}
/
// 计算字符串长度,,半角字符两个算一个汉字
// param text 要计算的字符串
// return 长度
///
public static int getStringLength(String text){
int count = 0;
int length = 0;
if(text != null && text.length() > 0){
char[] str = text.toCharArray();
for(int i = 0; i < str.length; i++){
if(32 < str[i] && str[i] < 127){
count++;
}
}
if(count % 2 == 0){
length = text.length() - count + count / 2;
}else
length = text.length() - count + count / 2 + 1;
}
return length;
}
/
// 截取字符串方法,半角字符两个算一个汉字
// param text 要截取的字符串
// param length 要截取的长度
// return 截取后的字符串,后面加三个点
///
public static String cutString(String text,int length){
int templngth = 0;
int i = 0;
int count = 0;
if(length != 0 && text != null && text.length() > length){
char[] str = text.toCharArray();
for( ; i <= str.length; i++){
boolean flag = false;
if(32 < str[i] && str[i] < 127){
flag = true;
count++;
if(count % 2 == 1)
templngth++;
}else
templngth++;
if(templngth == length){
if(flag && i < str.length -1){
if(32 < str[i + 1] && str[i + 1] < 127){
i += 1;
}
}
break;
}
}
text = text.substring(0,++i) + "...";
}
return text;
}
/
// 将\n转换为'< b r >',字符串未空时返回 ;
// param text
// return
///
public final static String convert2Br(String text){
return "".equals(text) ? " " : StringUtil.return2Br(text);
}
/
// 比较两个版本字符串的大小,格式为:主版本号.次版本号.编译版本号
// 有可能不包括编译版本号
// param bigstr
// param smallstr
// return
///
public final static boolean compare(String bigstr,String smallstr){
/
// 检查是否包含编译版本号,如果没有默认补0
///
if(bigstr.indexOf(".") == bigstr.lastIndexOf("."))
bigstr = bigstr.concat(".0");
if(smallstr.indexOf(".") == smallstr.lastIndexOf("."))
smallstr = smallstr.concat(".0");
/
// 第一步比较(主版本.次版本),转化为float
// 第二步比较编译版本,转化为int
///
float serverVersion = Float.valueOf(bigstr.substring(0,bigstr.lastIndexOf(".")));
float clientVersion = Float.valueOf(smallstr.substring(0,smallstr.lastIndexOf(".")));
if(serverVersion > clientVersion){//需要更新
return true;
}else if(serverVersion == clientVersion){//如果主版本.次版本相同,则比较编译版本号
if(Integer.parseInt(bigstr.substring(bigstr.lastIndexOf(".") + 1)) > Integer.parseInt(smallstr.substring(smallstr.lastIndexOf(".") + 1))){
return true;
}
}
return false;
}
/
// 逗号分隔符
///
public final static String SPLIT_COMMA = ",";
//
// 将数组转化为字符串,使用逗号分隔符连接
// param array
// return
///
public final static String toString(int[] array){
return toString(array,SPLIT_COMMA);
}
/
// 将数组转化为字符串,使用指定分隔符连接
// param array
// param splitStr
// return
///
public final static String toString(int[] array,String splitStr){
if(array == null || array.length == 0)
return "";
int length = array.length;
StringBuilder sb = new StringBuilder();
for(int i = 0; i < length; i++){
if(i < length -1)
sb.append(array[i]).append(splitStr);
else
sb.append(array[i]);
}
return sb.toString();
}
public static void main(String[] args){
System.out.println(StringUtil.compare("2.0.5", "2.1"));
}
}