StringUtils

/*** Eclipse Class Decompiler plugin, copyright (c) 2012 Chao Chen (cnfree2000@hotmail.com) ***/
package bf.cbm.util;

import bf.cbm.util.collection.ArrayUtil;
import java.io.UnsupportedEncodingException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.codec.language.Metaphone;

public final class StringUtil {
public static final String BLANK = "";
public static final String UNDERSCORE = "_";
public static final String SPACE = " ";
public static final String NEWLINE = "\\n";
public static final String BULLET_INDENT_SYMBOL = "\\xb7";
private static final int DEFAULT_SPACES_LENGTH = 100000;
private static final String[] PUNCTUATION = { ",", ".", ";", ":", "/",
"\\", "-", "_", " ", "!", "/" };

private static final String[] PUNCTUATION_INCLUDING_QUESTION_MARK = (String[]) ArrayUtil
.union(PUNCTUATION, new String[] { "?" }, String.class);

private static final Pattern BR_TAG_PATTERN = Pattern
.compile("<[Bb][Rr]\\s*/>");
private static final String HTML_A_HREF_TAG_PATTERN = "\\s*(?i)href\\s*=\\s*(\"([^\"]*\")|'[^']*'|([^'\">\\s]+))";

public static String toString(Object object) {
if (object != null) {
return object.toString();
}
return "";
}

public static String toStringOrNull(Object object) {
if (object != null) {
return object.toString();
}
return null;
}

public static String toStringConvertNull(Object object) {
if (object != null) {
String objectString = object.toString();
if (!("null".equalsIgnoreCase(objectString))) {
return objectString;
}
}
return "";
}

public static boolean containsCaseInsensitiveStringOrBothStringsAreNull(
String stringToFind, String stringToSearch) {
if ((stringToFind == null) && (stringToSearch == null))
return true;
if ((stringToSearch != null) && (stringToFind == null))
return false;
if ((stringToSearch == null) && (stringToFind != null)) {
return false;
}
String stringToFindAsUpperCase = stringToFind.toUpperCase();
String stringToSearchAsUpperCase = stringToSearch.toUpperCase();
return stringToSearchAsUpperCase.contains(stringToFindAsUpperCase);
}

public static boolean containsAnyStringsFromList(String stringToSearch,
List<String> stringsToFind) {
if (stringsToFind == null) {
return false;
}

for (String stringToFind : stringsToFind) {
if (containsCaseInsensitiveStringOrBothStringsAreNull(stringToFind,
stringToSearch)) {
return true;
}
}

return false;
}

public static boolean isEqualUpperCase(String s1, String s2) {
if ((s1 == null) && (s2 == null))
return true;
if ((s1 != null) && (s2 == null))
return false;
if ((s1 == null) && (s2 != null)) {
return false;
}
s1 = s1.toUpperCase();
s2 = s2.toUpperCase();

return s1.equals(s2);
}

public static boolean equals(String a, String b) {
if ((a == null) && (b == null))
return true;
if ((a == null) && (b != null))
return false;
if ((a != null) && (b == null)) {
return false;
}
return a.equals(b);
}

public static boolean isNotEqual(String a, String b) {
return (!(equals(a, b)));
}

public static boolean isEqualOrBothEmpty(String first, String second) {
return ((((isEmpty(first)) || (first.equals(second)))) && (((isEmpty(second)) || (second
.equals(first)))));
}

public static boolean equalsOneOf(String testString, String[] setOfStrings) {
if ((testString == null) && (setOfStrings == null))
return true;
if (testString == null)
return false;
if (setOfStrings == null) {
return false;
}
for (String s : setOfStrings) {
if (equals(s, testString)) {
return true;
}

}

return false;
}

public static boolean equalsAndNotNull(String a, String b) {
if ((a != null) && (b != null)) {
return a.equals(b);
}
return false;
}

public static boolean equalsWhereNullAndEmptyAreEquivalent(String a,
String b) {
if (a == null) {
a = "";
}
if (b == null) {
b = "";
}
return a.equals(b);
}

public static boolean isDifferent(String a, String b) {
return (!(equals(a, b)));
}

public static boolean isDifferentWhereNullAndEmptyAreNotConsideredDifferent(
String a, String b) {
return (!(equalsWhereNullAndEmptyAreEquivalent(a, b)));
}

public static int attributeCompareTo(Object o1, Object o2,
String attributeName) {
return attributeCompareTo(o1, o2, attributeName, false);
}

public static int attributeCompareTo(Object o1, Object o2,
String attributeName, boolean ignoreCase) {
if ((ObjectUtil.isEmpty(o1)) && (ObjectUtil.isEmpty(o2)))
return 0;
if ((ObjectUtil.isEmpty(o1) ^ ObjectUtil.isEmpty(o2)))
return ((ObjectUtil.isEmpty(o1)) ? -1 : 1);
try {
String attr1 = (String) PropertyUtils.getSimpleProperty(o1,
attributeName);
String attr2 = (String) PropertyUtils.getSimpleProperty(o2,
attributeName);
if (ignoreCase) {
return compareToIgnoreCase(attr1, attr2);
}
return compareTo(attr1, attr2);
} catch (Exception e) {
throw new IllegalStateException(
new StringBuilder()
.append("StringUtil was unable to compare attributes of objects:\n\t")
.append(o1).append("\n\t").append(o2)
.append("\n\tAttribute Name: ")
.append(attributeName).toString());
}
}

public static int compareTo(String c1, String c2) {
if ((c1 != null) && (c2 != null))
return c1.compareTo(c2);
if ((c1 == null) && (c2 == null))
return 0;
if ((c1 == null) && (c2 != null)) {
return -1;
}

return 1;
}

public static int compareToIgnoreCase(String c1, String c2) {
if ((c1 != null) && (c2 != null))
return c1.compareToIgnoreCase(c2);
if ((c1 == null) && (c2 == null))
return 0;
if ((c1 == null) && (c2 != null)) {
return -1;
}

return 1;
}

public static boolean isBlank(String value) {
return ((value == null) || (value.trim().length() == 0));
}

public static boolean isEmpty(String value) {
return ((value == null) || (value.trim().length() == 0));
}

public static boolean isNotBlank(String value) {
return (!(isBlank(value)));
}

public static boolean isNotEmpty(String val) {
return (!(isEmpty(val)));
}

public static boolean isNullOrZeroLength(String val) {
return ((val == null) || (val.length() == 0));
}

public static boolean isNotNullAndIsNotZeroLength(String val) {
return (!(isNullOrZeroLength(val)));
}

public static boolean allEmpty(String[] vals) {
for (String val : vals) {
if (isNotEmpty(val)) {
return false;
}
}
return true;
}

public static boolean anyEmpty(String[] vals) {
for (String val : vals) {
if (isEmpty(val)) {
return true;
}
}
return false;
}

public static boolean startsWithVowel(String s) {
if (isEmpty(s)) {
return false;
}
char first = s.substring(0, 1).toCharArray()[0];
return isVowel(first);
}

public static boolean startsWithValue(String s, String val) {
if ((isEmpty(s)) || (isEmpty(val))) {
return false;
}
return s.startsWith(val);
}

public static boolean isVowel(char c) {
return ((c == 'a') || (c == 'A') || (c == 'e') || (c == 'E')
|| (c == 'i') || (c == 'I') || (c == 'o') || (c == 'O')
|| (c == 'u') || (c == 'U'));
}

public static boolean isSingleRepeatingCharacter(String string, char ch) {
if (isEmpty(string)) {
return false;
}

char[] characters = string.toCharArray();
for (char c : characters) {
if (ch != c) {
return false;
}
}
return true;
}

public static boolean isAllDigits(String testString) {
if (isEmpty(testString)) {
return false;
}

char[] testChars = testString.toCharArray();
for (char testChar : testChars) {
if (!(Character.isDigit(testChar))) {
return false;
}
}
return true;
}

public static boolean containsADigit(String testString) {
if (testString == null) {
return false;
}

for (char testChar : testString.toCharArray()) {
if (Character.isDigit(testChar)) {
return true;
}
}
return false;
}

public static boolean isValidDateRule(String dateRule) {
return Pattern
.matches("[A-Z[_]*]+\\(\\d{1,2}(,\\d{1,2})?\\)", dateRule);
}

public static boolean isValidDateRuleSingle(String dateRule) {
return Pattern.matches("[A-Z[_]*]+\\(\\d{1,2}\\)", dateRule);
}

public static boolean isValidAlphaNumeric(String str) {
return Pattern.matches("^[a-zA-Z0-9]+$", str);
}

public static boolean isValidAlphaWithSpace(String str) {
return Pattern.matches("^[a-zA-Z ]+$", str);
}

public static boolean isValidAnchorTag(String str) {
if (str.contains("<a>")) {
return false;
}

if (!(isValidateHref(str.split("<a"), "</a>"))) {
return false;
}

return isValidateHref(str.split("</a>"), "<a");
}

public static boolean isValidateHref(String[] strArr, String tagPrefixSuffix) {
for (String anchorTag : strArr) {
if (anchorTag.contains("href")) {
if (anchorTag.contains(tagPrefixSuffix)) {
boolean matchesHrefTagPattern = Pattern
.compile(
"\\s*(?i)href\\s*=\\s*(\"([^\"]*\")|'[^']*'|([^'\">\\s]+))")
.matcher(
new StringBuilder().append("<a ")
.append(anchorTag).toString())
.find();
if (!(matchesHrefTagPattern))
return false;
} else {
return false;
}
}
}
return true;
}

public static boolean isValidAbsoluteURL(String url) {
return ((isNotEmpty(url)) && (((url.startsWith("http://")) || (url
.startsWith("https://")))));
}

public static String checkNull(String possiblyNull) {
return neverNull(possiblyNull);
}

public static String checkNull(String possiblyNull, String useIfNull) {
return ((possiblyNull == null) ? useIfNull : possiblyNull);
}

public static String preferNotNull(String firstPreference,
String failoverIfFirstWasNull) {
return ((firstPreference == null) ? failoverIfFirstWasNull
: firstPreference);
}

public static String neverNull(String possiblyNull) {
return ((possiblyNull == null) ? "" : possiblyNull);
}

public static String neverNull(String possiblyNull, String useIfNull) {
if (possiblyNull == null) {
if (useIfNull == null) {
return "";
}
return useIfNull;
}

return possiblyNull;
}

public static String neverBlank(String possiblyNullOrWhitespace,
String useIfBlank) {
if (isBlank(possiblyNullOrWhitespace)) {
if (isBlank(useIfBlank)) {
return "[ unknown ]";
}
return useIfBlank;
}

return possiblyNullOrWhitespace;
}

public static boolean matchesFirstNCharacters(String field1, String field2,
int n) {
if ((((field1 == null) || (field2 == null)))
&& (((field1 != null) || (field2 != null)))) {
return false;
}

if (field1 != null)
field1 = field1.trim();
else {
field1 = "";
}
if (field2 != null)
field2 = field2.trim();
else {
field2 = "";
}
if ((((field1.isEmpty()) || (field2.isEmpty())))
&& (!(field1.equals(field2)))) {
return false;
}

if (field1.length() >= n) {
if (field2.length() >= n) {
String field1Fragment = field1.substring(0, n);
String field2Fragment = field2.substring(0, n);
return field1Fragment.equals(field2Fragment);
}
return false;
}

return false;
}

public static int getSubstringCount(String string, String substring) {
if (isEmpty(string)) {
return 0;
}

int count = 0;
int index = -1;
while (true) {
int newIndex = string.indexOf(substring, index + 1);
if (newIndex <= index)
break;
++count;
index = newIndex;
}

return count;
}

public static String escapeQuotes(String s) {
if (s == null) {
return null;
}

if ((s.indexOf(39) >= 0) || (s.indexOf(34) >= 0)) {
s = replaceSequenceStrictCase(s, "'", "\\'");
s = replaceSequenceStrictCase(s, "\"", "\\\"");
}
return s;
}

public static String escapeHTML(String s) {
if (s == null) {
return null;
}

if ((s.indexOf(62) >= 0) || (s.indexOf(60) >= 0)) {
s = replaceSequenceStrictCase(s, ">", "&gt;");
s = replaceSequenceStrictCase(s, "<", "&lt;");
}
return s;
}

public static String convertToHTML(String s) {
if (s == null) {
return s;
}

s = s.replaceAll("&", "&amp;");
s = s.replaceAll("<", "&lt;");
s = s.replaceAll(">", "&gt;");
s = s.replaceAll("\n", "<br/>");

return s;
}

public static String escapeHTMLAttributeValue(String s) {
if (s == null) {
return null;
}

if ((s.indexOf(62) >= 0) || (s.indexOf(60) >= 0)
|| (s.indexOf(34) >= 0) || (s.indexOf(38) >= 0)) {
s = s.replaceAll("&", "&amp;");
s = s.replaceAll("\"", "&quot;");
s = s.replaceAll(">", "&gt;");
s = s.replaceAll("<", "&lt;");
}
return s;
}

public static String reverseEscapeHTML(String s) {
if (s == null) {
return null;
}

if ((s.contains("&gt;")) || (s.contains("&lt;"))
|| (s.contains("&amp;")) || (s.contains("&#43;"))
|| (s.contains("&#39;")) || (s.contains("&#64;"))) {
s = replaceSequenceIgnoreCase(s, "&amp;", "&");
s = replaceSequenceIgnoreCase(s, "&gt;", ">");
s = replaceSequenceIgnoreCase(s, "&lt;", "<");
s = replaceSequenceStrictCase(s, "&#43;", "+");
s = replaceSequenceStrictCase(s, "&#39;", "'");
s = replaceSequenceStrictCase(s, "&#64;", "@");
}
return s;
}

public static String replaceSequenceIgnoreCase(String source, String old,
String nue) {
if ((source == null) || (source.length() == 0)) {
return null;
}
if ((old == null) || (old.length() == 0)) {
throw new IllegalArgumentException(
"String to replace can't be empty");
}

if (nue == null) {
nue = "";
}

String oldAsUpperCase = old.toUpperCase();
if (nue.toUpperCase().contains(oldAsUpperCase)) {
StringBuilder buffer = new StringBuilder(source.length());
int index = 0;

while ((pos = source.toUpperCase().indexOf(oldAsUpperCase, index)) != -1) {
int pos;
buffer.append(source.substring(index, pos));
buffer.append(nue);
index = pos + old.length();
}
buffer.append(source.substring(index, source.length()));
return buffer.toString();
}

StringBuilder buffer = new StringBuilder(source.length());
buffer.append(source);

while ((index = buffer.toString().toUpperCase().indexOf(oldAsUpperCase)) > -1) {
int index;
buffer.replace(index, index + old.length(), nue);
}
return buffer.toString();
}

public static String replaceSequenceStrictCase(String source, String old,
String nue) {
if ((source == null) || (source.length() == 0)) {
return null;
}
if ((old == null) || (old.length() == 0)) {
throw new IllegalArgumentException(
"String to replace can't be empty");
}

if (nue == null) {
nue = "";
}

if (nue.contains(old)) {
StringBuilder buffer = new StringBuilder(source.length());
int index = 0;

while ((pos = source.indexOf(old, index)) != -1) {
int pos;
buffer.append(source.substring(index, pos));
buffer.append(nue);
index = pos + old.length();
}
buffer.append(source.substring(index, source.length()));
return buffer.toString();
}

StringBuilder buffer = new StringBuilder(source.length());
buffer.append(source);

while ((index = buffer.indexOf(old)) > -1) {
int index;
buffer.replace(index, index + old.length(), nue);
}
return buffer.toString();
}

public static String replaceIllegalCharacters(String source) {
String fixedString = source;
if (source != null) {
if (fixedString.indexOf(60) > -1) {
fixedString = fixedString.replace('<', ' ');
}
if (fixedString.indexOf(62) > -1) {
fixedString = fixedString.replace('>', ' ');
}
}
return fixedString;
}

public static String replace(String orig, String replacee, String replacor) {
if (orig == null)
return "";
if ((replacee == null) || (replacor == null)) {
return orig;
}
int startIndex = 0;
String result = new String(orig);
while (true) {
int replaceStartIndex = result.indexOf(replacee, startIndex);
if (replaceStartIndex == -1) {
break;
}
int replaceEndIndex = replaceStartIndex + replacee.length() - 1;
result = new StringBuilder()
.append(result.substring(0, replaceStartIndex))
.append(replacor)
.append(result.substring(replaceEndIndex + 1,
result.length())).toString();
startIndex = replaceStartIndex + replacor.length();
}
return result;
}

public static String replace(String orig, String[] replacees,
String replacor) {
if (orig == null)
return "";
if ((replacees == null) || (replacees.length == 0)
|| (replacor == null)) {
return orig;
}
String result = new String(orig);
for (String replacee : replacees) {
result = replace(result, replacee, replacor);
}
return result;
}

public static String filterPunctuation(String s, String filterOut) {
return replace(s, filterOut, "");
}

public static String filterPunctuation(String s) {
return replace(s, PUNCTUATION, "");
}

public static String filterPunctuationIncludingQuestionMark(String s) {
return replace(s, PUNCTUATION_INCLUDING_QUESTION_MARK, "");
}

public static String filterPunctuationAndBlanks(Object obj) {
if (obj != null) {
return filterPunctuationAndBlanks(obj.toString());
}
return "";
}

public static String filterPunctuationAndBlanks(String s) {
String filtered = filterPunctuation(s);
return replace(filtered, " ", "");
}

public static String filterExtraneousBlanks(String s) {
if (isNullOrZeroLength(s)) {
return s;
}
return s.trim().replaceAll("\\s{2,}", " ");
}

public static String toLowerCase(String s) {
return ((s == null) ? null : s.toLowerCase());
}

public static String toUpperCase(String s) {
return ((s == null) ? null : s.toUpperCase());
}

public static String lowercaseFirstLetter(String s) {
if ((s != null) && (s.length() > 0)) {
return new StringBuilder()
.append(Character.toLowerCase(s.charAt(0)))
.append(s.substring(1)).toString();
}
return s;
}

public static String lowercaseFirstLetterIfNotInAnAcronym(String s) {
if ((s != null) && (s.length() > 0)) {
if ((s.length() > 2) && (Character.isUpperCase(s.charAt(1)))
&& (Character.isUpperCase(s.charAt(2)))) {
return s;
}
return new StringBuilder()
.append(Character.toLowerCase(s.charAt(0)))
.append(s.substring(1)).toString();
}

return s;
}

public static String uppercaseFirstLetter(String s) {
if ((s != null) && (s.length() > 0)) {
return new StringBuilder()
.append(Character.toUpperCase(s.charAt(0)))
.append(s.substring(1)).toString();
}
return s;
}

public static String mixedCase(String s) {
return ((s == null) ? null : uppercaseFirstLetter(s.toLowerCase()));
}

public static String toLowerCaseStrictlyAlphaNumeric(String stringToSimplify) {
if (stringToSimplify != null) {
String lowerSourceString = stringToSimplify.toLowerCase();
StringBuilder safeStringBuilder = new StringBuilder(
lowerSourceString.length());
for (int i = 0; i < lowerSourceString.length(); ++i) {
char characterToExamine = lowerSourceString.charAt(i);
if (Character.isLetterOrDigit(characterToExamine)) {
safeStringBuilder.append(characterToExamine);
}
}
return safeStringBuilder.toString();
}
return null;
}

public static String strictlyAlphaNumeric(String stringToSimplify) {
if (stringToSimplify != null) {
StringBuilder safeStringBuilder = new StringBuilder(
stringToSimplify.length());
for (int i = 0; i < stringToSimplify.length(); ++i) {
char characterToExamine = stringToSimplify.charAt(i);
if (Character.isLetterOrDigit(characterToExamine)) {
safeStringBuilder.append(characterToExamine);
}
}
return safeStringBuilder.toString();
}
return null;
}

public static String humanizeJavaClassName(Class clazz) {
String unqualifiedClassName = ObjectUtil.getUnqualifiedClassName(clazz);
return humanizeJavaName(unqualifiedClassName);
}

public static String humanizeJavaClassNameAndOptionallyDiscardSuffix(
Class clazz, String classNameSuffixToDiscard) {
String unqualifiedClassName = ObjectUtil.getUnqualifiedClassName(clazz);
if ((classNameSuffixToDiscard != null)
&& (unqualifiedClassName.endsWith(classNameSuffixToDiscard))) {
unqualifiedClassName = unqualifiedClassName.substring(
0,
unqualifiedClassName.length()
- classNameSuffixToDiscard.length());
}

return humanizeJavaName(unqualifiedClassName);
}

public static String humanizeJavaName(String javaName) {
return javaName.replaceAll("([^A-Z])([A-Z])", "$1 $2").replaceAll(
"([^0-9])([0-9])", "$1 $2");
}

public static String humanizeJavaNameAndUppercaseFirstLetter(String javaName) {
return humanizeJavaName(uppercaseFirstLetter(javaName));
}

public static String toOrdinal(long number) {
StringBuilder sb = new StringBuilder(new StringBuilder().append(number)
.append("").toString());

int penult = (int) (number % 100L) / 10;
int ult = (int) (number % 10L);

if (penult != 1) {
if (ult == 1)
sb.append("st");
else if (ult == 2)
sb.append("nd");
else if (ult == 3)
sb.append("rd");
else
sb.append("th");
} else {
sb.append("th");
}

return sb.toString();
}

public static String prependAOrAn(String s) {
StringBuilder sb = new StringBuilder();
if (!(isEmpty(s))) {
sb.append((startsWithVowel(s)) ? "an " : "a ");
sb.append(s);
}
return sb.toString();
}

public static String repeat(String stringToRepeat, int timesToRepeat) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < timesToRepeat; ++i) {
sb.append(stringToRepeat);
}
return sb.toString();
}

