public CSVTokenizer(String aString) 
{
    this(aString, CSVTokenizer.SEPARATOR_COMMA);
}

Constructs a string tokenizer for the specified string. The tokenizer uses the default separator set, which is CSVTokenizer.SEPARATOR_COMMA. Separator string themselves will not be treated as tokens.

Parameters:

aString - a string to be parsed.

 public CSVTokenizer(String aString,
    String theSeparator) 
{
    this(aString, theSeparator, CSVTokenizer.DOUBLE_QUATE);
}

Constructs a csv tokenizer for the specified string. The characters in the theSeparator argument are the separator for separating tokens. Separator string themselves will not be treated as tokens.

Parameters:

aString - a string to be parsed.

theSeparator - the separator (CSVTokenizer.SEPARATOR_COMMA, CSVTokenizer.TAB, CSVTokenizer.SPACE, etc.).

 public CSVTokenizer(String aString,
    String theSeparator,
    String theQuate) 
{
                                                                                           
    if (aString == null)
    {
      throw new NullPointerException("The given string is null");
    }
    if (theSeparator == null)
    {
      throw new NullPointerException("The given separator is null");
    }
    if (theQuate == null)
    {
      throw new NullPointerException("The given quate is null");
    }
    this.record = aString.trim();
    this.separator = theSeparator;
    this.quate = theQuate;
    this.currentIndex = 0;
    this.beforeStart = true;
}

Constructs a csv tokenizer for the specified string. theSeparator argument is the separator for separating tokens.

If the returnSeparators flag is true, then the separator string is also returned as tokens. separator is returned as a string. If the flag is false, the separator string is skipped and only serve as separator between tokens.

Parameters:

aString - a string to be parsed.

theSeparator - the separator (CSVTokenizer.SEPARATOR_COMMA, CSVTokenizer.TAB, CSVTokenizer.SPACE, etc.).

theQuate - the quate (CSVTokenizer.SINGLE_QUATE, CSVTokenizer.DOUBLE_QUATE, etc.).

 public int countTokens() 
{
    int count = 0;
    final int preserve = this.currentIndex;
    final boolean preserveStart = this.beforeStart;
    while (this.hasMoreTokens())
    {
      this.nextToken();
      count++;
    }
    this.currentIndex = preserve;
    this.beforeStart = preserveStart;
    return count;
}

Calculates the number of times that this tokenizer's nextToken method can be called before it generates an exception. The current position is not advanced.

 public String getQuate() 
{
    return this.quate;
}

Returns the quate.

 public boolean hasMoreElements() 
{
    return hasMoreTokens();
}

Returns the same value as the hasMoreTokens method. It exists so that this class can implement the Enumeration interface.

 public boolean hasMoreTokens() 
{
    return (this.currentIndex <  this.record.length());
}

Tests if there are more tokens available from this tokenizer's string. If this method returns true, then a subsequent call to nextToken with no argument will successfully return a token.

 public Object nextElement() 
{
    return nextToken();
}

Returns the same value as the nextToken method, except that its declared return value is Object rather than String. It exists so that this class can implement the Enumeration interface.

 public String nextToken() throws IllegalArgumentException, NoSuchElementException 
{
    if (!this.hasMoreTokens())
    {
      throw new NoSuchElementException();
    }
    if (beforeStart == false)
    {
      currentIndex += this.separator.length();
    }
    else
    {
      beforeStart = false;
    }
    if (this.record.startsWith(this.quate, this.currentIndex))
    {
      final StringBuffer token = new StringBuffer(100);
      String rec = this.record.substring(this.currentIndex + this.quate.length());
      while (true)
      {
        final int end = rec.indexOf(this.quate);
        if (end <  0)
        {
          throw new IllegalArgumentException("Illegal format");
        }
        if (!rec.startsWith(this.quate, end + 1))
        {
          token.append(rec.substring(0, end));
          break;
        }
        token.append(rec.substring(0, end + 1));
        rec = rec.substring(end + this.quate.length() * 2);
        this.currentIndex++;
      }
      this.currentIndex += (token.length() + this.quate.length() * 2);
      return token.toString();
    }
    final int end = this.record.indexOf(this.separator, this.currentIndex);
    if (end  >= 0)
    {
      final int start = this.currentIndex;
      final String token = this.record.substring(start, end);
      this.currentIndex = end;
      return token;
    }
    else
    {
      final int start = this.currentIndex;
      final String token = this.record.substring(start);
      this.currentIndex = this.record.length();
      return token;
    }
}

Returns the next token from this string tokenizer.

 public String nextToken(String theSeparator) 
{
    separator = theSeparator;
    return nextToken();
}

Returns the next token in this string tokenizer's string. First, the set of characters considered to be separator by this CSVTokenizer object is changed to be the characters in the string separator. Then the next token in the string after the current position is returned. The current position is advanced beyond the recognized token. The new delimiter set remains the default after this call.

 public  void setQuate(String quate) 
{
    this.quate = quate;
}

Sets the quate.