/**     * Take a String which is a delimited list and convert it to a String array.     * <p>A single delimiter can consists of more than one character: It will still     * be considered as single delimiter string, rather than as bunch of potential     * delimiter characters - in contrast to {@code tokenizeToStringArray}.     * @param str the input String     * @param delimiter the delimiter between elements (this is a single delimiter,     * rather than a bunch individual delimiter characters)     * @param charsToDelete a set of characters to delete. Useful for deleting unwanted     * line breaks: e.g. "\r\n\f" will delete all new lines and line feeds in a String.     * @return an array of the tokens in the list     * @see #tokenizeToStringArray     */    public static String[] delimitedListToStringArray(String str, String delimiter, String charsToDelete) {        if (str == null) {            return new String[0];        }        if (delimiter == null) {            return new String[] {str};        }        List<String> result = new ArrayList<String>();        if ("".equals(delimiter)) {            for (int i = 0; i < str.length(); i++) {                result.add(deleteAny(str.substring(i, i + 1), charsToDelete));            }        }        else {            int pos = 0;            int delPos;            while ((delPos = str.indexOf(delimiter, pos)) != -1) {                result.add(deleteAny(str.substring(pos, delPos), charsToDelete));                pos = delPos + delimiter.length();            }            if (str.length() > 0 && pos <= str.length()) {                // Add rest of String, but not in case of empty input.                result.add(deleteAny(str.substring(pos), charsToDelete));            }        }        return toStringArray(result);    }        /**     * Copy the given Collection into a String array.     * The Collection must contain String elements only.     * @param collection the Collection to copy     * @return the String array ({@code null} if the passed-in     * Collection was {@code null})     */    public static String[] toStringArray(Collection<String> collection) {        if (collection == null) {            return null;        }        return collection.toArray(new String[collection.size()]);    }        /**     * Delete any character in a given String.     * @param inString the original String     * @param charsToDelete a set of characters to delete.     * E.g. "az\n" will delete ‘a‘s, ‘z‘s and new lines.     * @return the resulting String     */    public static String deleteAny(String inString, String charsToDelete) {        if (!hasLength(inString) || !hasLength(charsToDelete)) {            return inString;        }        StringBuilder sb = new StringBuilder();        for (int i = 0; i < inString.length(); i++) {            char c = inString.charAt(i);            if (charsToDelete.indexOf(c) == -1) {                sb.append(c);            }        }        return sb.toString();    }    /**     * Check that the given String is neither {@code null} nor of length 0.     * Note: Will return {@code true} for a String that purely consists of whitespace.     * @param str the String to check (may be {@code null})     * @return {@code true} if the String is not null and has length     * @see #hasLength(CharSequence)     */    public static boolean hasLength(String str) {        return hasLength((CharSequence) str);    }    /**     * Check that the given CharSequence is neither {@code null} nor of length 0.     * Note: Will return {@code true} for a CharSequence that purely consists of whitespace.     * <p><pre class="code">     * StringUtils.hasLength(null) = false     * StringUtils.hasLength("") = false     * StringUtils.hasLength(" ") = true     * StringUtils.hasLength("Hello") = true     * </pre>     * @param str the CharSequence to check (may be {@code null})     * @return {@code true} if the CharSequence is not null and has length     * @see #hasText(String)     */    public static boolean hasLength(CharSequence str) {        return (str != null && str.length() > 0);    }

    /**     * Tokenize the given String into a String array via a StringTokenizer.     * Trims tokens and omits empty tokens.     * <p>The given delimiters string is supposed to consist of any number of     * delimiter characters. Each of those characters can be used to separate     * tokens. A delimiter is always a single character; for multi-character     * delimiters, consider using {@code delimitedListToStringArray}     * @param str the String to tokenize     * @param delimiters the delimiter characters, assembled as String     * (each of those characters is individually considered as delimiter).     * @return an array of the tokens     * @see java.util.StringTokenizer     * @see String#trim()     * @see #delimitedListToStringArray     */    public static String[] tokenizeToStringArray(String str, String delimiters) {        return tokenizeToStringArray(str, delimiters, true, true);    }    /**     * Tokenize the given String into a String array via a StringTokenizer.     * <p>The given delimiters string is supposed to consist of any number of     * delimiter characters. Each of those characters can be used to separate     * tokens. A delimiter is always a single character; for multi-character     * delimiters, consider using {@code delimitedListToStringArray}     * @param str the String to tokenize     * @param delimiters the delimiter characters, assembled as String     * (each of those characters is individually considered as delimiter)     * @param trimTokens trim the tokens via String‘s {@code trim}     * @param ignoreEmptyTokens omit empty tokens from the result array     * (only applies to tokens that are empty after trimming; StringTokenizer     * will not consider subsequent delimiters as token in the first place).     * @return an array of the tokens ({@code null} if the input String     * was {@code null})     * @see java.util.StringTokenizer     * @see String#trim()     * @see #delimitedListToStringArray     */    public static String[] tokenizeToStringArray(            String str, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens) {        if (str == null) {            return null;        }        StringTokenizer st = new StringTokenizer(str, delimiters);        List<String> tokens = new ArrayList<String>();        while (st.hasMoreTokens()) {            String token = st.nextToken();            if (trimTokens) {                token = token.trim();            }            if (!ignoreEmptyTokens || token.length() > 0) {                tokens.add(token);            }        }        return toStringArray(tokens);    }    /**     * Copy the given Collection into a String array.     * The Collection must contain String elements only.     * @param collection the Collection to copy     * @return the String array ({@code null} if the passed-in     * Collection was {@code null})     */    public static String[] toStringArray(Collection<String> collection) {        if (collection == null) {            return null;        }        return collection.toArray(new String[collection.size()]);    }