public static String toFixedLengthBinaryString(int decimal, int totalChars) {
String binary = Integer.toBinaryString(decimal);

if (binary.length() > totalChars) {
throw new IllegalArgumentException(new StringBuilder()
.append(decimal).append(" in binary is ").append(binary)
.append(" which has ").append("more than ")
.append(totalChars).append(" characters.").toString());
}

char[] charArray = new char[totalChars];
int binaryIndex = 0;
for (int i = 0; i < charArray.length; ++i) {
if (i < charArray.length - binary.length())
charArray[i] = '0';
else {
charArray[i] = binary.charAt(binaryIndex++);
}

}

return new String(charArray);
}

public static String blankInsteadOfNull(Object obj) {
if (obj == null) {
return "";
}
return blankInsteadOfNull(obj.toString());
}

public static String blankInsteadOfNull(String string) {
if (string == null) {
return "";
}
return string;
}

public static String stringInsteadOfNull(String string, String defaultString) {
if (string == null) {
return defaultString;
}
return string;
}

public static String getBlankString(int length) {
if (length > 100000) {
throw new IllegalArgumentException(
"trying to get more space than we are prepared for, max size = 100000");
}

StringBuilder sb = new StringBuilder();
for (int i = 0; i < length; ++i) {
sb.append(' ');
}
return sb.toString();
}

