Java String Util Class
Unfortunately, Java does not include a proper String manipulation class in its Java SE SDK. I really do not understand why… However, we see so many implementations and libraries including the distinguished Apache Commons Lang and android.text package. If your project faces a string war (war is hell!) you have to add dependencies or create your own class!
So today I wrote down a simple String utility class with common methods which has no external dependencies. As you can see some methods are borrowed from apache.commons.lang and android.text. I hope you find it useful! Update 2013-05-02: Added join methods
/**
* A utility class which contains common and useful String manipulation methods.
* Wrap and Join methods are taken from <a href=
* "http://commons.apache.org/lang/api-2.6/org/apache/commons/lang/WordUtils.html"
* >org.apache.commons.lang.WordUtils</a>
* <p>
* isEmpty() method is taken from <a
* href="http://developer.android.com/reference/android/text/TextUtils.html"
* >android.text.TextUtils</a>
*
*/
public class StringUtils {
/**
* Returns true if the string is null or 0-length.
*
* @param str
* the string to be examined
* @return true if str is null or zero length
*/
public static boolean isEmpty(CharSequence str) {
if (str == null || str.length() == 0)
return true;
else
return false;
}
/**
* Replaces a null String with an empty string ("")
*
* @param str
* source string
*/
public static String replaceNullWithEmpty(String str) {
return isEmpty(str) ? "" : str;
}
/**
* Replaces an empty string ("") with null
*
* @param str
* source string
*/
public static String replaceEmptyWithNull(String str) {
return isEmpty(str) ? null : str;
}
/**
* Truncates s to fit within len. If s is an empty string, it will return an
* empty string. If s is null, null is returned.
*
* @param s
* source string
* @param len
* number of characters we want
**/
public static String truncate(String s, int len) {
if (s == null) {
return null;
}
if (s.equals("")) {
return "";
}
return s.substring(0, Math.min(len, s.length()));
}
/**
* <p>
* Wraps a single line of text, identifying words by <code>' '</code>.
* </p>
*
* <p>
* New lines will be separated by the system property line separator. Very
* long words, such as URLs will <i>not</i> be wrapped.
* </p>
*
* <p>
* Leading spaces on a new line are stripped. Trailing spaces are not
* stripped.
* </p>
*
* <pre>
* StringUtils.wrap(null, *) = null
* StringUtils.wrap("", *) = ""
* </pre>
*
* This method is a copy of org.apache.commons.lang.WordUtils.wrap() method
*
* @param str
* the String to be word wrapped, may be null
* @param wrapLength
* the column to wrap the words at, less than 1 is treated as 1
* @return a line with newlines inserted, <code>null</code> if null input
*/
public static String wrap(String str, int wrapLength) {
return wrap(str, wrapLength, null, false);
}
/**
* <p>
* Wraps a single line of text, identifying words by <code>' '</code>.
* </p>
*
* <p>
* Leading spaces on a new line are stripped. Trailing spaces are not
* stripped.
* </p>
*
* <pre>
* StringUtils.wrap(null, *, *, *) = null
* StringUtils.wrap("", *, *, *) = ""
* </pre>
*
* This method is a copy of org.apache.commons.lang.WordUtils.wrap() method
*
* @param str
* the String to be word wrapped, may be null
* @param wrapLength
* the column to wrap the words at, less than 1 is treated as 1
* @param newLineStr
* the string to insert for a new line, <code>null</code> uses
* the system property line separator
* @param wrapLongWords
* true if long words (such as URLs) should be wrapped
* @return a line with newlines inserted, <code>null</code> if null input
*/
public static String wrap(String str, int wrapLength, String newLineStr,
boolean wrapLongWords) {
if (str == null) {
return null;
}
if (newLineStr == null) {
newLineStr = "\n";
}
if (wrapLength < 1) {
wrapLength = 1;
}
int inputLineLength = str.length();
int offset = 0;
StringBuffer wrappedLine = new StringBuffer(inputLineLength + 32);
while ((inputLineLength - offset) > wrapLength) {
if (str.charAt(offset) == ' ') {
offset++;
continue;
}
int spaceToWrapAt = str.lastIndexOf(' ', wrapLength + offset);
if (spaceToWrapAt >= offset) {
// normal case
wrappedLine.append(str.substring(offset, spaceToWrapAt));
wrappedLine.append(newLineStr);
offset = spaceToWrapAt + 1;
} else {
// really long word or URL
if (wrapLongWords) {
// wrap really long word one line at a time
wrappedLine.append(str.substring(offset, wrapLength
+ offset));
wrappedLine.append(newLineStr);
offset += wrapLength;
} else {
// do not wrap really long word, just extend beyond limit
spaceToWrapAt = str.indexOf(' ', wrapLength + offset);
if (spaceToWrapAt >= 0) {
wrappedLine
.append(str.substring(offset, spaceToWrapAt));
wrappedLine.append(newLineStr);
offset = spaceToWrapAt + 1;
} else {
wrappedLine.append(str.substring(offset));
offset = inputLineLength;
}
}
}
}
// Whatever is left in line is short enough to just pass through
wrappedLine.append(str.substring(offset));
return wrappedLine.toString();
}
/**
* <p>
* Joins the elements of the provided array into a single String containing
* the provided list of elements.
* </p>
*
* <p>
* No delimiter is added before or after the list. Null objects or empty
* strings within the array are represented by empty strings.
* </p>
*
* <pre>
* StringUtils.join(null, *) = null
* StringUtils.join([], *) = ""
* StringUtils.join([null], *) = ""
* StringUtils.join(["a", "b", "c"], ';') = "a;b;c"
* StringUtils.join(["a", "b", "c"], null) = "abc"
* StringUtils.join([null, "", "a"], ';') = ";;a"
* </pre>
*
* @param array
* the array of values to join together, may be null
* @param separator
* the separator character to use
* @return the joined String, <code>null</code> if null array input
* @since 2.0
*/
public static String join(long[] array, char separator) {
if (array == null) {
return null;
}
return join(array, separator, 0, array.length);
}
/**
* <p>
* Joins the elements of the provided array into a single String containing
* the provided list of elements.
* </p>
*
* <p>
* No delimiter is added before or after the list. Null objects or empty
* strings within the array are represented by empty strings.
* </p>
*
* <pre>
* StringUtils.join(null, *) = null
* StringUtils.join([], *) = ""
* StringUtils.join([null], *) = ""
* StringUtils.join(["a", "b", "c"], ';') = "a;b;c"
* StringUtils.join(["a", "b", "c"], null) = "abc"
* StringUtils.join([null, "", "a"], ';') = ";;a"
* </pre>
*
* @param array
* the array of values to join together, may be null
* @param separator
* the separator character to use
* @param startIndex
* the first index to start joining from. It is an error to pass
* in an end index past the end of the array
* @param endIndex
* the index to stop joining from (exclusive). It is an error to
* pass in an end index past the end of the array
* @return the joined String, <code>null</code> if null array input
* @since 2.0
*/
public static String join(long[] array, char separator, int startIndex,
int endIndex) {
if (array == null) {
return null;
}
int bufSize = (endIndex - startIndex);
if (bufSize <= 0) {
return "";
}
StringBuffer buf = new StringBuffer(bufSize);
for (int i = startIndex; i < endIndex; i++) {
if (i > startIndex) {
buf.append(separator);
}
buf.append(array[i]);
}
return buf.toString();
}
/**
* <p>
* Joins the elements of the provided array into a single String containing
* the provided list of elements.
* </p>
*
* <p>
* No delimiter is added before or after the list. Null objects or empty
* strings within the array are represented by empty strings.
* </p>
*
* <pre>
* StringUtils.join(null, *) = null
* StringUtils.join([], *) = ""
* StringUtils.join([null], *) = ""
* StringUtils.join(["a", "b", "c"], ';') = "a;b;c"
* StringUtils.join(["a", "b", "c"], null) = "abc"
* StringUtils.join([null, "", "a"], ';') = ";;a"
* </pre>
*
* @param array
* the array of values to join together, may be null
* @param separator
* the separator character to use
* @return the joined String, <code>null</code> if null array input
* @since 2.0
*/
public static String join(Object[] array, char separator) {
if (array == null) {
return null;
}
return join(array, separator, 0, array.length);
}
/**
* <p>
* Joins the elements of the provided array into a single String containing
* the provided list of elements.
* </p>
*
* <p>
* No delimiter is added before or after the list. Null objects or empty
* strings within the array are represented by empty strings.
* </p>
*
* <pre>
* StringUtils.join(null, *) = null
* StringUtils.join([], *) = ""
* StringUtils.join([null], *) = ""
* StringUtils.join(["a", "b", "c"], ';') = "a;b;c"
* StringUtils.join(["a", "b", "c"], null) = "abc"
* StringUtils.join([null, "", "a"], ';') = ";;a"
* </pre>
*
* @param array
* the array of values to join together, may be null
* @param separator
* the separator character to use
* @param startIndex
* the first index to start joining from. It is an error to pass
* in an end index past the end of the array
* @param endIndex
* the index to stop joining from (exclusive). It is an error to
* pass in an end index past the end of the array
* @return the joined String, <code>null</code> if null array input
* @since 2.0
*/
public static String join(Object[] array, char separator, int startIndex,
int endIndex) {
if (array == null) {
return null;
}
int bufSize = (endIndex - startIndex);
if (bufSize <= 0) {
return "";
}
bufSize *= ((array[startIndex] == null ? 16 : array[startIndex]
.toString().length()) + 1);
StringBuffer buf = new StringBuffer(bufSize);
for (int i = startIndex; i < endIndex; i++) {
if (i > startIndex) {
buf.append(separator);
}
if (array[i] != null) {
buf.append(array[i]);
}
}
return buf.toString();
}
}
Comments