Java String Tokenize tokenize(String s, char separator)

Here you can find the source of tokenize(String s, char separator)

  1. HOME
  2. Java
  3. S
  4. String Tokenize
  5. tokenize(String s, char separator)

Description

Split up a string into tokens delimited by the specified separator character.

License

Open Source License

Parameter

Parameter Description
s The String to tokenize
separator The character delimiting tokens

Return

An ArrayList of String tokens, or null is s is null or 0 length.

Declaration 

public static String[] tokenize(String s, char separator)

Method Source Code

//package com.java2s;

import java.util.ArrayList;

public class Main {
    /**/* w ww  .java2s . c  o  m*/
     * The empty String <code>""</code>.
     * @since 2.0
     */
    public static final String EMPTY = "";

    /**
     * Split up a string into tokens delimited by the specified separator
     * character.  If the string is null or zero length, returns null.
     *
     * @param s         The String to tokenize
     * @param separator The character delimiting tokens
     *
     * @return An ArrayList of String tokens, or null is s is null or 0 length.
     */
    public static String[] tokenize(String s, char separator) {
        if (s == null || s.length() == 0) {
            return null;
        }
        int start = 0;
        int stop = 0;
        ArrayList tokens = new ArrayList();
        while (start <= s.length()) {
            stop = s.indexOf(separator, start);
            if (stop == -1) {
                stop = s.length();
            }
            String token = s.substring(start, stop);
            tokens.add(token);
            start = stop + 1;
        }

        return (String[]) tokens.toArray(new String[tokens.size()]);
    }

    /**
     * Gets a String's length or <code>0</code> if the String is <code>null</code>.
     *
     * @param str
     *            a String or <code>null</code>
     * @return String length or <code>0</code> if the String is <code>null</code>.
     * @since 2.4
     */
    public static int length(String str) {
        return str == null ? 0 : str.length();
    }

    /**
     * <p>Finds the first index within a String, handling <code>null</code>.
     * This method uses {@link String#indexOf(int)}.</p>
     *
     * <p>A <code>null</code> or empty ("") String will return <code>-1</code>.</p>
     *
     * <pre>
     * GosuStringUtil.indexOf(null, *)         = -1
     * GosuStringUtil.indexOf("", *)           = -1
     * GosuStringUtil.indexOf("aabaabaa", 'a') = 0
     * GosuStringUtil.indexOf("aabaabaa", 'b') = 2
     * </pre>
     *
     * @param str  the String to check, may be null
     * @param searchChar  the character to find
     * @return the first index of the search character,
     *  -1 if no match or <code>null</code> string input
     * @since 2.0
     */
    public static int indexOf(String str, char searchChar) {
        if (isEmpty(str)) {
            return -1;
        }
        return str.indexOf(searchChar);
    }

    /**
     * <p>Finds the first index within a String from a start position,
     * handling <code>null</code>.
     * This method uses {@link String#indexOf(int, int)}.</p>
     *
     * <p>A <code>null</code> or empty ("") String will return <code>-1</code>.
     * A negative start position is treated as zero.
     * A start position greater than the string length returns <code>-1</code>.</p>
     *
     * <pre>
     * GosuStringUtil.indexOf(null, *, *)          = -1
     * GosuStringUtil.indexOf("", *, *)            = -1
     * GosuStringUtil.indexOf("aabaabaa", 'b', 0)  = 2
     * GosuStringUtil.indexOf("aabaabaa", 'b', 3)  = 5
     * GosuStringUtil.indexOf("aabaabaa", 'b', 9)  = -1
     * GosuStringUtil.indexOf("aabaabaa", 'b', -1) = 2
     * </pre>
     *
     * @param str  the String to check, may be null
     * @param searchChar  the character to find
     * @param startPos  the start position, negative treated as zero
     * @return the first index of the search character,
     *  -1 if no match or <code>null</code> string input
     * @since 2.0
     */
    public static int indexOf(String str, char searchChar, int startPos) {
        if (isEmpty(str)) {
            return -1;
        }
        return str.indexOf(searchChar, startPos);
    }