public static String stripTrailingBrTags(String string) {
if (string == null) {
return null;
}

String s = string.trim();
while ((s.endsWith("<br>")) || (s.endsWith("<br/>"))
|| (s.endsWith("<BR>")) || (s.endsWith("<BR/>"))) {
s = s.substring(0, s.lastIndexOf(60));
s = s.trim();
}

return s;
}

public static boolean containsBrTag(String string) {
Matcher brMatcher = BR_TAG_PATTERN.matcher(string);
return brMatcher.find();
}

public static String stripTrailingSubstrings(String string, String substring) {
if ((string == null) || (substring == null)) {
return null;
}

String s = string.trim();
while (s.endsWith(substring)) {
s = s.substring(0, s.lastIndexOf(substring));
s = s.trim();
}

return s;
}

public static String formatMessage(String message, String[] args) {
MessageFormat mf = new MessageFormat(message);
return mf.format(args);
}

public static String toDelimitedString(Collection collection,
String delimiter) {
if (collection == null) {
return "";
}
return toDelimitedString(collection.toArray(), delimiter);
}

public static String toDelimitedString(Collection collection,
String delimiter, String lastDelimiter) {
if (collection == null) {
return "";
}
return toDelimitedString(collection.toArray(), delimiter, lastDelimiter);
}

