10 Simple String Utility Methods for Java Developer
https://www.fromdev.com/2010/06/10-simple-string-utility-methods-for.html

String operations are common to all kind of programming. Java has many in built operations supported by String class. String functions in java include substring, split, trim and more. However, there are a few more things we do on a regular basis and can be reused. There are few functions which I observed commonly used and may be helpful to keep handy as StringUtil class with static methods.
- Getting Exception Stack Trace to a String value Exceptions class provides a printStackTrace() method which directly prints the Stack Trace to the console. Sometimes you may need to take stack trace to a String variable and use it (e.g. logging using logger), or doing processing on the trace e.g. eclipse shows stack trace and links it to the file and line number. Below is a simple piece of code which demonstrates how we can capture the stack trace inside as String variable. This example utilizes the StringWriter class to convert the stream content to a String.
Merging two String arrays
This is another simple Java String utility method, which can be used to merge two arrays of String values. This takes care of eliminating the duplicates and also does null checking. If you are dealing with multiple String arrays then it could be a useful method. - Trim List of String This is a Collections List equivalent of the trim method for String Array. This can be used to trim all String values in a List of Strings. It takes care of null checking.
- Trim array of String This is another simple but useful Java String Utility/Util method, which can be used to trim all String values in an array of String. This takes care of null checking while doing trim. java.lang.String class contains the trim method which can be used to trim a string from left and right both sides. So for example if you have a string [" This is a String "] then calling a trim() method on this string will convert it to ["This is a String"].
- Unquoting the String This method can be used to unquote a string value. This method takes care of single and double quotes both along with handling the null string. It returns the string as it is when the string is not quoted.
- Extracting File Name from Absolute path Exact file name extraction is required many times when dealing with files. Below is a String utility method, which can be used to extract the exact file name from an absolute path. It uses the File.separatorChar which should take care of all platforms.
- Getting Array/List of tokens from String This method can be used to convert a String separated by delimiter into an array of String.
- Checking Starts/Ends with Ignoring the case The java.lang.String class default implementation has startsWith and endsWith() methods which perform case sensitive comparison, Below are two functions, which can be used to do the same startsWith/endsWith check ignoring the case.
- Converting String to set of Unique tokens This method can be used to create a set of unique string values from a string which has tokens separated by some separator. This is a very useful method when you get the input as comma or space separated string, which has to be converted to a set of values when dealing with each value individually and avoiding duplicates. The code is using StringTokenizer for separating the tokens, so single or multiple separators can be used.
- Masking Null String value There are times when we don't want to deal with null String values, in such cases below utility method can be utilized. This method returns an empty string value in case the string value is null. The same argument of extra method call may come up for this as well, but you may save unwanted NullPointerException in your application by using such a method. I have found this useful at places where we are displaying a field value on the user interface and want to mask the null values with an empty string.
public static String toString(Exception e) { StringWriter s = new StringWriter(); e.printStackTrace(new PrintWriter(s)); return s.toString(); }
/** * This String utility or util method can be used to merge 2 arrays of * string values. If the input arrays are like this array1 = {"a", "b" , * "c"} array2 = {"c", "d", "e"} Then the output array will have {"a", "b" , * "c", "d", "e"} * * This takes care of eliminating duplicates and checks null values. * * @param values * @return */ public static String[] mergeStringArrays(String array1[], String array2[]) { if (array1 == null || array1.length == 0) return array2; if (array2 == null || array2.length == 0) return array1; List array1List = Arrays.asList(array1); List array2List = Arrays.asList(array2); List result = new ArrayList(array1List); List tmp = new ArrayList(array1List); tmp.retainAll(array2List); result.removeAll(tmp); result.addAll(array2List); return ((String[]) result.toArray(new String[result.size()])); }
/** * This String utility or util method can be used to trim all the String * values in list of Strings. For input [" a1 ", "b1 ", " c1"] the output * will be {"a1", "b1", "c1"} Method takes care of null values. This method * is collections equivalent of the trim method for String array. * * @param values * @return */ public static List trim(final List values) { List newValues = new ArrayList(); for (int i = 0, length = values.size(); i < length; i++) { String v = (String) values.get(i); if (v != null) { v = v.trim(); } newValues.add(v); } return newValues; }
/** * This String utility or util method can be used to * trim all the String values in the string array. * For input {" a1 ", "b1 ", " c1"} * the output will be {"a1", "b1", "c1"} * Method takes care of null values. * @param values * @return */ public static String[] trim(final String[] values) { for (int i = 0, length = values.length; i < length; i++) { if (values[i] != null) { values[i] = values[i].trim(); } } return values; }
/** * This String util method removes single or double quotes * from a string if its quoted. * for input string = "mystr1" output will be = mystr1 * for input string = 'mystr2' output will be = mystr2 * * @param String value to be unquoted. * @return value unquoted, null if input is null. * */ public static String unquote(String s) { if (s != null && ((s.startsWith("\"") && s.endsWith("\"")) || (s.startsWith("'") && s.endsWith("'")))) { s = s.substring(1, s.length() - 1); } return s; } /** * Same method as above but using the ?: syntax which is shorter. You can use whichever you prefer. * This String util method removes single or double quotes from a string if * its quoted. for input string = "mystr1" output will be = mystr1 for input * * string = 'mystr2' output will be = mystr2 * * @param String * value to be unquoted. * @return value unquoted, null if input is null. * */ public static String unquote2(String s) { return (s != null && ((s.startsWith("\"") && s.endsWith("\"")) || (s .startsWith("'") && s.endsWith("'")))) ? s = s.substring(1, s .length() - 1) : s; }
/** * This method extracts the file name from absolute path of file * As an example : ** ** * @param absoluteFileName File name with path * @return FileName minus the path */ public static String extractFileName(String absoluteFileName) { if (!isNullOrEmpty(absoluteFileName)) { absoluteFileName = absoluteFileName.substring(absoluteFileName .lastIndexOf(File.separatorChar) + 1, absoluteFileName.lastIndexOf(".")); } return absoluteFileName; }
* For an input "c:\myDir\MyFile.java" * The output will be : "MyFile" ** *
/** * This method is used to split the given string into different tokens at * the occurrence of specified delimiter * An example : *A better and simpler/improved version of the same method is suggested by one of the readers and the code looks like this."abcdzefghizlmnop"
and using a delimiter"z"
* would give following output *"abcd" "efghi" "lmnop"
* * @param str The string that needs to be broken * @param delimeter The delimiter used to break the string * @return a string array */ public static String[] getTokensArray(String str, String delimeter) { String[] data; if(str == null){ return null; } if (delimeter == null || "".equals(delimeter) || "".equals(str)) { data = new String[1]; data[0] = str; return data; } else { StringTokenizer st = new StringTokenizer(str, delimeter); int tokenCount = st.countTokens(); data = new String[tokenCount]; for (int i = 0; st.hasMoreTokens(); i++) { data[i] = st.nextToken(); } return data; } }
/** * This method is used to split the given string into different tokens at * the occurrence of specified delimiter * An example : *Another variation for the same method is for getting a java.util.List instead of an array of objects. This can be easily done using small change to the above method"abcdzefghizlmnop"
and using a delimiter"z"
* would give following output *"abcd" "efghi" "lmnop"
* * @param str The string that needs to be broken * @param delimeter The delimiter used to break the string * @return a string array */ public static String[] getTokensArray(String str, String delimeter) { if (str != null) { return str.split(delimeter); } return null; }
/** * This method is used to split the given string into different tokens at * the occurrence of specified delimiter * An example : *"abcdzefghizlmnop"
and using a delimiter"z"
* would give following output *"abcd" "efghi" "lmnop"
* * @param str The string that needs to be broken * @param delimeter The delimiter used to break the string * @return a instance of java.util.Listwith each token as one item in list */ public static List getTokensList(String str, String delimeter) { if (str != null) { return Arrays.asList(str.split(delimeter)); } return new ArrayList (); }
/** * Check a String ends with another string ignoring the case. * * @param str * @param suffix * @return */ public static boolean endsWithIgnoreCase(String str, String suffix) { if (str == null || suffix == null) { return false; } if (str.endsWith(suffix)) { return true; } if (str.length() < suffix.length()) { return false; } else { return str.toLowerCase().endsWith(suffix.toLowerCase()); } } /** * Check a String starts with another string ignoring the case. * * @param str * @param prefix * @return */ public static boolean startsWithIgnoreCase(String str, String prefix) { if (str == null || prefix == null) { return false; } if (str.startsWith(prefix)) { return true; } if (str.length() < prefix.length()) { return false; } else { return str.toLowerCase().startsWith(prefix.toLowerCase()); } }
/** * This method creates a set of unique string tokens which are separated by * separator * * @param str * @param separator * @return */ public static Set getUniqueTokens(String str, String separator) { StringTokenizer tokenizer = new StringTokenizer(str, separator); Set tokens = new HashSet(); while (tokenizer.hasMoreTokens()) { tokens.add(tokenizer.nextToken()); } return tokens; }Another way of writing the same method is (suggested by a reader in the comments section) is using the String.split() method. Below is the code for same
/** * This method creates a set of unique string tokens which are separated by * separator * * @param str * @param separator * @return */ public static Set getUniqueTokens(String str, String separator) { String [] tmpStr = str.split(separator); return new HashSet(Arrays.asList(tmpStr)); }
/** * Return a not null string. * * @param s String * @return empty string if it is null otherwise the string passed in as * parameter. */ public static String nonNull(String s) { if (s == null) { return ""; } return s; }
Article Updates
- Updated in April 2019: Minor changes and updates to the introduction section. Images are updated to HTTPS.