import javax.mail.internet.InternetAddress;
import javax.mail.internet.AddressException;
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.BreakIterator;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
/**
* Utility class to peform common String manipulation algorithms.
*/
public class StringUtils {
// Constants used by escapeHTMLTags
private static final char[] QUOTE_ENCODE = """.toCharArray(); //"
private static final char[] AMP_ENCODE = "&".toCharArray(); //&
private static final char[] LT_ENCODE = "<".toCharArray(); //<
private static final char[] GT_ENCODE = ">".toCharArray(); //>
private StringUtils() {
// Not instantiable.
}
/**
*
* 此方法描述的是: 字符串的替换
* @param string 需要替换的字符串
* @param oldString 被替换的字符串
* @param newString 新字符串
* @version 创建时间:2009-9-13 下午01:34:23
*/
public static String replace(String string, String oldString, String newString) {
if (string == null) {
return null;
}
int i = 0; //初始位置,从0开始
//从指定位置开始查找oldString在string中的起始位置
if ((i = string.indexOf(oldString, i)) >= 0) {
// Use char []'s, as they are more efficient to deal with.
char[] string2 = string.toCharArray();
char[] newString2 = newString.toCharArray();
int oLength = oldString.length();
//StringBuilder 简易替换 比 StringBuffer 要快
StringBuilder buf = new StringBuilder(string2.length);
//string2从起始位置到 i 的部分... 继续追加新串 newString2
buf.append(string2, 0, i).append(newString2);
//string中旧字符串的结束位置
i += oLength;
int j = i;
// Replace all remaining instances of oldString with newString.
//用新串替换所有出现的旧串
while ((i = string.indexOf(oldString, i)) > 0) {
buf.append(string2, j, i - j).append(newString2);
i += oLength;
j = i;
}
//用新串替换后的string2中截获最后一次出现新串的结束位置到结尾
buf.append(string2, j, string2.length - j);
return buf.toString();
}
return string;
}
/**
*
* 此方法描述的是: 字符串的替换 不区分大小写
* @param string 需要替换的字符串
* @param oldString 被替换的字符串
* @param newString 新字符串
* @version 创建时间:2009-9-13 下午01:34:23
*/
public static String replaceIgnoreCase(String line, String oldString, String newString) {
if (line == null) {
return null;
}
String lcLine = line.toLowerCase();
String lcOldString = oldString.toLowerCase();
int i = 0;
if ((i = lcLine.indexOf(lcOldString, i)) >= 0) {
char[] line2 = line.toCharArray();
char[] newString2 = newString.toCharArray();
int oLength = oldString.length();
StringBuilder buf = new StringBuilder(line2.length);
buf.append(line2, 0, i).append(newString2);
i += oLength;
int j = i;
while ((i = lcLine.indexOf(lcOldString, i)) > 0) {
buf.append(line2, j, i - j).append(newString2);
i += oLength;
j = i;
}
buf.append(line2, j, line2.length - j);
return buf.toString();
}
return line;
}
/**
* Replaces all instances of oldString with newString in line with the
* added feature that matches of newString in oldString ignore case.
* The count paramater is set to the number of replaces performed.
*
* @param line the String to search to perform replacements on
* @param oldString the String that should be replaced by newString
* @param newString the String that will replace all instances of oldString
* @param count a value that will be updated with the number of replaces
* performed.
* @return a String will all instances of oldString replaced by newString
*/
public static String replaceIgnoreCase(String line, String oldString, String newString, int[] count){
if (line == null) {
return null;
}
String lcLine = line.toLowerCase();
String lcOldString = oldString.toLowerCase();
int i = 0;
if ((i = lcLine.indexOf(lcOldString, i)) >= 0) {
int counter = 1;
char[] line2 = line.toCharArray();
char[] newString2 = newString.toCharArray();
int oLength = oldString.length();
StringBuilder buf = new StringBuilder(line2.length);
buf.append(line2, 0, i).append(newString2);
i += oLength;
int j = i;
while ((i = lcLine.indexOf(lcOldString, i)) > 0) {
counter++;
buf.append(line2, j, i - j).append(newString2);
i += oLength;
j = i;
}
buf.append(line2, j, line2.length - j);
count[0] = counter;
return buf.toString();
}
return line;
}
/**
* Replaces all instances of oldString with newString in line.
* The count Integer is updated with number of replaces.
*
* @param line the String to search to perform replacements on.
* @param oldString the String that should be replaced by newString.
* @param newString the String that will replace all instances of oldString.
* @return a String will all instances of oldString replaced by newString.
*/
public static String replace(String line, String oldString, String newString, int[] count){
if (line == null) {
return null;
}
int i = 0;
if ((i = line.indexOf(oldString, i)) >= 0) {
int counter = 1;
char[] line2 = line.toCharArray();
char[] newString2 = newString.toCharArray();
int oLength = oldString.length();
StringBuilder buf = new StringBuilder(line2.length);
buf.append(line2, 0, i).append(newString2);
i += oLength;
int j = i;
while ((i = line.indexOf(oldString, i)) > 0) {
counter++;
buf.append(line2, j, i - j).append(newString2);
i += oLength;
j = i;
}
buf.append(line2, j, line2.length - j);
count[0] = counter;
return buf.toString();
}
return line;
}
/**
* This method takes a string and strips out all tags except <br> tags while still leaving
* the tag body intact.
*
* @param in the text to be converted.
* @return the input string with all tags removed.
*/
public static String stripTags(String in) {
if (in == null) {
return null;
}
char ch;
int i = 0;
int last = 0;
char[] input = in.toCharArray();
int len = input.length;
StringBuilder out = new StringBuilder((int)(len * 1.3));
for (; i < len; i++) {
ch = input[i];
if (ch > '>') {
}
else if (ch == '<') {
if (i + 3 < len && input[i + 1] == 'b' && input[i + 2] == 'r' && input[i + 3] == '>') {
i += 3;
continue;
}
if (i > last) {
out.append(input, last, i - last);
}
last = i + 1;
}
else if (ch == '>') {
last = i + 1;
}
}
if (last == 0) {
return in;
}
if (i > last) {
out.append(input, last, i - last);
}
return out.toString();
}
/**
* This method takes a string which may contain HTML tags (ie, <b>,
* <table>, etc) and converts the '<'' and '>' characters to
* their HTML escape sequences. It will also replace LF with <br>.
*
* @param in the text to be converted.
* @return the input string with the characters '<' and '>' replaced
* with their HTML escape sequences.
*/
public static String escapeHTMLTags(String in) {
if (in == null) {
return null;
}
char ch;
int i = 0;
int last = 0;
char[] input = in.toCharArray();
int len = input.length;
StringBuilder out = new StringBuilder((int)(len * 1.3));
for (; i < len; i++) {
ch = input[i];
if (ch > '>') {
}
else if (ch == '<') {
if (i > last) {
out.append(input, last, i - last);
}
last = i + 1;
out.append(LT_ENCODE);
}
else if (ch == '>') {
if (i > last) {
out.append(input, last, i - last);
}
last = i + 1;
out.append(GT_ENCODE);
}
else if (ch == '\n') {
if (i > last) {
out.append(input, last, i - last);
}
last = i + 1;
out.append("<br>");
}
}
if (last == 0) {
return in;
}
if (i > last) {
out.append(input, last, i - last);
}
return out.toString();
}
/**
* Used by the hash method.
*/
private static Map<String, MessageDigest> digests =
new ConcurrentHashMap<String, MessageDigest>();
/**
* Hashes a String using the Md5 algorithm and returns the result as a
* String of hexadecimal numbers. This method is synchronized to avoid
* excessive MessageDigest object creation. If calling this method becomes
* a bottleneck in your code, you may wish to maintain a pool of
* MessageDigest objects instead of using this method.
* <p/>
* A hash is a one-way function -- that is, given an
* input, an output is easily computed. However, given the output, the
* input is almost impossible to compute. This is useful for passwords
* since we can store the hash and a hacker will then have a very hard time
* determining the original password.
* <p/>
* In Jive, every time a user logs in, we simply
* take their plain text password, compute the hash, and compare the
* generated hash to the stored hash. Since it is almost impossible that
* two passwords will generate the same hash, we know if the user gave us
* the correct password or not. The only negative to this system is that
* password recovery is basically impossible. Therefore, a reset password
* method is used instead.
*
* @param data the String to compute the hash of.
* @return a hashed version of the passed-in String
*/
public static String hash(String data) {
return hash(data, "MD5");
}
/**
* Hashes a String using the specified algorithm and returns the result as a
* String of hexadecimal numbers. This method is synchronized to avoid
* excessive MessageDigest object creation. If calling this method becomes
* a bottleneck in your code, you may wish to maintain a pool of
* MessageDigest objects instead of using this method.
* <p/>
* A hash is a one-way function -- that is, given an
* input, an output is easily computed. However, given the output, the
* input is almost impossible to compute. This is useful for passwords
* since we can store the hash and a hacker will then have a very hard time
* determining the original password.
* <p/>
* In Jive, every time a user logs in, we simply
* take their plain text password, compute the hash, and compare the
* generated hash to the stored hash. Since it is almost impossible that
* two passwords will generate the same hash, we know if the user gave us
* the correct password or not. The only negative to this system is that
* password recovery is basically impossible. Therefore, a reset password
* method is used instead.
*
* @param data the String to compute the hash of.
* @param algorithm the name of the algorithm requested.
* @return a hashed version of the passed-in String
*/
public static String hash(String data, String algorithm) {
try {
return hash(data.getBytes("utf-8"), algorithm);
}
catch (UnsupportedEncodingException e) {
Log.error(e);
}
return data;
}
/**
* Hashes a byte array using the specified algorithm and returns the result as a
* String of hexadecimal numbers. This method is synchronized to avoid
* excessive MessageDigest object creation. If calling this method becomes
* a bottleneck in your code, you may wish to maintain a pool of
* MessageDigest objects instead of using this method.
* <p/>
* A hash is a one-way function -- that is, given an
* input, an output is easily computed. However, given the output, the
* input is almost impossible to compute. This is useful for passwords
* since we can store the hash and a hacker will then have a very hard time
* determining the original password.
* <p/>
* In Jive, every time a user logs in, we simply
* take their plain text password, compute the hash, and compare the
* generated hash to the stored hash. Since it is almost impossible that
* two passwords will generate the same hash, we know if the user gave us
* the correct password or not. The only negative to this system is that
* password recovery is basically impossible. Therefore, a reset password
* method is used instead.
*
* @param bytes the byte array to compute the hash of.
* @param algorithm the name of the algorithm requested.
* @return a hashed version of the passed-in String
*/
public static String hash(byte[] bytes, String algorithm) {
synchronized (algorithm.intern()) {
MessageDigest digest = digests.get(algorithm);
if (digest == null) {
try {
digest = MessageDigest.getInstance(algorithm);
digests.put(algorithm, digest);
}
catch (NoSuchAlgorithmException nsae) {
Log.error("Failed to load the " + algorithm + " MessageDigest. " +
"Jive will be unable to function normally.", nsae);
return null;
}
}
// Now, compute hash.
digest.update(bytes);
return encodeHex(digest.digest());
}
}
/**
* Turns an array of bytes into a String representing each byte as an
* unsigned hex number.
* <p/>
* Method by Santeri Paavolainen, Helsinki Finland 1996<br>
* (c) Santeri Paavolainen, Helsinki Finland 1996<br>
* Distributed under LGPL.
*
* @param bytes an array of bytes to convert to a hex-string
* @return generated hex string
*/
public static String encodeHex(byte[] bytes) {
StringBuilder buf = new StringBuilder(bytes.length * 2);
int i;
for (i = 0; i < bytes.length; i++) {
if (((int)bytes[i] & 0xff) < 0x10) {
buf.append("0");
}
buf.append(Long.toString((int)bytes[i] & 0xff, 16));
}
return buf.toString();
}
/**
* Turns a hex encoded string into a byte array. It is specifically meant
* to "reverse" the toHex(byte[]) method.
*
* @param hex a hex encoded String to transform into a byte array.
* @return a byte array representing the hex String[
*/
public static byte[] decodeHex(String hex) {
char[] chars = hex.toCharArray();
byte[] bytes = new byte[chars.length / 2];
int byteCount = 0;
for (int i = 0; i < chars.length; i += 2) {
int newByte = 0x00;
newByte |= hexCharToByte(chars[i]);
newByte <<= 4;
newByte |= hexCharToByte(chars[i + 1]);
bytes[byteCount] = (byte)newByte;
byteCount++;
}
return bytes;
}
/**
* Returns the the byte value of a hexadecmical char (0-f). It's assumed
* that the hexidecimal chars are lower case as appropriate.
*
* @param ch a hexedicmal character (0-f)
* @return the byte value of the character (0x00-0x0F)
*/
private static byte hexCharToByte(char ch) {
switch (ch) {
case '0':
return 0x00;
case '1':
return 0x01;
case '2':
return 0x02;
case '3':
return 0x03;
case '4':
return 0x04;
case '5':
return 0x05;
case '6':
return 0x06;
case '7':
return 0x07;
case '8':
return 0x08;
case '9':
return 0x09;
case 'a':
return 0x0A;
case 'b':
return 0x0B;
case 'c':
return 0x0C;
case 'd':
return 0x0D;
case 'e':
return 0x0E;
case 'f':
return 0x0F;
}
return 0x00;
}
/**
* Encodes a String as a base64 String.
*
* @param data a String to encode.
* @return a base64 encoded String.
*/
public static String encodeBase64(String data) {
byte[] bytes = null;
try {
bytes = data.getBytes("UTF-8");
}
catch (UnsupportedEncodingException uee) {
Log.error(uee);
}
return encodeBase64(bytes);
}
/**
* Encodes a byte array into a base64 String.
*
* @param data a byte array to encode.
* @return a base64 encode String.
*/
public static String encodeBase64(byte[] data) {
// Encode the String. We pass in a flag to specify that line
// breaks not be added. This is consistent with our previous base64
// implementation. Section 2.1 of 3548 (base64 spec) also specifies
// no line breaks by default.
return Base64.encodeBytes(data, Base64.DONT_BREAK_LINES);
}
/**
* Decodes a base64 String.
*
* @param data a base64 encoded String to decode.
* @return the decoded String.
*/
public static byte[] decodeBase64(String data) {
return Base64.decode(data);
}
/**
* Converts a line of text into an array of lower case words using a
* BreakIterator.wordInstance().<p>
*
* This method is under the Jive Open Source Software License and was
* written by Mark Imbriaco.
*
* @param text a String of text to convert into an array of words
* @return text broken up into an array of words.
*/
public static String[] toLowerCaseWordArray(String text) {
if (text == null || text.length() == 0) {
return new String[0];
}
List<String> wordList = new ArrayList<String>();
BreakIterator boundary = BreakIterator.getWordInstance();
boundary.setText(text);
int start = 0;
for (int end = boundary.next(); end != BreakIterator.DONE;
start = end, end = boundary.next()) {
String tmp = text.substring(start, end).trim();
// Remove characters that are not needed.
tmp = replace(tmp, "+", "");
tmp = replace(tmp, "/", "");
tmp = replace(tmp, "\\", "");
tmp = replace(tmp, "#", "");
tmp = replace(tmp, "*", "");
tmp = replace(tmp, ")", "");
tmp = replace(tmp, "(", "");
tmp = replace(tmp, "&", "");
if (tmp.length() > 0) {
wordList.add(tmp);
}
}
return wordList.toArray(new String[wordList.size()]);
}
/**
* Pseudo-random number generator object for use with randomString().
* The Random class is not considered to be cryptographically secure, so
* only use these random Strings for low to medium security applications.
*/
private static Random randGen = new Random();
/**
* Array of numbers and letters of mixed case. Numbers appear in the list
* twice so that there is a more equal chance that a number will be picked.
* We can use the array to get a random number or letter by picking a random
* array index.
*/
private static char[] numbersAndLetters = ("0123456789abcdefghijklmnopqrstuvwxyz" +
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray();
/**
* Returns a random String of numbers and letters (lower and upper case)
* of the specified length. The method uses the Random class that is
* built-in to Java which is suitable for low to medium grade security uses.
* This means that the output is only pseudo random, i.e., each number is
* mathematically generated so is not truly random.<p>
* <p/>
* The specified length must be at least one. If not, the method will return
* null.
*
* @param length the desired length of the random String to return.
* @return a random String of numbers and letters of the specified length.
*/
public static String randomString(int length) {
if (length < 1) {
return null;
}
// Create a char buffer to put random letters and numbers in.
char[] randBuffer = new char[length];
for (int i = 0; i < randBuffer.length; i++) {
randBuffer[i] = numbersAndLetters[randGen.nextInt(71)];
}
return new String(randBuffer);
}
/**
* Intelligently chops a String at a word boundary (whitespace) that occurs
* at the specified index in the argument or before. However, if there is a
* newline character before <code>length</code>, the String will be chopped
* there. If no newline or whitespace is found in <code>string</code> up to
* the index <code>length</code>, the String will chopped at <code>length</code>.
* <p/>
* For example, chopAtWord("This is a nice String", 10) will return
* "This is a" which is the first word boundary less than or equal to 10
* characters into the original String.
*
* @param string the String to chop.
* @param length the index in <code>string</code> to start looking for a
* whitespace boundary at.
* @return a substring of <code>string</code> whose length is less than or
* equal to <code>length</code>, and that is chopped at whitespace.
*/
public static String chopAtWord(String string, int length) {
if (string == null || string.length() == 0) {
return string;
}
char[] charArray = string.toCharArray();
int sLength = string.length();
if (length < sLength) {
sLength = length;
}
// First check if there is a newline character before length; if so,
// chop word there.
for (int i = 0; i < sLength - 1; i++) {
// Windows
if (charArray[i] == '\r' && charArray[i + 1] == '\n') {
return string.substring(0, i + 1);
}
// Unix
else if (charArray[i] == '\n') {
return string.substring(0, i);
}
}
// Also check boundary case of Unix newline
if (charArray[sLength - 1] == '\n') {
return string.substring(0, sLength - 1);
}
// Done checking for newline, now see if the total string is less than
// the specified chop point.
if (string.length() < length) {
return string;
}
// No newline, so chop at the first whitespace.
for (int i = length - 1; i > 0; i--) {
if (charArray[i] == ' ') {
return string.substring(0, i).trim();
}
}
// Did not find word boundary so return original String chopped at
// specified length.
return string.substring(0, length);
}
/**
* Reformats a string where lines that are longer than <tt>width</tt>
* are split apart at the earliest wordbreak or at maxLength, whichever is
* sooner. If the width specified is less than 5 or greater than the input
* Strings length the string will be returned as is.
* <p/>
* Please note that this method can be lossy - trailing spaces on wrapped
* lines may be trimmed.
*
* @param input the String to reformat.
* @param width the maximum length of any one line.
* @return a new String with reformatted as needed.
*/
public static String wordWrap(String input, int width, Locale locale) {
// protect ourselves
if (input == null) {
return "";
}
else if (width < 5) {
return input;
}
else if (width >= input.length()) {
return input;
}
// default locale
if (locale == null) {
locale = JiveGlobals.getLocale();
}
StringBuilder buf = new StringBuilder(input);
boolean endOfLine = false;
int lineStart = 0;
for (int i = 0; i < buf.length(); i++) {
if (buf.charAt(i) == '\n') {
lineStart = i + 1;
endOfLine = true;
}
// handle splitting at width character
if (i > lineStart + width - 1) {
if (!endOfLine) {
int limit = i - lineStart - 1;
BreakIterator breaks = BreakIterator.getLineInstance(locale);
breaks.setText(buf.substring(lineStart, i));
int end = breaks.last();
// if the last character in the search string isn't a space,
// we can't split on it (looks bad). Search for a previous
// break character
if (end == limit + 1) {
if (!Character.isWhitespace(buf.charAt(lineStart + end))) {
end = breaks.preceding(end - 1);
}
}
// if the last character is a space, replace it with a \n
if (end != BreakIterator.DONE && end == limit + 1) {
buf.replace(lineStart + end, lineStart + end + 1, "\n");
lineStart = lineStart + end;
}
// otherwise, just insert a \n
else if (end != BreakIterator.DONE && end != 0) {
buf.insert(lineStart + end, '\n');
lineStart = lineStart + end + 1;
}
else {
buf.insert(i, '\n');
lineStart = i + 1;
}
}
else {
buf.insert(i, '\n');
lineStart = i + 1;
endOfLine = false;
}
}
}
return buf.toString();
}
/**
* Escapes all necessary characters in the String so that it can be used in SQL
*
* @param string the string to escape.
* @return the string with appropriate characters escaped.
*/
public static String escapeForSQL(String string) {
if (string == null) {
return null;
}
else if (string.length() == 0) {
return string;
}
char ch;
char[] input = string.toCharArray();
int i = 0;
int last = 0;
int len = input.length;
StringBuilder out = null;
for (; i < len; i++) {
ch = input[i];
if (ch == '\'') {
if (out == null) {
out = new StringBuilder(len + 2);
}
if (i > last) {
out.append(input, last, i - last);
}
last = i + 1;
out.append('\'').append('\'');
}
}
if (out == null) {
return string;
}
else if (i > last) {
out.append(input, last, i - last);
}
return out.toString();
}
/**
* Escapes all necessary characters in the String so that it can be used
* in an XML doc.
*
* @param string the string to escape.
* @return the string with appropriate characters escaped.
*/
public static String escapeForXML(String string) {
if (string == null) {
return null;
}
char ch;
int i = 0;
int last = 0;
char[] input = string.toCharArray();
int len = input.length;
StringBuilder out = new StringBuilder((int)(len * 1.3));
for (; i < len; i++) {
ch = input[i];
if (ch > '>') {
}
else if (ch == '<') {
if (i > last) {
out.append(input, last, i - last);
}
last = i + 1;
out.append(LT_ENCODE);
}
else if (ch == '&') {
if (i > last) {
out.append(input, last, i - last);
}
last = i + 1;
out.append(AMP_ENCODE);
}
else if (ch == '"') {
if (i > last) {
out.append(input, last, i - last);
}
last = i + 1;
out.append(QUOTE_ENCODE);
}
}
if (last == 0) {
return string;
}
if (i > last) {
out.append(input, last, i - last);
}
return out.toString();
}
/**
* Unescapes the String by converting XML escape sequences back into normal
* characters.
*
* @param string the string to unescape.
* @return the string with appropriate characters unescaped.
*/
public static String unescapeFromXML(String string) {
string = replace(string, "<", "<");
string = replace(string, ">", ">");
string = replace(string, """, "\"");
return replace(string, "&", "&");
}
private static final char[] zeroArray =
"0000000000000000000000000000000000000000000000000000000000000000".toCharArray();
/**
* Pads the supplied String with 0's to the specified length and returns
* the result as a new String. For example, if the initial String is
* "9999" and the desired length is 8, the result would be "00009999".
* This type of padding is useful for creating numerical values that need
* to be stored and sorted as character data. Note: the current
* implementation of this method allows for a maximum <tt>length</tt> of
* 64.
*
* @param string the original String to pad.
* @param length the desired length of the new padded String.
* @return a new String padded with the required number of 0's.
*/
public static String zeroPadString(String string, int length) {
if (string == null || string.length() > length) {
return string;
}
StringBuilder buf = new StringBuilder(length);
buf.append(zeroArray, 0, length - string.length()).append(string);
return buf.toString();
}
/**
* Formats a Date as a fifteen character long String made up of the Date's
* padded millisecond value.
*
* @return a Date encoded as a String.
*/
public static String dateToMillis(Date date) {
return zeroPadString(Long.toString(date.getTime()), 15);
}
/**
* Returns a textual representation for the time that has elapsed.
*
* @param delta the elapsed time.
* @return textual representation for the time that has elapsed.
*/
public static String getElapsedTime(long delta) {
if (delta < JiveConstants.MINUTE) {
return LocaleUtils.getLocalizedString("global.less-minute");
}
else if (delta < JiveConstants.HOUR) {
long mins = delta / JiveConstants.MINUTE;
StringBuilder sb = new StringBuilder();
sb.append(mins).append(" ");
sb.append((mins==1) ? LocaleUtils.getLocalizedString("global.minute") : LocaleUtils.getLocalizedString("global.minutes"));
return sb.toString();
}
else if (delta < JiveConstants.DAY) {
long hours = delta / JiveConstants.HOUR;
delta -= hours * JiveConstants.HOUR;
long mins = delta / JiveConstants.MINUTE;
StringBuilder sb = new StringBuilder();
sb.append(hours).append(" ");
sb.append((hours == 1) ? LocaleUtils.getLocalizedString("global.hour") : LocaleUtils.getLocalizedString("global.hours"));
sb.append(", ");
sb.append(mins).append(" ");
sb.append((mins == 1) ? LocaleUtils.getLocalizedString("global.minute") : LocaleUtils.getLocalizedString("global.minutes"));
return sb.toString();
} else {
long days = delta / JiveConstants.DAY;
delta -= days * JiveConstants.DAY;
long hours = delta / JiveConstants.HOUR;
delta -= hours * JiveConstants.HOUR;
long mins = delta / JiveConstants.MINUTE;
StringBuilder sb = new StringBuilder();
sb.append(days).append(" ");
sb.append((days == 1) ? LocaleUtils.getLocalizedString("global.day") : LocaleUtils.getLocalizedString("global.days"));
sb.append(", ");
sb.append(hours).append(" ");
sb.append((hours == 1) ? LocaleUtils.getLocalizedString("global.hour") : LocaleUtils.getLocalizedString("global.hours"));
sb.append(", ");
sb.append(mins).append(" ");
sb.append((mins == 1) ? LocaleUtils.getLocalizedString("global.minute") : LocaleUtils.getLocalizedString("global.minutes"));
return sb.toString();
}
}
/**
* Returns a formatted String from time.
*
* @param diff the amount of elapsed time.
* @return the formatte String.
*/
public static String getTimeFromLong(long diff) {
final String HOURS = "h";
final String MINUTES = "min";
final String SECONDS = "sec";
final long MS_IN_A_DAY = 1000 * 60 * 60 * 24;
final long MS_IN_AN_HOUR = 1000 * 60 * 60;
final long MS_IN_A_MINUTE = 1000 * 60;
final long MS_IN_A_SECOND = 1000;
Date currentTime = new Date();
long numDays = diff / MS_IN_A_DAY;
diff = diff % MS_IN_A_DAY;
long numHours = diff / MS_IN_AN_HOUR;
diff = diff % MS_IN_AN_HOUR;
long numMinutes = diff / MS_IN_A_MINUTE;
diff = diff % MS_IN_A_MINUTE;
long numSeconds = diff / MS_IN_A_SECOND;
diff = diff % MS_IN_A_SECOND;
long numMilliseconds = diff;
StringBuffer buf = new StringBuffer();
if (numHours > 0) {
buf.append(numHours + " " + HOURS + ", ");
}
if (numMinutes > 0) {
buf.append(numMinutes + " " + MINUTES);
}
//buf.append(numSeconds + " " + SECONDS);
String result = buf.toString();
if (numMinutes < 1) {
result = "< 1 minute";
}
return result;
}
/**
* Returns a collection of Strings as a comma-delimitted list of strings.
*
* @return a String representing the Collection.
*/
public static String collectionToString(Collection<String> collection) {
if (collection == null || collection.isEmpty()) {
return "";
}
StringBuilder buf = new StringBuilder();
String delim = "";
for (String element : collection) {
buf.append(delim);
buf.append(element);
delim = ",";
}
return buf.toString();
}
/**
* Returns a comma-delimitted list of Strings as a Collection.
*
* @return a Collection representing the String.
*/
public static Collection<String> stringToCollection(String string) {
if (string == null || string.trim().length() == 0) {
return Collections.emptyList();
}
Collection<String> collection = new ArrayList<String>();
StringTokenizer tokens = new StringTokenizer(string, ",");
while (tokens.hasMoreTokens()) {
collection.add(tokens.nextToken().trim());
}
return collection;
}
/**
* Abbreviates a string to a specified length and then adds an ellipsis
* if the input is greater than the maxWidth. Example input:
* <pre>
* user1@jivesoftware.com/home
* </pre>
* and a maximum length of 20 characters, the abbreviate method will return:
* <pre>
* user1@jivesoftware.c...
* </pre>
* @param str the String to abbreviate.
* @param maxWidth the maximum size of the string, minus the ellipsis.
* @return the abbreviated String, or <tt>null</tt> if the string was <tt>null</tt>.
*/
public static String abbreviate(String str, int maxWidth) {
if (null == str) {
return null;
}
if (str.length() <= maxWidth) {
return str;
}
return str.substring(0, maxWidth) + "...";
}
/**
*
* 此方法描述的是: 检测字符串是否为邮箱地址格式
* @version 创建时间:2009-9-13 下午01:34:23
*/
public static boolean isValidEmailAddress(String address) {
if (address == null) {
return false;
}
if (!address.contains("@")) {
return false;
}
try {
InternetAddress.parse(address);
return true;
}
catch (AddressException e) {
return false;
}
}
public static void main(String[] args){
//System.out.println("---->"+StringUtils.replaceIgnoreCase("我是。好m人", "M", "坏哈哈"));
System.out.println("---->"+StringUtils.isValidEmailAddress("011.com"));
}
}
分享到:
相关推荐
2. 字符串常用工具类: 字符串处理是编程中非常常见的任务,因此,一个字符串工具类会包含许多对字符串进行操作的方法。这可能包括字符串的格式化、分割、连接、查找和替换、去除空白字符、大小写转换、检查是否...
- Apache Commons Lang 提供了一系列工具类来简化字符串操作,如 `StringUtils`。 - 示例:使用 `StringUtils.equals` 方法进行比较。 #### 示例分析 给定的代码示例展示了如何使用 `equals` 方法来比较用户输入...
### Java字符串常用方法 在Java开发中,对字符串进行各种操作是常见的需求之一。下面将详细介绍标题和描述中提到的一些重要知识点。 #### 1. 判断字符串为空 判断一个字符串是否为空(`null`或者仅包含空白字符)...
`StringUtils`工具类是Java开发中非常常用的一个类库,主要提供了一系列静态方法来处理字符串。这个工具类在处理字符串的常见操作时提供了很大的便利,比如数组转字符串、空值检测、非空处理以及空格处理等。接下来...
Java 中的字符串处理是非常重要的一部分,而 StringUtils 工具类则是 Java 中最常用的字符串处理工具类之一。今天,我们将详细介绍如何自定义封装一个 StringUtils 工具类,并对其进行详细的解释。 标题解释 标题 ...
本篇文章将深入探讨Java中的几个常用工具类,包括日期处理、字符串操作、JSON解析以及货币转换等方面。 首先,让我们关注日期工具类。在Java中,日期处理通常涉及到`java.util.Date`和`java.time`包中的类。例如,`...
`StringUtils` 是 Apache Commons Lang 库中的一个核心类,提供了大量关于字符串操作的实用方法,旨在作为 Java 核心库的扩展。这个库在 `commons-lang-2.5` 版本中是最新的,尽管现在可能有更新的版本,但这个版本...
`StringUtils`类是这个工具包中的核心类之一,专门用于处理字符串的各种操作,包括但不限于判断、截取、格式化等。在Java标准库中,虽然`String`类已经提供了很多基本的字符串操作方法,但`StringUtils`通过提供更...
在这个"Android常用工具类"中,我们可以看到几个关键的工具类:DateUtils、OkhttpUtils、StringUtils、ToastUtils和LocationUtils。接下来,我们将详细探讨这些工具类的功能和用法。 1. **DateUtils**: DateUtils...
在 `StringUtils` 中,空格被视为非空字符,因此 `" "` 被认为是非空字符串。 **2. `isBlank(String str)` 和 `isNotBlank(String str)`** `isBlank` 方法更进一步,除了检查 `null` 和长度为零的情况,还会检测...
11. **工具类与库**:许多编程语言提供了专门的字符串处理工具类,如Java的`StringUtils`(Apache Commons Lang)和Python的`string`模块,它们提供了大量实用的静态方法,简化了字符串操作。 本章的讨论将涵盖以上...
= [] StringUtils.split("abc def", " ") = ["abc", "def"] StringUtils.split("abc def", ",") = ["abc def"] 以上仅列举了部分 StringUtils 中常用的方法,实际上还有很多其他功能,如去除特定字符、替换字符串、...
为了方便开发者高效地进行字符串操作,Apache Commons Lang库提供了一个强大的工具类——`StringUtils`。此工具类提供了丰富的静态方法来帮助开发者简化字符串处理任务。本文将详细介绍`StringUtils`中的几个常用...
下面我们将详细探讨这些工具类在字符串、日期、JDBC和XML解析等方面的使用。 1. **字符串工具**: - `String`类:Java中最基础的数据类型之一,提供了大量的静态方法用于字符串操作,如`concat()`, `substring()`,...
"常用工具类jar包"是一个集合了各种实用工具方法的库,主要包含了字符串处理、JSON转换处理、订单实体类以及商品库客户端调用的封装。下面将对这些知识点进行详细解释: 1. **字符串处理封装**: 字符串处理是编程...
Java 常用工具类是开发中不可或缺的部分,它们提供了许多便利的功能,帮助开发者提高代码质量和开发效率。在Java世界里,String是最常用的类之一,它涵盖了字符串处理的各种基本操作。然而,JDK内置的String API有时...