public static String toDelimitedString(Object[] objs, String delimiter) {
return toDelimitedString(objs, delimiter, null);
}

public static String toDelimitedString(Object[] objs, String delimiter,
String lastDelimiter) {
return toDelimitedString(objs, delimiter, lastDelimiter, false);
}

public static String toDelimitedString(Object[] objs, String delimiter,
String lastDelimiter, boolean trimStrings) {
if (objs != null) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < objs.length; ++i) {
Object obj = objs[i];
if (i > 0) {
sb.append(((i == objs.length - 1) && (!(isEmpty(lastDelimiter)))) ? lastDelimiter
: delimiter);
}

if (obj != null) {
sb.append((trimStrings) ? obj.toString().trim() : obj);
}

}

return sb.toString();
}
return "";
}

public static String trim(String s) {
if (s != null) {
return s.trim();
}
return null;
}

public static String padOrTrimTo(String s, int length) {
if ((s == null) || ("".equals(s.trim())))
return "";
if (s.length() == length)
return s;
if (s.length() > length) {
return s.substring(0, length);
}
return new StringBuilder().append(s)
.append(getBlankString(length - s.length())).toString();
}

public static String leftPad(String s, char padChar, int length) {
if (s == null) {
s = "";
}

if (s.length() >= length) {
return s;
}

int paddingNeeded = length - s.length();
StringBuilder result = new StringBuilder();

for (int i = 0; i < paddingNeeded; ++i) {
result.append(padChar);
}

result.append(s);
return result.toString();
}