    /**
     * <p>Finds the first index within a String, handling <code>null</code>.
     * This method uses {@link String#indexOf(String)}.</p>
     *
     * <p>A <code>null</code> String will return <code>-1</code>.</p>
     *
     * <pre>
     * GosuStringUtil.indexOf(null, *)          = -1
     * GosuStringUtil.indexOf(*, null)          = -1
     * GosuStringUtil.indexOf("", "")           = 0
     * GosuStringUtil.indexOf("aabaabaa", "a")  = 0
     * GosuStringUtil.indexOf("aabaabaa", "b")  = 2
     * GosuStringUtil.indexOf("aabaabaa", "ab") = 1
     * GosuStringUtil.indexOf("aabaabaa", "")   = 0
     * </pre>
     *
     * @param str  the String to check, may be null
     * @param searchStr  the String to find, may be null
     * @return the first index of the search String,
     *  -1 if no match or <code>null</code> string input
     * @since 2.0
     */
    public static int indexOf(String str, String searchStr) {
        if (str == null || searchStr == null) {
            return -1;
        }
        return str.indexOf(searchStr);
    }

    /**
     * <p>Finds the first index within a String, handling <code>null</code>.
     * This method uses {@link String#indexOf(String, int)}.</p>
     *
     * <p>A <code>null</code> String will return <code>-1</code>.
     * A negative start position is treated as zero.
     * An empty ("") search String always matches.
     * A start position greater than the string length only matches
     * an empty search String.</p>
     *
     * <pre>
     * GosuStringUtil.indexOf(null, *, *)          = -1
     * GosuStringUtil.indexOf(*, null, *)          = -1
     * GosuStringUtil.indexOf("", "", 0)           = 0
     * GosuStringUtil.indexOf("aabaabaa", "a", 0)  = 0
     * GosuStringUtil.indexOf("aabaabaa", "b", 0)  = 2
     * GosuStringUtil.indexOf("aabaabaa", "ab", 0) = 1
     * GosuStringUtil.indexOf("aabaabaa", "b", 3)  = 5
     * GosuStringUtil.indexOf("aabaabaa", "b", 9)  = -1
     * GosuStringUtil.indexOf("aabaabaa", "b", -1) = 2
     * GosuStringUtil.indexOf("aabaabaa", "", 2)   = 2
     * GosuStringUtil.indexOf("abc", "", 9)        = 3
     * </pre>
     *
     * @param str  the String to check, may be null
     * @param searchStr  the String to find, may be null
     * @param startPos  the start position, negative treated as zero
     * @return the first index of the search String,
     *  -1 if no match or <code>null</code> string input
     * @since 2.0
     */
    public static int indexOf(String str, String searchStr, int startPos) {
        if (str == null || searchStr == null) {
            return -1;
        }
        // JDK1.2/JDK1.3 have a bug, when startPos > str.length for "", hence
        if (searchStr.length() == 0 && startPos >= str.length()) {
            return str.length();
        }
        return str.indexOf(searchStr, startPos);
    }

    /**
     * <p>Gets a substring from the specified String avoiding exceptions.</p>
     *
     * <p>A negative start position can be used to start <code>n</code>
     * characters from the end of the String.</p>
     *
     * <p>A <code>null</code> String will return <code>null</code>.
     * An empty ("") String will return "".</p>
     *
     * <pre>
     * GosuStringUtil.substring(null, *)   = null
     * GosuStringUtil.substring("", *)     = ""
     * GosuStringUtil.substring("abc", 0)  = "abc"
     * GosuStringUtil.substring("abc", 2)  = "c"
     * GosuStringUtil.substring("abc", 4)  = ""
     * GosuStringUtil.substring("abc", -2) = "bc"
     * GosuStringUtil.substring("abc", -4) = "abc"
     * </pre>
     *
     * @param str  the String to get the substring from, may be null
     * @param start  the position to start from, negative means
     *  count back from the end of the String by this many characters
     * @return substring from start position, <code>null</code> if null String input
     */
    public static String substring(String str, int start) {
        if (str == null) {
            return null;
        }

        // handle negatives, which means last n characters
        if (start < 0) {
            start = str.length() + start; // remember start is negative
        }

        if (start < 0) {
            start = 0;
        }
        if (start > str.length()) {
            return EMPTY;
        }

        return str.substring(start);
    }

