简单、优雅、有序才是真的美 -- 王昕
废话不多说，直接上代码。
验证类Validator
主要是空验证、数字、格式验证
调用的例子：
protected void validateEmailFrom(ActionRequest actionRequest){
String emailFromName = getParameter(actionRequest, "emailFromName");
String emailFromAddress = getParameter(
actionRequest, "emailFromAddress");
if (Validator.isNull(emailFromName)) {
SessionErrors.add(actionRequest, "emailFromName");
}
else if (!Validator.isEmailAddress(emailFromAddress) &&
!Validator.isVariableTerm(emailFromAddress)) {
SessionErrors.add(actionRequest, "emailFromAddress");
}
}
数组工具类，ArrayUtil
主要的操作是：
源代码实现分析1、去除重复值，如
public static String[] distinct(String[] array) {
return distinct(array, null);
}
public static String[] distinct(
String[] array, Comparator<String> comparator) {
if ((array == null) || (array.length == 0)) {
return array;
}
Set<String> set = null;
if (comparator == null) {
set = new TreeSet<String>();
}
else {
set = new TreeSet<String>(comparator);
}
for (int i = 0; i < array.length; i++) {
String s = array[i];
if (!set.contains(s)) {
set.add(s);
}
}
return set.toArray(new String[set.size()]);
}
源代码实现分析2、尾部增加项，比如：
public static Float[] append(Float[] array, Float obj) {
Float[] newArray = new Float[array.length + 1];
System.arraycopy(array, 0, newArray, 0, array.length);
newArray[newArray.length - 1] = obj;
return newArray;
}
3、JSONArray、Object和Array转换，如：
static String[] toStringArray(JSONArray array) static String[] toStringArray(Object[] array)
字符串工具StringUtil
一个例子，用于字符替换，同时也使用了StringPool
protected Map<String, String> getJSONValues(
JSONArray data, String namespace, String id) {
Map<String, String> values = new HashMap<String, String>(data.length());
for (int i = 0; i < data.length(); i++) {
JSONObject jsonObject = data.getJSONObject(i);
String name = jsonObject.getString("name");
name = StringUtil.replace(
name, new String[] {namespace, id},
new String[] {StringPool.BLANK, StringPool.BLANK});
values.put(name, jsonObject.getString("value"));
}
return values;
}
StringUtil源代码，有兴趣可以研究
package com.liferay.portal.kernel.util;
import com.liferay.portal.kernel.log.Log;
import com.liferay.portal.kernel.log.LogFactoryUtil;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
public class StringUtil {
public static String add(String s, String add) {
return add(s, add, StringPool.COMMA);
}
public static String add(String s, String add, String delimiter) {
return add(s, add, delimiter, false);
}
public static String add(
String s, String add, String delimiter, boolean allowDuplicates) {
if ((add == null) || (delimiter == null)) {
return null;
}
if (s == null) {
s = StringPool.BLANK;
}
if (allowDuplicates || !contains(s, add, delimiter)) {
StringBuilder sb = new StringBuilder();
sb.append(s);
if (Validator.isNull(s) || s.endsWith(delimiter)) {
sb.append(add);
sb.append(delimiter);
}
else {
sb.append(delimiter);
sb.append(add);
sb.append(delimiter);
}
s = sb.toString();
}
return s;
}
public static String bytesToHexString(byte[] bytes) {
StringBuilder sb = new StringBuilder(bytes.length * 2);
for (int i = 0; i < bytes.length; i++) {
String hex = Integer.toHexString(
0x0100 + (bytes[i] & 0x00FF)).substring(1);
if (hex.length() < 2) {
sb.append("0");
}
sb.append(hex);
}
return sb.toString();
}
public static boolean contains(String s, String text) {
return contains(s, text, StringPool.COMMA);
}
public static boolean contains(String s, String text, String delimiter) {
if ((s == null) || (text == null) || (delimiter == null)) {
return false;
}
StringBuilder sb = null;
if (!s.endsWith(delimiter)) {
sb = new StringBuilder();
sb.append(s);
sb.append(delimiter);
s = sb.toString();
}
sb = new StringBuilder();
sb.append(delimiter);
sb.append(text);
sb.append(delimiter);
String dtd = sb.toString();
int pos = s.indexOf(dtd);
if (pos == -1) {
sb = new StringBuilder();
sb.append(text);
sb.append(delimiter);
String td = sb.toString();
if (s.startsWith(td)) {
return true;
}
return false;
}
return true;
}
public static int count(String s, String text) {
if ((s == null) || (text == null)) {
return 0;
}
int count = 0;
int pos = s.indexOf(text);
while (pos != -1) {
pos = s.indexOf(text, pos + text.length());
count++;
}
return count;
}
public static boolean endsWith(String s, char end) {
return endsWith(s, (new Character(end)).toString());
}
public static boolean endsWith(String s, String end) {
if ((s == null) || (end == null)) {
return false;
}
if (end.length() > s.length()) {
return false;
}
String temp = s.substring(s.length() - end.length(), s.length());
if (temp.equalsIgnoreCase(end)) {
return true;
}
else {
return false;
}
}
public static String extractChars(String s) {
if (s == null) {
return StringPool.BLANK;
}
StringBuilder sb = new StringBuilder();
char[] c = s.toCharArray();
for (int i = 0; i < c.length; i++) {
if (Validator.isChar(c[i])) {
sb.append(c[i]);
}
}
return sb.toString();
}
public static String extractDigits(String s) {
if (s == null) {
return StringPool.BLANK;
}
StringBuilder sb = new StringBuilder();
char[] c = s.toCharArray();
for (int i = 0; i < c.length; i++) {
if (Validator.isDigit(c[i])) {
sb.append(c[i]);
}
}
return sb.toString();
}
public static String extractFirst(String s, String delimiter) {
if (s == null) {
return null;
}
else {
String[] array = split(s, delimiter);
if (array.length > 0) {
return array[0];
}
else {
return null;
}
}
}
public static String extractLast(String s, String delimiter) {
if (s == null) {
return null;
}
else {
String[] array = split(s, delimiter);
if (array.length > 0) {
return array[array.length - 1];
}
else {
return null;
}
}
}
public static String highlight(String s, String keywords) {
return highlight(s, keywords, "<span class=\"highlight\">", "</span>");
}
public static String highlight(
String s, String keywords, String highlight1, String highlight2) {
if (s == null) {
return null;
}
// The problem with using a regexp is that it searches the text in a
// case insenstive manner but doens‘t replace the text in a case
// insenstive manner. So the search results actually get messed up. The
// best way is to actually parse the results.
//return s.replaceAll(
// "(?i)" + keywords, highlight1 + keywords + highlight2);
StringBuilder sb = new StringBuilder(StringPool.SPACE);
StringTokenizer st = new StringTokenizer(s);
while (st.hasMoreTokens()) {
String token = st.nextToken();
if (token.equalsIgnoreCase(keywords)) {
sb.append(highlight1);
sb.append(token);
sb.append(highlight2);
}
else {
sb.append(token);
}
if (st.hasMoreTokens()) {
sb.append(StringPool.SPACE);
}
}
return sb.toString();
}
public static String lowerCase(String s) {
if (s == null) {
return null;
}
else {
return s.toLowerCase();
}
}
public static String merge(boolean[] array) {
return merge(array, StringPool.COMMA);
}
public static String merge(boolean[] array, String delimiter) {
if (array == null) {
return null;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < array.length; i++) {
sb.append(String.valueOf(array[i]).trim());
if ((i + 1) != array.length) {
sb.append(delimiter);
}
}
return sb.toString();
}
public static String merge(double[] array) {
return merge(array, StringPool.COMMA);
}
public static String merge(double[] array, String delimiter) {
if (array == null) {
return null;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < array.length; i++) {
sb.append(String.valueOf(array[i]).trim());
if ((i + 1) != array.length) {
sb.append(delimiter);
}
}
return sb.toString();
}
public static String merge(float[] array) {
return merge(array, StringPool.COMMA);
}
public static String merge(float[] array, String delimiter) {
if (array == null) {
return null;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < array.length; i++) {
sb.append(String.valueOf(array[i]).trim());
if ((i + 1) != array.length) {
sb.append(delimiter);
}
}
return sb.toString();
}
public static String merge(int[] array) {
return merge(array, StringPool.COMMA);
}
public static String merge(int[] array, String delimiter) {
if (array == null) {
return null;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < array.length; i++) {
sb.append(String.valueOf(array[i]).trim());
if ((i + 1) != array.length) {
sb.append(delimiter);
}
}
return sb.toString();
}
public static String merge(long[] array) {
return merge(array, StringPool.COMMA);
}
public static String merge(long[] array, String delimiter) {
if (array == null) {
return null;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < array.length; i++) {
sb.append(String.valueOf(array[i]).trim());
if ((i + 1) != array.length) {
sb.append(delimiter);
}
}
return sb.toString();
}
public static String merge(short[] array) {
return merge(array, StringPool.COMMA);
}
public static String merge(short[] array, String delimiter) {
if (array == null) {
return null;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < array.length; i++) {
sb.append(String.valueOf(array[i]).trim());
if ((i + 1) != array.length) {
sb.append(delimiter);
}
}
return sb.toString();
}
public static String merge(Collection<?> col) {
return merge(col, StringPool.COMMA);
}
public static String merge(Collection<?> col, String delimiter) {
return merge(col.toArray(new Object[col.size()]), delimiter);
}
public static String merge(Object[] array) {
return merge(array, StringPool.COMMA);
}
public static String merge(Object[] array, String delimiter) {
if (array == null) {
return null;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < array.length; i++) {
sb.append(String.valueOf(array[i]).trim());
if ((i + 1) != array.length) {
sb.append(delimiter);
}
}
return sb.toString();
}
public static String randomize(String s) {
return Randomizer.getInstance().randomize(s);
}
public static String read(ClassLoader classLoader, String name)
throws IOException {
return read(classLoader, name, false);
}
public static String read(ClassLoader classLoader, String name, boolean all)
throws IOException {
if (all) {
StringBuilder sb = new StringBuilder();
Enumeration<URL> enu = classLoader.getResources(name);
while (enu.hasMoreElements()) {
URL url = enu.nextElement();
InputStream is = url.openStream();
String s = read(is);
if (s != null) {
sb.append(s);
sb.append(StringPool.NEW_LINE);
}
is.close();
}
return sb.toString().trim();
}
else {
InputStream is = classLoader.getResourceAsStream(name);
String s = read(is);
is.close();
return s;
}
}
public static String read(InputStream is) throws IOException {
StringBuilder sb = new StringBuilder();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String line = null;
while ((line = br.readLine()) != null) {
sb.append(line).append(‘\n‘);
}
br.close();
return sb.toString().trim();
}
public static String remove(String s, String remove) {
return remove(s, remove, StringPool.COMMA);
}
public static String remove(String s, String remove, String delimiter) {
if ((s == null) || (remove == null) || (delimiter == null)) {
return null;
}
if (Validator.isNotNull(s) && !s.endsWith(delimiter)) {
s += delimiter;
}
StringBuilder sb = new StringBuilder();
sb.append(delimiter);
sb.append(remove);
sb.append(delimiter);
String drd = sb.toString();
sb = new StringBuilder();
sb.append(remove);
sb.append(delimiter);
String rd = sb.toString();
while (contains(s, remove, delimiter)) {
int pos = s.indexOf(drd);
if (pos == -1) {
if (s.startsWith(rd)) {
int x = remove.length() + delimiter.length();
int y = s.length();
s = s.substring(x, y);
}
}
else {
int x = pos + remove.length() + delimiter.length();
int y = s.length();
sb = new StringBuilder();
sb.append(s.substring(0, pos));
sb.append(s.substring(x, y));
s = sb.toString();
}
}
return s;
}
public static String replace(String s, char oldSub, char newSub) {
if (s == null) {
return null;
}
return s.replace(oldSub, newSub);
}
public static String replace(String s, char oldSub, String newSub) {
if ((s == null) || (newSub == null)) {
return null;
}
// The number 5 is arbitrary and is used as extra padding to reduce
// buffer expansion
StringBuilder sb = new StringBuilder(s.length() + 5 * newSub.length());
char[] charArray = s.toCharArray();
for (char c : charArray) {
if (c == oldSub) {
sb.append(newSub);
}
else {
sb.append(c);
}
}
return sb.toString();
}
public static String replace(String s, String oldSub, String newSub) {
if ((s == null) || (oldSub == null) || (newSub == null)) {
return null;
}
int y = s.indexOf(oldSub);
if (y >= 0) {
// The number 5 is arbitrary and is used as extra padding to reduce
// buffer expansion
StringBuilder sb = new StringBuilder(
s.length() + 5 * newSub.length());
int length = oldSub.length();
int x = 0;
while (x <= y) {
sb.append(s.substring(x, y));
sb.append(newSub);
x = y + length;
y = s.indexOf(oldSub, x);
}
sb.append(s.substring(x));
return sb.toString();
}
else {
return s;
}
}
public static String replace(String s, String[] oldSubs, String[] newSubs) {
if ((s == null) || (oldSubs == null) || (newSubs == null)) {
return null;
}
if (oldSubs.length != newSubs.length) {
return s;
}
for (int i = 0; i < oldSubs.length; i++) {
s = replace(s, oldSubs[i], newSubs[i]);
}
return s;
}
public static String replace(
String s, String[] oldSubs, String[] newSubs, boolean exactMatch) {
if ((s == null) || (oldSubs == null) || (newSubs == null)) {
return null;
}
if (oldSubs.length != newSubs.length) {
return s;
}
if (!exactMatch) {
replace(s, oldSubs, newSubs);
}
else {
for (int i = 0; i < oldSubs.length; i++) {
s = s.replaceAll("\\b" + oldSubs[i] + "\\b" , newSubs[i]);
}
}
return s;
}
/**
* Returns a string with replaced values. This method will replace all text
* in the given string, between the beginning and ending delimiter, with new
* values found in the given map. For example, if the string contained the
* text <code>[$HELLO$]</code>, and the beginning delimiter was
* <code>[$]</code>, and the ending delimiter was <code>$]</code>, and the
* values map had a key of <code>HELLO</code> that mapped to
* <code>WORLD</code>, then the replaced string will contain the text
* <code>[$WORLD$]</code>.
*
* @param s the original string
* @param begin the beginning delimiter
* @param end the ending delimiter
* @param values a map of old and new values
* @return a string with replaced values
*/
public static String replaceValues(
String s, String begin, String end, Map<String, String> values) {
if ((s == null) || (begin == null) || (end == null) ||
(values == null) || (values.size() == 0)) {
return s;
}
StringBuilder sb = new StringBuilder(s.length());
int pos = 0;
while (true) {
int x = s.indexOf(begin, pos);
int y = s.indexOf(end, x + begin.length());
if ((x == -1) || (y == -1)) {
sb.append(s.substring(pos, s.length()));
break;
}
else {
sb.append(s.substring(pos, x + begin.length()));
String oldValue = s.substring(x + begin.length(), y);
String newValue = values.get(oldValue);
if (newValue == null) {
newValue = oldValue;
}
sb.append(newValue);
pos = y;
}
}
return sb.toString();
}
public static String reverse(String s) {
if (s == null) {
return null;
}
char[] c = s.toCharArray();
char[] reverse = new char[c.length];
for (int i = 0; i < c.length; i++) {
reverse[i] = c[c.length - i - 1];
}
return new String(reverse);
}
public static String safePath(String path) {
return replace(path, StringPool.DOUBLE_SLASH, StringPool.SLASH);
}
public static String shorten(String s) {
return shorten(s, 20);
}
public static String shorten(String s, int length) {
return shorten(s, length, "...");
}
public static String shorten(String s, String suffix) {
return shorten(s, 20, suffix);
}
public static String shorten(String s, int length, String suffix) {
if ((s == null) || (suffix == null)) {
return null;
}
if (s.length() > length) {
for (int j = length; j >= 0; j--) {
if (Character.isWhitespace(s.charAt(j))) {
length = j;
break;
}
}
StringBuilder sb = new StringBuilder();
sb.append(s.substring(0, length));
sb.append(suffix);
s = sb.toString();
}
return s;
}
public static String[] split(String s) {
return split(s, StringPool.COMMA);
}
public static String[] split(String s, String delimiter) {
if (s == null || delimiter == null) {
return new String[0];
}
s = s.trim();
if (!s.endsWith(delimiter)) {
StringBuilder sb = new StringBuilder();
sb.append(s);
sb.append(delimiter);
s = sb.toString();
}
if (s.equals(delimiter)) {
return new String[0];
}
List<String> nodeValues = new ArrayList<String>();
if (delimiter.equals("\n") || delimiter.equals("\r")) {
try {
BufferedReader br = new BufferedReader(new StringReader(s));
String line = null;
while ((line = br.readLine()) != null) {
nodeValues.add(line);
}
br.close();
}
catch (IOException ioe) {
_log.error(ioe.getMessage());
}
}
else {
int offset = 0;
int pos = s.indexOf(delimiter, offset);
while (pos != -1) {
nodeValues.add(new String(s.substring(offset, pos)));
offset = pos + delimiter.length();
pos = s.indexOf(delimiter, offset);
}
}
return nodeValues.toArray(new String[nodeValues.size()]);
}
public static boolean[] split(String s, boolean x) {
return split(s, StringPool.COMMA, x);
}
public static boolean[] split(String s, String delimiter, boolean x) {
String[] array = split(s, delimiter);
boolean[] newArray = new boolean[array.length];
for (int i = 0; i < array.length; i++) {
boolean value = x;
try {
value = Boolean.valueOf(array[i]).booleanValue();
}
catch (Exception e) {
}
newArray[i] = value;
}
return newArray;
}
public static double[] split(String s, double x) {
return split(s, StringPool.COMMA, x);
}
public static double[] split(String s, String delimiter, double x) {
String[] array = split(s, delimiter);
double[] newArray = new double[array.length];
for (int i = 0; i < array.length; i++) {
double value = x;
try {
value = Double.parseDouble(array[i]);
}
catch (Exception e) {
}
newArray[i] = value;
}
return newArray;
}
public static float[] split(String s, float x) {
return split(s, StringPool.COMMA, x);
}
public static float[] split(String s, String delimiter, float x) {
String[] array = split(s, delimiter);
float[] newArray = new float[array.length];
for (int i = 0; i < array.length; i++) {
float value = x;
try {
value = Float.parseFloat(array[i]);
}
catch (Exception e) {
}
newArray[i] = value;
}
return newArray;
}
public static int[] split(String s, int x) {
return split(s, StringPool.COMMA, x);
}
public static int[] split(String s, String delimiter, int x) {
String[] array = split(s, delimiter);
int[] newArray = new int[array.length];
for (int i = 0; i < array.length; i++) {
int value = x;
try {
value = Integer.parseInt(array[i]);
}
catch (Exception e) {
}
newArray[i] = value;
}
return newArray;
}
public static long[] split(String s, long x) {
return split(s, StringPool.COMMA, x);
}
public static long[] split(String s, String delimiter, long x) {
String[] array = split(s, delimiter);
long[] newArray = new long[array.length];
for (int i = 0; i < array.length; i++) {
long value = x;
try {
value = Long.parseLong(array[i]);
}
catch (Exception e) {
}
newArray[i] = value;
}
return newArray;
}
public static short[] split(String s, short x) {
return split(s, StringPool.COMMA, x);
}
public static short[] split(String s, String delimiter, short x) {
String[] array = split(s, delimiter);
short[] newArray = new short[array.length];
for (int i = 0; i < array.length; i++) {
short value = x;
try {
value = Short.parseShort(array[i]);
}
catch (Exception e) {
}
newArray[i] = value;
}
return newArray;
}
public static boolean startsWith(String s, char begin) {
return startsWith(s, (new Character(begin)).toString());
}
public static boolean startsWith(String s, String start) {
if ((s == null) || (start == null)) {
return false;
}
if (start.length() > s.length()) {
return false;
}
String temp = s.substring(0, start.length());
if (temp.equalsIgnoreCase(start)) {
return true;
}
else {
return false;
}
}
/**
* Return the number of starting letters that s1 and s2 have in common
* before they deviate.
*
* @param s1 the first string
* @param s2 the second string
*
* @return the number of starting letters that s1 and s2 have in common
* before they deviate
*/
public static int startsWithWeight(String s1, String s2) {
if ((s1 == null) || (s2 == null)) {
return 0;
}
char[] charArray1 = s1.toCharArray();
char[] charArray2 = s2.toCharArray();
int i = 0;
for (; (i < charArray1.length) && (i < charArray2.length); i++) {
if (charArray1[i] != charArray2[i]) {
break;
}
}
return i;
}
public static String stripBetween(String s, String begin, String end) {
if ((s == null) || (begin == null) || (end == null)) {
return s;
}
StringBuilder sb = new StringBuilder(s.length());
int pos = 0;
while (true) {
int x = s.indexOf(begin, pos);
int y = s.indexOf(end, x + begin.length());
if ((x == -1) || (y == -1)) {
sb.append(s.substring(pos, s.length()));
break;
}
else {
sb.append(s.substring(pos, x));
pos = y + end.length();
}
}
return sb.toString();
}
public static String trim(String s) {
return trim(s, null);
}
public static String trim(String s, char c) {
return trim(s, new char[] {c});
}
public static String trim(String s, char[] exceptions) {
if (s == null) {
return null;
}
char[] charArray = s.toCharArray();
int len = charArray.length;
int x = 0;
int y = charArray.length;
for (int i = 0; i < len; i++) {
char c = charArray[i];
if (_isTrimable(c, exceptions)) {
x = i + 1;
}
else {
break;
}
}
for (int i = len - 1; i >= 0; i--) {
char c = charArray[i];
if (_isTrimable(c, exceptions)) {
y = i;
}
else {
break;
}
}
if ((x != 0) || (y != len)) {
return s.substring(x, y);
}
else {
return s;
}
}
public static String trimLeading(String s) {
return trimLeading(s, null);
}
public static String trimLeading(String s, char c) {
return trimLeading(s, new char[] {c});
}
public static String trimLeading(String s, char[] exceptions) {
if (s == null) {
return null;
}
char[] charArray = s.toCharArray();
int len = charArray.length;
int x = 0;
int y = charArray.length;
for (int i = 0; i < len; i++) {
char c = charArray[i];
if (_isTrimable(c, exceptions)) {
x = i + 1;
}
else {
break;
}
}
if ((x != 0) || (y != len)) {
return s.substring(x, y);
}
else {
return s;
}
}
public static String trimTrailing(String s) {
return trimTrailing(s, null);
}
public static String trimTrailing(String s, char c) {
return trimTrailing(s, new char[] {c});
}
public static String trimTrailing(String s, char[] exceptions) {
if (s == null) {
return null;
}
char[] charArray = s.toCharArray();
int len = charArray.length;
int x = 0;
int y = charArray.length;
for (int i = len - 1; i >= 0; i--) {
char c = charArray[i];
if (_isTrimable(c, exceptions)) {
y = i;
}
else {
break;
}
}
if ((x != 0) || (y != len)) {
return s.substring(x, y);
}
else {
return s;
}
}
public static String upperCase(String s) {
if (s == null) {
return null;
}
else {
return s.toUpperCase();
}
}
public static String upperCaseFirstLetter(String s) {
char[] chars = s.toCharArray();
if ((chars[0] >= 97) && (chars[0] <= 122)) {
chars[0] = (char)(chars[0] - 32);
}
return new String(chars);
}
public static String wrap(String text) {
return wrap(text, 80, StringPool.NEW_LINE);
}
public static String wrap(String text, int width, String lineSeparator) {
if (text == null) {
return null;
}
StringBuilder sb = new StringBuilder();
try {
BufferedReader br = new BufferedReader(new StringReader(text));
String s = StringPool.BLANK;
while ((s = br.readLine()) != null) {
if (s.length() == 0) {
sb.append(lineSeparator);
}
else {
String[] tokens = s.split(StringPool.SPACE);
boolean firstWord = true;
int curLineLength = 0;
for (int i = 0; i < tokens.length; i++) {
if (!firstWord) {
sb.append(StringPool.SPACE);
curLineLength++;
}
if (firstWord) {
sb.append(lineSeparator);
}
sb.append(tokens[i]);
curLineLength += tokens[i].length();
if (curLineLength >= width) {
firstWord = true;
curLineLength = 0;
}
else {
firstWord = false;
}
}
}
}
}
catch (IOException ioe) {
_log.error(ioe.getMessage());
}
return sb.toString();
}
private static boolean _isTrimable(char c, char[] exceptions) {
if ((exceptions != null) && (exceptions.length > 0)) {
for (int i = 0; i < exceptions.length; i++) {
if (c == exceptions[i]) {
return false;
}
}
}
return Character.isWhitespace(c);
}
private static Log _log = LogFactoryUtil.getLog(StringUtil.class);
}
其他工具类
- 集合的泛型帮助类：MapUtil、ListUtil
- Base64的转换：Base64
- http参数帮助，编解码工具：HttpUtil
- 文件操作：FileUtil
- 类型工具：ClassUtil：
- 常用字符串静态类：StringPool
其中StringPool定义了一些final值，可以利用起来：
package com.liferay.portal.kernel.util;
public class StringPool {
public static final String AMPERSAND = "&";
public static final String AMPERSAND_ENCODED = "&";
public static final String APOSTROPHE = "‘";
public static final String AT = "@";
public static final String BACK_SLASH = "\\";
public static final String BETWEEN = "BETWEEN";
public static final String BLANK = "";
public static final String CDATA_OPEN = "<![CDATA[";
public static final String CDATA_CLOSE = "]]>";
public static final String CLOSE_BRACKET = "]";
public static final String CLOSE_CURLY_BRACE = "}";
public static final String CLOSE_PARENTHESIS = ")";
public static final String COLON = ":";
public static final String COMMA = ",";
public static final String COMMA_AND_SPACE = ", ";
public static final String DASH = "-";
public static final String DOUBLE_APOSTROPHE = "‘‘";
public static final String DOUBLE_CLOSE_BRACKET = "]]";
public static final String DOUBLE_OPEN_BRACKET = "[[";
public static final String DOUBLE_SLASH = "//";
public static final String EQUAL = "=";
public static final String GREATER_THAN = ">";
public static final String GREATER_THAN_OR_EQUAL = ">=";
public static final String FALSE = "false";
public static final String FORWARD_SLASH = "/";
public static final String FOUR_SPACES = " ";
public static final String IS_NOT_NULL = "IS NOT NULL";
public static final String IS_NULL = "IS NULL";
public static final String LESS_THAN = "<";
public static final String LESS_THAN_OR_EQUAL = "<=";
public static final String LIKE = "LIKE";
public static final String MINUS = "-";
public static final String NBSP = " ";
public static final String NEW_LINE = "\n";
public static final String NOT_EQUAL = "!=";
public static final String NOT_LIKE = "NOT LIKE";
public static final String NULL = "null";
public static final String OPEN_BRACKET = "[";
public static final String OPEN_CURLY_BRACE = "{";
public static final String OPEN_PARENTHESIS = "(";
public static final String PERCENT = "%";
public static final String PERIOD = ".";
public static final String PIPE = "|";
public static final String PLUS = "+";
public static final String POUND = "#";
public static final String QUESTION = "?";
public static final String QUOTE = "\"";
public static final String RETURN = "\r";
public static final String RETURN_NEW_LINE = "\r\n";
public static final String SEMICOLON = ";";
public static final String SLASH = FORWARD_SLASH;
public static final String SPACE = " ";
public static final String STAR = "*";
public static final String TILDE = "~";
public static final String TRUE = "true";
public static final String UNDERLINE = "_";
public static final String UTF8 = "UTF-8";
}
时间： 2024-11-05 19:02:46