public static String rightPad(String s, char padChar, int length) {
if (s == null) {
s = "";
}

if (s.length() >= length) {
return s;
}

int paddingNeeded = length - s.length();
StringBuilder result = new StringBuilder();
result.append(s);

for (int i = 0; i < paddingNeeded; ++i) {
result.append(padChar);
}

return result.toString();
}

public static String rightTrim(String s, int length) {
if ((isNullOrZeroLength(s)) || (s.length() <= length)) {
return s;
}
return s.substring(0, length);
}

public static String leftTrim(String s, int length) {
if ((isNullOrZeroLength(s)) || (s.length() <= length)) {
return s;
}
return s.substring(s.length() - length);
}

public static String removeSuffixFromEndOf(String original,
String suffixToRemoveIfFound) {
if ((original == null) || (suffixToRemoveIfFound == null)
|| (original.length() == 0)
|| (suffixToRemoveIfFound.length() == 0)) {
return original;
}
if (original.endsWith(suffixToRemoveIfFound)) {
return original.substring(0, original.length()
- suffixToRemoveIfFound.length());
}

return original;
}

public static String removePrefix(String prefixToRemoveIfFound,
String original) {
if ((original == null) || (prefixToRemoveIfFound == null)
|| (original.length() == 0)
|| (prefixToRemoveIfFound.length() == 0)) {
return original;
}
if (original.startsWith(prefixToRemoveIfFound)) {
return original.substring(prefixToRemoveIfFound.length());
}

return original;
}