    /**
     * <p>Gets a substring from the specified String avoiding exceptions.</p>
     *
     * <p>A negative start position can be used to start/end <code>n</code>
     * characters from the end of the String.</p>
     *
     * <p>The returned substring starts with the character in the <code>start</code>
     * position and ends before the <code>end</code> position. All position counting is
     * zero-based -- i.e., to start at the beginning of the string use
     * <code>start = 0</code>. Negative start and end positions can be used to
     * specify offsets relative to the end of the String.</p>
     *
     * <p>If <code>start</code> is not strictly to the left of <code>end</code>, ""
     * is returned.</p>
     *
     * <pre>
     * GosuStringUtil.substring(null, *, *)    = null
     * GosuStringUtil.substring("", * ,  *)    = "";
     * GosuStringUtil.substring("abc", 0, 2)   = "ab"
     * GosuStringUtil.substring("abc", 2, 0)   = ""
     * GosuStringUtil.substring("abc", 2, 4)   = "c"
     * GosuStringUtil.substring("abc", 4, 6)   = ""
     * GosuStringUtil.substring("abc", 2, 2)   = ""
     * GosuStringUtil.substring("abc", -2, -1) = "b"
     * GosuStringUtil.substring("abc", -4, 2)  = "ab"
     * </pre>
     *
     * @param str  the String to get the substring from, may be null
     * @param start  the position to start from, negative means
     *  count back from the end of the String by this many characters
     * @param end  the position to end at (exclusive), negative means
     *  count back from the end of the String by this many characters
     * @return substring from start position to end positon,
     *  <code>null</code> if null String input
     */
    public static String substring(String str, int start, int end) {
        if (str == null) {
            return null;
        }

        // handle negatives
        if (end < 0) {
            end = str.length() + end; // remember end is negative
        }
        if (start < 0) {
            start = str.length() + start; // remember start is negative
        }

        // check length next
        if (end > str.length()) {
            end = str.length();
        }

        // if start is greater than end, return ""
        if (start > end) {
            return EMPTY;
        }

        if (start < 0) {
            start = 0;
        }
        if (end < 0) {
            end = 0;
        }

        return str.substring(start, end);
    }

    /**
     * <p>Checks if a String is empty ("") or null.</p>
     *
     * <pre>
     * StringUtils.isEmpty(null)      = true
     * StringUtils.isEmpty("")        = true
     * StringUtils.isEmpty(" ")       = false
     * StringUtils.isEmpty("bob")     = false
     * StringUtils.isEmpty("  bob  ") = false
     * </pre>
     *
     * <p>NOTE: This method changed in Lang version 2.0.
     * It no longer trims the String.
     * That functionality is available in isBlank().</p>
     *
     * @param str  the String to check, may be null
     * @return <code>true</code> if the String is empty or null
     */
    public static boolean isEmpty(String str) {
        return str == null || str.length() == 0;
    }
}

Related

  1. tokenize(String s)
  2. tokenize(String s)
  3. tokenize(String s)
  4. tokenize(String s)
  5. tokenize(String s)
  6. tokenize(String s, char separator, int maxTokens)
  7. tokenize(String s, char separator, int maxTokens)
  8. tokenize(String s, String delimiters)
  9. tokenize(String s1)