terms,
String delim)
{
StringBuilder sb = new StringBuilder(32);
if (terms != null && !terms.isEmpty())
{
boolean appended = false;
for (String term : terms)
{
if (appended)
{
sb.append(delim);
}
appended = true;
sb.append(term);
}
}
return sb.toString();
}
/**
* Convenience method to parse a string to an integer, returning 0 if the
* input is null or not a valid integer
*
* @param s
* @return
*/
public static int parseInt(String s)
{
int result = 0;
if (s != null && s.length() > 0)
{
try
{
result = Integer.parseInt(s);
} catch (NumberFormatException ex)
{
}
}
return result;
}
/**
* Compares two versions formatted as e.g. "3.4.5" and returns -1, 0 or 1 as
* the first version precedes, is equal to, or follows the second
*
* @param v1
* @param v2
* @return
*/
public static int compareVersions(String v1, String v2)
{
return compareVersions(v1, v2, null);
}
/**
* Compares two versions formatted as e.g. "3.4.5b1" and returns -1, 0 or 1 as
* the first version precedes, is equal to, or follows the second
*
* @param v1
* @param v2
* @param pointSeparator
* a string used to delimit point increments in sub-tokens of the
* version
* @return
*/
public static int compareVersions(String v1, String v2,
String pointSeparator)
{
if (v1 == null || v2 == null)
{
return 0;
}
String[] toks1 = v1.split("\\.");
String[] toks2 = v2.split("\\.");
int i = 0;
for (; i < toks1.length; i++)
{
if (i >= toks2.length)
{
/*
* extra tokens in v1
*/
return 1;
}
String tok1 = toks1[i];
String tok2 = toks2[i];
if (pointSeparator != null)
{
/*
* convert e.g. 5b2 into decimal 5.2 for comparison purposes
*/
tok1 = tok1.replace(pointSeparator, ".");
tok2 = tok2.replace(pointSeparator, ".");
}
try
{
float f1 = Float.valueOf(tok1);
float f2 = Float.valueOf(tok2);
int comp = Float.compare(f1, f2);
if (comp != 0)
{
return comp;
}
} catch (NumberFormatException e)
{
System.err
.println("Invalid version format found: " + e.getMessage());
return 0;
}
}
if (i < toks2.length)
{
/*
* extra tokens in v2
*/
return -1;
}
/*
* same length, all tokens match
*/
return 0;
}
/**
* Converts the string to all lower-case except the first character which is
* upper-cased
*
* @param s
* @return
*/
public static String toSentenceCase(String s)
{
if (s == null)
{
return s;
}
if (s.length() <= 1)
{
return s.toUpperCase(Locale.ROOT);
}
return s.substring(0, 1).toUpperCase(Locale.ROOT)
+ s.substring(1).toLowerCase(Locale.ROOT);
}
/**
* A helper method that strips off any leading or trailing html and body tags.
* If no html tag is found, then also html-encodes angle bracket characters.
*
* @param text
* @return
*/
public static String stripHtmlTags(String text)
{
if (text == null)
{
return null;
}
String tmp2up = text.toUpperCase(Locale.ROOT);
int startTag = tmp2up.indexOf("");
if (startTag > -1)
{
text = text.substring(startTag + 6);
tmp2up = tmp2up.substring(startTag + 6);
}
// is omission of "" intentional here??
int endTag = tmp2up.indexOf("");
if (endTag > -1)
{
text = text.substring(0, endTag);
tmp2up = tmp2up.substring(0, endTag);
}
endTag = tmp2up.indexOf("");
if (endTag > -1)
{
text = text.substring(0, endTag);
}
if (startTag == -1 && (text.contains("<") || text.contains(">")))
{
text = text.replaceAll("<", "<");
text = text.replaceAll(">", ">");
}
return text;
}
/**
* Answers the input string with any occurrences of the 'encodeable'
* characters replaced by their URL encoding
*
* @param s
* @param encodable
* @return
*/
public static String urlEncode(String s, String encodable)
{
if (s == null || s.isEmpty())
{
return s;
}
/*
* do % encoding first, as otherwise it may double-encode!
*/
if (encodable.indexOf(PERCENT) != -1)
{
s = urlEncode(s, PERCENT);
}
for (char c : encodable.toCharArray())
{
if (c != PERCENT)
{
s = urlEncode(s, c);
}
}
return s;
}
/**
* Answers the input string with any occurrences of {@code c} replaced with
* their url encoding. Answers the input string if it is unchanged.
*
* @param s
* @param c
* @return
*/
static String urlEncode(String s, char c)
{
String decoded = String.valueOf(c);
if (s.indexOf(decoded) != -1)
{
String encoded = getUrlEncoding(c);
if (!encoded.equals(decoded))
{
s = s.replace(decoded, encoded);
}
}
return s;
}
/**
* Answers the input string with any occurrences of the specified (unencoded)
* characters replaced by their URL decoding.
*
* Example: {@code urlDecode("a%3Db%3Bc", "-;=,")} should answer
* {@code "a=b;c"}.
*
* @param s
* @param encodable
* @return
*/
public static String urlDecode(String s, String encodable)
{
if (s == null || s.isEmpty())
{
return s;
}
for (char c : encodable.toCharArray())
{
String encoded = getUrlEncoding(c);
if (s.indexOf(encoded) != -1)
{
String decoded = String.valueOf(c);
s = s.replace(encoded, decoded);
}
}
return s;
}
/**
* Does a lazy lookup of the url encoding of the given character, saving the
* value for repeat lookups
*
* @param c
* @return
*/
private static String getUrlEncoding(char c)
{
if (c < 0 || c >= urlEncodings.length)
{
return String.valueOf(c);
}
String enc = urlEncodings[c];
if (enc == null)
{
try
{
enc = urlEncodings[c] = URLEncoder.encode(String.valueOf(c),
"UTF-8");
} catch (UnsupportedEncodingException e)
{
enc = urlEncodings[c] = String.valueOf(c);
}
}
return enc;
}
public static int firstCharPosIgnoreCase(String text, String chars)
{
int min = text.length() + 1;
for (char c : chars.toLowerCase(Locale.ROOT).toCharArray())
{
int i = text.toLowerCase(Locale.ROOT).indexOf(c);
if (0 <= i && i < min)
{
min = i;
}
}
return min < text.length() + 1 ? min : -1;
}
}