public static int getMaxLengthAsPerceivedByDatabase(
String stringToValidateLengthOf) {
if (isNotNullAndIsNotZeroLength(stringToValidateLengthOf)) {
try {
return stringToValidateLengthOf.getBytes("UTF-8").length;
} catch (UnsupportedEncodingException localUnsupportedEncodingException) {
}
}
return 0;
}

public static String removeNonDigits(String input) {
if (input != null) {
return input.replaceAll("\\D", "");
}
return input;
}

public static String escapeXML(String s) {
if (s == null) {
return null;
}

if (s.indexOf(38) >= 0) {
s = s.replaceAll("&", "&amp;");
}
if (s.indexOf(60) >= 0) {
s = s.replaceAll("<", "&lt;");
}
if (s.indexOf(62) >= 0) {
s = s.replaceAll(">", "&gt;");
}
if (s.indexOf(34) >= 0) {
s = s.replaceAll(String.valueOf('"'), "&quot;");
}
if (s.indexOf(39) >= 0) {
s = s.replaceAll(String.valueOf('\''), "&apos;");
}

return s;
}

public static String[] fromDelimitedStringToArray(String delimitedString,
String delimiter) {
List listOfStrings = fromDelimitedStringToList(delimitedString,
delimiter);
return ((String[]) listOfStrings.toArray(new String[listOfStrings
.size()]));
}

public static List<String> fromDelimitedStringToList(
String delimitedString, String delimiter) {
return ((List) fromDelimitedStringToCollection(delimitedString,
delimiter, new ArrayList()));
}

public static Set<String> fromDelimitedStringToSet(String delimitedString,
String delimiter) {
return ((Set) fromDelimitedStringToCollection(delimitedString,
delimiter, new HashSet()));
}

public static Collection<String> fromDelimitedStringToCollection(
String delimitedString, String delimiter,
Collection<String> stringCollection) {
if (isEmpty(delimitedString)) {
return stringCollection;
}

StringTokenizer parseString = new StringTokenizer(delimitedString,
delimiter);
while (parseString.hasMoreTokens()) {
stringCollection.add(parseString.nextToken());
}

return stringCollection;
}

public static String unformatNumber(String thenum) {
String num = new String();
if (thenum != null) {
for (int i = 0; i < thenum.length(); ++i) {
if (Character.isDigit(thenum.charAt(i))) {
num = new StringBuilder().append(num)
.append(thenum.charAt(i)).toString();
}
}
}
return num;
}

public static String substr(String theString, int startPos, int length) {
return substrnopad(theString, startPos, length, true);
}

public static String substrnopad(String theString, int startPos,
int length, boolean padFlag) {
int endPos = startPos + length;
String retString = new String();

if (theString != null) {
if (endPos >= theString.length())
retString = theString.substring(startPos);
else {
retString = theString.substring(startPos, endPos);
}

}

while ((padFlag) && (retString.length() < length)) {
retString = new StringBuilder().append(retString).append(" ")
.toString();
}

return retString;
}

public static List<String> splitIntoStringsOfMaxLength(String longString,
int maxLength) {
List splitStrings = new ArrayList();
if (longString != null) {
int index = 0;
while ((index < longString.length()) || (index == 0)) {
splitStrings.add(longString.substring(index,
Math.min(index + maxLength, longString.length())));
index += maxLength;
}
}
return splitStrings;
}

public static List<String> splitByCommaOrWhitespaceAndPreventEmptyValuesInResult(
String stringToSplit) {
return splitByRegexAndPreventEmptyValuesInResult("([, ]+)",
stringToSplit);
}

public static List<String> splitByRegexAndPreventEmptyValuesInResult(
String delimiterRegex, String stringToSplit) {
if ((delimiterRegex == null) || (stringToSplit == null)) {
return Collections.emptyList();
}

List nonEmptyFragments = new ArrayList();

for (String fragment : stringToSplit.split(delimiterRegex)) {
if (isNotEmpty(fragment)) {
nonEmptyFragments.add(fragment);
}
}
return nonEmptyFragments;
}

public static String removePunctuation(String s) {
char[] removeChar = { '.', '!', '#', '$', '%', '&', '\'', '(', ')',
'*', '+', ',', '-', '/', ':', ';', '<', '?', '[', '\\', ']',
'^', '`', '{', '|', '}' };

int i = 0;
for (; i < removeChar.length; ++i) {
s = s.replace(removeChar[i], ' ');
}
s = s.trim();
return s;
}

public static boolean equalsIgnoreCase(String value1, String value2) {
if ((value1 == null) && (value2 == null)) {
return true;
}
if ((value1 == null) || (value2 == null)) {
return false;
}

return value1.equalsIgnoreCase(value2);
}

public static boolean metaphoneStrings(String string1, String string2) {
Metaphone metaphone = new Metaphone();
String first = metaphone.encode(string1);
String second = metaphone.encode(string2);

return metaphone.isMetaphoneEqual(first, second);
}

public static String addDashesToSSN(String ssn) {
if ((ssn == null) || (ssn.length() != 9)) {
return null;
}
return new StringBuilder().append(ssn.substring(0, 3)).append("-")
.append(ssn.substring(3, 5)).append("-")
.append(ssn.substring(5, 9)).toString();
}

public static String abbreviate(String str, int maxWidth) {
if ((str == null) || (str.length() <= maxWidth)) {
return str;
}
if (maxWidth < 4) {
throw new IllegalStateException("maxWidth can not be less then 4");
}

return new StringBuilder().append(str.substring(0, maxWidth - 3))
.append("...").toString();
}

public static String abbreviateToDatabasePerceivedLength(String str,
int maxWidth) {
if ((str == null)
|| (getMaxLengthAsPerceivedByDatabase(str) <= maxWidth)) {
return str;
}
if (maxWidth < 4) {
throw new IllegalStateException("maxWidth can not be less then 4");
}

String abbreviatedString = str.substring(0, maxWidth - 3);
while (getMaxLengthAsPerceivedByDatabase(abbreviatedString) > maxWidth - 3) {
abbreviatedString = abbreviatedString.substring(0,
abbreviatedString.length() - 1);
}
return new StringBuilder().append(abbreviatedString).append("...")
.toString();
}

public static boolean isAllUpperCase(String string) {
if (isEmpty(string)) {
return false;
}
int length = string.length();
for (int i = 0; i < length; ++i) {
Character character = Character.valueOf(string.charAt(i));
if ((Character.isLetter(character.charValue()))
&& (!(Character.isUpperCase(character.charValue())))) {
return false;
}
}

return true;
}

public static String parseUserNameForAudit(String userNameForAudit) {
String parsedString = userNameForAudit;
if ((userNameForAudit != null) && (userNameForAudit.contains(":"))) {
parsedString = userNameForAudit.substring(userNameForAudit
.lastIndexOf(":") + 1);
}
return parsedString;
}

public static String replaceSpecialCharacters(String value) {
if (value != null) {
value = value.replace("’", "’");
value = value.replace("“", "“");
value = value.replace("”", "”");
}
return value;
}

public static String parseStringAsDoubleAndTruncateToInt(String amount) {
double d = Double.parseDouble(amount);
int i = (int) d;
return String.valueOf(i);
}

public static String addLeadingPathSeparatorIfMissing(String path) {
if (path == null)
return null;
if (path.startsWith("/")) {
return path;
}
return new StringBuilder().append("/").append(path).toString();
}

public static boolean isGreaterThan(String string, int length) {
return ((isNotEmpty(string)) && (string.length() > length));
}

public static String toHtmlUnorderedList(Collection<?> items) {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("<ul>\n");
for (Iterator i$ = items.iterator(); i$.hasNext();) {
Object object = i$.next();
stringBuilder.append("  <li>").append(object).append("</li>\n");
}
stringBuilder.append("</ul>");
return stringBuilder.toString();
}

public static String toFilenameSafeString(String filename) {
return filename.replace(' ', '_').replaceAll("[^0-9a-zA-Z_]", "");
}

public static String queryStringParam(String paramName, String paramValue) {
return String.format("%s=%s", new Object[] { paramName, paramValue });
}

public static String escapeCSV(String in) {
if (in == null) {
return "";
}

boolean needToEncloseInQuotes = false;

if (in.indexOf(34) != -1) {
needToEncloseInQuotes = true;
in = in.replaceAll("[\"]", "\"\"");
}

if (in.indexOf(44) != -1) {
needToEncloseInQuotes = true;
}

if (needToEncloseInQuotes) {
return new StringBuilder().append("\"").append(in).append("\"")
.toString();
}
return in;
}
}