SimpleScanner

java.lang.Object
- acm.io.SimpleScanner

```
public final class SimpleScanner
extends Object
```
A simple text scanner which can parse primitive types and strings using regular expressions.
A Scanner breaks its input into tokens using a delimiter pattern, which by default matches whitespace. The resulting tokens may then be converted into values of different types using the various next methods.
This class is based on a subset of the functionality of Sun's java.util.Scanner class from J2SE v1.5.0, with some code borrowed from the TextReader class written by Stuart Reges of the University of Washington. It should work with 'lazy input' from the keyboard as needed.
Some notable differences from java.util.Scanner are the following:
- All Java 5-specific features, such as implementing Iterator < String > and the public MatchResult match() method, are missing.
- The useLocale, findInLine, and findInHorizon methods are not implemented and throw an UnsupportedOperationException when called.
- This implementation is not guaranteed to exactly match the parsing behavior of java.util.Scanner for complex cases. The java.util.Scanner uses sophisticated delimiting between tokens of input; this Scanner simply tokenizes on whitespace. Also, for example, this implementation returns true on a call to hasNextFloat() if the upcoming input token is "2.1F", because this implementation's parsing is based on the primitive wrappers; java.util.Scanner would return false in this same case.
- The toString text, exception text and exception-throwing behavior is not guaranteed to match that of java.util.Scanner. In particular, this implementation includes the offending input line number in its NoSuchElementException text to aid debugging.
- This implementation is slower than java.util.Scanner, partly because it does not directly cache input or regular expression patterns for simplicity. Since this class is a holdover implementation until widespread adoption of Java 5, this was deemed acceptable.
Recent changes:
- 2011-12-05: Fixed bug with scanner.reuse property and System.setIn.
- 2008-02-27: Fixed bugs: next() w/ trailing spaces; multiple System.in Scanners
- 2007-08-13: Fixed hasNextLine bug where last line doesn't have a trailing \n .
- 2007-07-27: Added -Dscanner.workingdir=DIR option for Grade-It.
- 2007-07-18: More hanging input bug fixes for Grade-It system.
- 2007-07-15: Fixed various input bugs (used to hang after waiting for input).
- - 2006-09-18: Added support for multiple Scanners reading the same underlying input stream without problems (useful for CSE 14x grading scripts). Example:
```
 % java -Dscanner.reuse=1 MyProgramThatUsesScanner

 
```
  - 2005-07-30: Added support for regular expressions, delimiter, hasNext(Pattern), next(Pattern), useDelimiter, and skip(Pattern).
  - 2005-07-12: Added better error messages when wrong token type is read. The goal is for CS1 students to be able to more easily find their mistakes. Added support for command-line flag -Dscanner.echo=1 flag so that the Scanner can be made to echo stdin when it is being redirected in from a file. Example:
```
 % java -Dscanner.echo=1 MyProgramThatUsesScanner < input.txt

 
```
  - 2005-01-22: Fixed a bug where nextLine returned an empty string rather than throwing an exception when no more input was available.
  - 2005-01-01: Renamed all private methods with underscores because students were discovering the private hasNextChar method and trying to use it in their programs.

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`SCANNER_APPLET_MODE_PROPERTY_NAME`
`static String`	`SCANNER_ECHO_PROPERTY_NAME`
`static String`	`SCANNER_REUSE_PROPERTY_NAME`
`static String`	`SCANNER_WORKING_DIR_PROPERTY_NAME`

Constructor Summary

Constructors
Constructor and Description
`SimpleScanner(File source)` Constructs a new Scanner that produces values scanned from the specified file.
`SimpleScanner(InputStream source)` Constructs a new Scanner that produces values scanned from the specified input stream.
`SimpleScanner(Reader source)` Constructs a new Scanner that produces values scanned from the specified source.
`SimpleScanner(String source)` Constructs a new Scanner that produces values scanned from the specified string.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`clearCache()`
`void`	`close()` Closes this scanner.
`Pattern`	`delimiter()` Returns the Pattern this Scanner is currently using to match delimiters.
`String`	`findInLine(Pattern pattern)` Attempts to find the next occurrence of the specified pattern ignoring delimiters.
`String`	`findInLine(String pattern)` Attempts to find the next occurrence of a pattern constructed from the specified string, ignoring delimiters.
`String`	`findWithinHorizon(Pattern pattern, int horizon)` Attempts to find the next occurrence of the specified pattern.
`String`	`findWithinHorizon(String pattern, int horizon)` Attempts to find the next occurrence of a pattern constructed from the specified string, ignoring delimiters.
`static boolean`	`getAppletMode()`
`static boolean`	`getEcho()`
`static boolean`	`getReuse()`
`static String`	`getWorkingDir()`
`boolean`	`hasNext()` Returns true if this scanner has another token in its input.
`boolean`	`hasNext(Pattern pattern)` Returns true if the next complete token matches the specified pattern.
`boolean`	`hasNext(String pattern)` Returns the next token if it matches the pattern constructed from the specified string.
`boolean`	`hasNextBigDecimal()` Returns true if the next token in this scanner's input can be interpreted as a BigDecimal using the nextBigDecimal() method.
`boolean`	`hasNextBigInteger()` Returns true if the next token in this scanner's input can be interpreted as a BigInteger in the default radix using the nextBigInteger() method.
`boolean`	`hasNextBigInteger(int radix)` Returns true if the next token in this scanner's input can be interpreted as a BigInteger in the specified radix using the nextBigInteger() method.
`boolean`	`hasNextBoolean()` Returns true if the next token in this scanner's input can be interpreted as a boolean value.
`boolean`	`hasNextByte()` Returns true if the next token in this scanner's input can be interpreted as a byte value in the default radix using the nextByte() method.
`boolean`	`hasNextByte(int radix)` Returns true if the next token in this scanner's input can be interpreted as a byte value in the specified radix using the nextByte() method.
`boolean`	`hasNextDouble()` Returns true if the next token in this scanner's input can be interpreted as a double value using the nextDouble() method.
`boolean`	`hasNextFloat()` Returns true if the next token in this scanner's input can be interpreted as a float value using the nextFloat() method.
`boolean`	`hasNextInt()` Returns true if the next token in this scanner's input can be interpreted as an int value in the default radix using the nextInt() method.
`boolean`	`hasNextInt(int radix)` Returns true if the next token in this scanner's input can be interpreted as an int value in the specified radix using the nextInt() method.
`boolean`	`hasNextLine()` Returns true if there is another line in the input of this scanner.
`boolean`	`hasNextLong()` Returns true if the next token in this scanner's input can be interpreted as a long value in the default radix using the nextLong() method.
`boolean`	`hasNextLong(int radix)` Returns true if the next token in this scanner's input can be interpreted as a long value in the specified radix using the nextLong() method.
`boolean`	`hasNextShort()` Returns true if the next token in this scanner's input can be interpreted as a short value in the default radix using the nextShort() method.
`boolean`	`hasNextShort(int radix)` Returns true if the next token in this scanner's input can be interpreted as a short value in the specified radix using the nextShort() method.
`IOException`	`ioException()` Returns the IOException last thrown by this Scanner.
`Locale`	`locale()` Returns this scanner's locale.
`String`	`next()` Finds and returns the next complete token from this scanner.
`String`	`next(Pattern pattern)` Returns the next token if it matches the specified pattern.
`String`	`next(String pattern)` Returns the next token if it matches the pattern constructed from the specified string.
`BigDecimal`	`nextBigDecimal()` Scans the next token of the input as a BigDecimal.
`BigInteger`	`nextBigInteger()` Scans the next token of the input as a BigInteger.
`BigInteger`	`nextBigInteger(int radix)` Scans the next token of the input as a BigInteger.
`boolean`	`nextBoolean()` Scans the next token of the input into a boolean value and returns that value.
`byte`	`nextByte()` Scans the next token of the input as a byte.
`byte`	`nextByte(int radix)` Scans the next token of the input as a byte.
`double`	`nextDouble()` Scans the next token of the input as a double.
`float`	`nextFloat()` Scans the next token of the input as a float.
`int`	`nextInt()` Scans the next token of the input as an int.
`int`	`nextInt(int radix)` Scans the next token of the input as an int.
`String`	`nextLine()` Advances this scanner past the current line and returns the input that was skipped.
`long`	`nextLong()` Scans the next token of the input as a long.
`long`	`nextLong(int radix)` Scans the next token of the input as a long.
`short`	`nextShort()` Scans the next token of the input as a short.
`short`	`nextShort(int radix)` Scans the next token of the input as a short.
`int`	`radix()` Returns this scanner's default radix.
`void`	`remove()` The remove operation is not supported by this implementation of Iterator.
`static void`	`setAppletMode(boolean value)`
`static void`	`setEcho(boolean value)`
`void`	`setEchoForce(boolean value)`
`void`	`setEchoStream(PrintStream stream)`
`static void`	`setReuse(boolean value)`
`static void`	`setWorkingDir(String value)`
`SimpleScanner`	`skip(Pattern pattern)` Skips input that matches the specified pattern, ignoring delimiters.
`SimpleScanner`	`skip(String pattern)` Skips input that matches a pattern constructed from the specified string.
`String`	`toString()` Returns the string representation of this Scanner.
`SimpleScanner`	`useDelimiter(Pattern pattern)` Sets this scanner's delimiting pattern to the specified pattern.
`SimpleScanner`	`useDelimiter(String pattern)` Sets this scanner's delimiting pattern to a pattern constructed from the specified String.
`SimpleScanner`	`useLocale(Locale locale)` Sets this scanner's locale to the specified locale.
`SimpleScanner`	`useRadix(int radix)` Sets this scanner's default radix to the specified radix.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - SCANNER_APPLET_MODE_PROPERTY_NAME
```
public static final String SCANNER_APPLET_MODE_PROPERTY_NAME
```
    See Also:
    
    Constant Field Values
  - SCANNER_ECHO_PROPERTY_NAME
```
public static final String SCANNER_ECHO_PROPERTY_NAME
```
    See Also:
    
    Constant Field Values
  - SCANNER_REUSE_PROPERTY_NAME
```
public static final String SCANNER_REUSE_PROPERTY_NAME
```
    See Also:
    
    Constant Field Values
  - SCANNER_WORKING_DIR_PROPERTY_NAME
```
public static final String SCANNER_WORKING_DIR_PROPERTY_NAME
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - SimpleScanner
```
public SimpleScanner(File source)
```
    Constructs a new Scanner that produces values scanned from the specified file. Bytes from the file are converted into characters using the underlying platform's default charset.
    
    Parameters:
    
    source - A file to be scanned
    
    Throws:
    
    IORuntimeException - if source is not found or cannot be read
  - SimpleScanner
```
public SimpleScanner(InputStream source)
```
    Constructs a new Scanner that produces values scanned from the specified input stream. Bytes from the stream are converted into characters using the underlying platform's default charset.
    
    Parameters:
    
    source - An input stream to be scanned
  - SimpleScanner
```
public SimpleScanner(Reader source)
```
    Constructs a new Scanner that produces values scanned from the specified source.
    
    Parameters:
    
    source - A character source to scan
  - SimpleScanner
```
public SimpleScanner(String source)
```
    Constructs a new Scanner that produces values scanned from the specified string.
    
    Parameters:
    
    source - A string to scan
- Method Detail
  - clearCache
```
public static void clearCache()
```
  - getEcho
```
public static boolean getEcho()
```
  - getAppletMode
```
public static boolean getAppletMode()
```
  - getReuse
```
public static boolean getReuse()
```
  - getWorkingDir
```
public static String getWorkingDir()
```
  - setAppletMode
```
public static void setAppletMode(boolean value)
```
  - setEcho
```
public static void setEcho(boolean value)
```
  - setReuse
```
public static void setReuse(boolean value)
```
  - setWorkingDir
```
public static void setWorkingDir(String value)
```
  - close
```
public void close()
```
    Closes this scanner.
    If this scanner is already closed then invoking this method will have no effect.
  - delimiter
```
public Pattern delimiter()
```
    Returns the Pattern this Scanner is currently using to match delimiters.
    
    Returns:
    
    this scanner's delimiting pattern.
  - findWithinHorizon
```
public String findWithinHorizon(Pattern pattern,
                                int horizon)
```
    Attempts to find the next occurrence of the specified pattern. This method searches through the input up to the specified search horizon, ignoring delimiters. If the pattern is found the scanner advances past the input that matched and returns the string that matched the pattern. If no such pattern is detected then the null is returned and the scanner's position remains unchanged. This method may block waiting for input that matches the pattern. A scanner will never search more than horizon code points beyond its current position. Note that a match may be clipped by the horizon; that is, an arbitrary match result may have been different if the horizon had been larger. The scanner treats the horizon as a transparent, non-anchoring bound. If horizon is 0, then the horizon is ignored and this method continues to search through the input looking for the specified pattern without bound. In this case it may buffer all of the input searching for the pattern. If horizon is negative, then an IllegalArgumentException is thrown.
    
    Parameters:
    
    pattern - the pattern to scan for
    
    Returns:
    
    the text that matched the specified pattern
    
    Throws:
    
    IllegalStateException - if this scanner is closed
    
    IllegalArgumentException - if horizon is negative
  - findWithinHorizon
```
public String findWithinHorizon(String pattern,
                                int horizon)
```
    Attempts to find the next occurrence of a pattern constructed from the specified string, ignoring delimiters. An invocation of this method of the form findWithinHorizon(pattern) behaves in exactly the same way as the invocation findWithinHorizon(Pattern.compile(pattern, horizon)).
    
    Parameters:
    
    pattern - a string specifying the pattern to search for
    
    Returns:
    
    the text that matched the specified pattern
    
    Throws:
    
    IllegalStateException - if this scanner is closed
    
    IllegalArgumentException - if horizon is negative
  - findInLine
```
public String findInLine(Pattern pattern)
```
    Attempts to find the next occurrence of the specified pattern ignoring delimiters. If the pattern is found before the next line separator, the scanner advances past the input that matched and returns the string that matched the pattern. If no such pattern is detected in the input up to the next line separator, then null is returned and the scanner's position is unchanged. This method may block waiting for input that matches the pattern. Since this method continues to search through the input looking for the specified pattern, it may buffer all of the input searching for the desired token if no line separators are present.
    
    Parameters:
    
    pattern - the pattern to scan for
    
    Returns:
    
    the text that matched the specified pattern
    
    Throws:
    
    IllegalStateException - - if this scanner is closed
  - findInLine
```
public String findInLine(String pattern)
```
    Attempts to find the next occurrence of a pattern constructed from the specified string, ignoring delimiters. An invocation of this method of the form findInLine(pattern) behaves in exactly the same way as the invocation findInLine(Pattern.compile(pattern)).
    
    Parameters:
    
    pattern - a string specifying the pattern to search for
    
    Returns:
    
    the text that matched the specified pattern
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNext
```
public boolean hasNext()
```
    Returns true if this scanner has another token in its input. This method may block while waiting for input to scan. The scanner does not advance past any input.
    
    Returns:
    
    true if and only if this scanner has another token
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNext
```
public boolean hasNext(Pattern pattern)
```
    Returns true if the next complete token matches the specified pattern. A complete token is prefixed and postfixed by input that matches the delimiter pattern. This method may block while waiting for input. The scanner does not advance past any input.
    
    Parameters:
    
    pattern - the pattern to scan for
    
    Returns:
    
    true if and only if this scanner has another token matching the specified pattern
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNext
```
public boolean hasNext(String pattern)
```
    Returns the next token if it matches the pattern constructed from the specified string. If the match is successful, the scanner advances past the input that matched the pattern. An invocation of this method of the form next(pattern) behaves in exactly the same way as the invocation next(Pattern.compile(pattern)).
    
    Parameters:
    
    pattern - a string specifying the pattern to scan
    
    Returns:
    
    the next token
    
    Throws:
    
    NoSuchElementException - if no such tokens are available
    
    IllegalStateException - if this scanner is closed
  - hasNextBigDecimal
```
public boolean hasNextBigDecimal()
```
    Returns true if the next token in this scanner's input can be interpreted as a BigDecimal using the nextBigDecimal() method. The scanner does not advance past any input.
    
    Returns:
    
    true if and only if this scanner's next token is a valid BigDecimal
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextBigInteger
```
public boolean hasNextBigInteger()
```
    Returns true if the next token in this scanner's input can be interpreted as a BigInteger in the default radix using the nextBigInteger() method. The scanner does not advance past any input.
    
    Returns:
    
    true if and only if this scanner's next token is a valid BigInteger
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextBigInteger
```
public boolean hasNextBigInteger(int radix)
```
    Returns true if the next token in this scanner's input can be interpreted as a BigInteger in the specified radix using the nextBigInteger() method. The scanner does not advance past any input.
    
    Parameters:
    
    radix - the radix used to interpret the token as an integer
    
    Returns:
    
    true if and only if this scanner's next token is a valid BigInteger
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextBoolean
```
public boolean hasNextBoolean()
```
    Returns true if the next token in this scanner's input can be interpreted as a boolean value. The scanner does not advance past the input that matched.
    
    Returns:
    
    true if and only if this scanner's next token is a valid boolean value
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextByte
```
public boolean hasNextByte()
```
    Returns true if the next token in this scanner's input can be interpreted as a byte value in the default radix using the nextByte() method. The scanner does not advance past any input.
    
    Returns:
    
    true if and only if this scanner's next token is a valid byte value
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextByte
```
public boolean hasNextByte(int radix)
```
    Returns true if the next token in this scanner's input can be interpreted as a byte value in the specified radix using the nextByte() method. The scanner does not advance past any input.
    
    Parameters:
    
    radix - the radix used to interpret the token as a byte value
    
    Returns:
    
    true if and only if this scanner's next token is a valid byte value
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextDouble
```
public boolean hasNextDouble()
```
    Returns true if the next token in this scanner's input can be interpreted as a double value using the nextDouble() method. The scanner does not advance past any input.
    
    Returns:
    
    true if and only if this scanner's next token is a valid double value
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextFloat
```
public boolean hasNextFloat()
```
    Returns true if the next token in this scanner's input can be interpreted as a float value using the nextFloat() method. The scanner does not advance past any input.
    
    Returns:
    
    true if and only if this scanner's next token is a valid float value
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextInt
```
public boolean hasNextInt()
```
    Returns true if the next token in this scanner's input can be interpreted as an int value in the default radix using the nextInt() method. The scanner does not advance past any input.
    
    Returns:
    
    true if and only if this scanner's next token is a valid int value
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextInt
```
public boolean hasNextInt(int radix)
```
    Returns true if the next token in this scanner's input can be interpreted as an int value in the specified radix using the nextInt() method. The scanner does not advance past any input.
    
    Parameters:
    
    radix - the radix used to interpret the token as an int value
    
    Returns:
    
    true if and only if this scanner's next token is a valid int value
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextLine
```
public boolean hasNextLine()
```
    Returns true if there is another line in the input of this scanner. This method may block while waiting for input. The scanner does not advance past any input.
    
    Returns:
    
    true if and only if this scanner has another line of input
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextLong
```
public boolean hasNextLong()
```
    Returns true if the next token in this scanner's input can be interpreted as a long value in the default radix using the nextLong() method. The scanner does not advance past any input.
    
    Returns:
    
    true if and only if this scanner's next token is a valid long value
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextLong
```
public boolean hasNextLong(int radix)
```
    Returns true if the next token in this scanner's input can be interpreted as a long value in the specified radix using the nextLong() method. The scanner does not advance past any input.
    
    Returns:
    
    true if and only if this scanner's next token is a valid long value
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextShort
```
public boolean hasNextShort()
```
    Returns true if the next token in this scanner's input can be interpreted as a short value in the default radix using the nextShort() method. The scanner does not advance past any input.
    
    Returns:
    
    true if and only if this scanner's next token is a valid short value in the default radix
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - hasNextShort
```
public boolean hasNextShort(int radix)
```
    Returns true if the next token in this scanner's input can be interpreted as a short value in the specified radix using the nextShort() method. The scanner does not advance past any input.
    
    Parameters:
    
    radix - the radix used to interpret the token as a short value
    
    Returns:
    
    true if and only if this scanner's next token is a valid short value in the specified radix
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - ioException
```
public IOException ioException()
```
    Returns the IOException last thrown by this Scanner. This method returns null if no such exception exists.
    
    Returns:
    
    the last exception thrown by this scanner's readable
  - locale
```
public Locale locale()
```
    Returns this scanner's locale. A scanner's locale affects many elements of its default primitive matching regular expressions.
    
    Returns:
    
    this scanner's locale
  - next
```
public String next()
```
    Finds and returns the next complete token from this scanner. A complete token is preceded and followed by input that matches the delimiter pattern. This method may block while waiting for input to scan, even if a previous invocation of hasNext() returned true.
    
    Returns:
    
    the next token
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - next
```
public String next(Pattern pattern)
```
    Returns the next token if it matches the specified pattern. This method may block while waiting for input to scan, even if a previous invocation of hasNext(Pattern) returned true. If the match is successful, the scanner advances past the input that matched the pattern.
    
    Parameters:
    
    pattern - the pattern to scan for
    
    Returns:
    
    the next token
    
    Throws:
    
    NoSuchElementException - if no more tokens are available
    
    IllegalStateException - if this scanner is closed
  - next
```
public String next(String pattern)
```
    Returns the next token if it matches the pattern constructed from the specified string. If the match is successful, the scanner advances past the input that matched the pattern. An invocation of this method of the form next(pattern) behaves in exactly the same way as the invocation next(Pattern.compile(pattern)).
    
    Parameters:
    
    pattern - a string specifying the pattern to scan
    
    Returns:
    
    the next token
    
    Throws:
    
    NoSuchElementException - if no such tokens are available
    
    IllegalStateException - if this scanner is closed
  - nextBigDecimal
```
public BigDecimal nextBigDecimal()
```
    Scans the next token of the input as a BigDecimal.
    
    Returns:
    
    the BigDecimal scanned from the input
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextBigInteger
```
public BigInteger nextBigInteger()
```
    Scans the next token of the input as a BigInteger.
    
    Returns:
    
    the BigInteger scanned from the input
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextBigInteger
```
public BigInteger nextBigInteger(int radix)
```
    Scans the next token of the input as a BigInteger.
    
    Parameters:
    
    radix - the radix used to interpret the token
    
    Returns:
    
    the BigInteger scanned from the input
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextBoolean
```
public boolean nextBoolean()
```
    Scans the next token of the input into a boolean value and returns that value. This method will throw FormatException if the next token cannot be translated into a valid boolean value. If the match is successful, the scanner advances past the input that matched.
    
    Returns:
    
    the boolean scanned from the input
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextByte
```
public byte nextByte()
```
    Scans the next token of the input as a byte.
    An invocation of this method of the form nextByte() behaves in exactly the same way as the invocation nextByte(radix), where radix is the default radix of this scanner.
    
    Returns:
    
    the byte scanned from the input
    
    Throws:
    
    NoSuchElementException - if input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextByte
```
public byte nextByte(int radix)
```
    Scans the next token of the input as a byte.
    
    Parameters:
    
    radix - the radix used to interpret the token as a byte value
    
    Returns:
    
    the byte scanned from the input
    
    Throws:
    
    InputMismatchException - if the next token does not match the Integer regular expression, or is out of range
    
    NoSuchElementException - if input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextDouble
```
public double nextDouble()
```
    Scans the next token of the input as a double. This method will throw NumberFormatException if the next token cannot be translated into a valid double value. If the translation is successful, the scanner advances past the input that matched.
    
    Returns:
    
    the double scanned from the input
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextFloat
```
public float nextFloat()
```
    Scans the next token of the input as a float. This method will throw NumberFormatException if the next token cannot be translated into a valid float value. If the translation is successful, the scanner advances past the input that matched.
    
    Returns:
    
    the float scanned from the input
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextInt
```
public int nextInt()
```
    Scans the next token of the input as an int. This method will throw NumberFormatException if the next token cannot be translated into a valid int value. If the translation is successful, the scanner advances past the input that matched.
    
    Returns:
    
    the int scanned from the input
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextInt
```
public int nextInt(int radix)
```
    Scans the next token of the input as an int. This method will throw FormatException if the next token cannot be translated into a valid int value. If the translation is successful, the scanner advances past the input that matched.
    
    Parameters:
    
    radix - the radix used to interpret the token as an int value
    
    Returns:
    
    the int scanned from the input
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextLine
```
public String nextLine()
```
    Advances this scanner past the current line and returns the input that was skipped. This method returns the rest of the current line, excluding any line separator at the end. The position is set to the beginning of the next line. Since this method continues to search through the input looking for a line separator, it may buffer all of the input searching for the line to skip if no line separators are present.
    
    Returns:
    
    the line that was skipped
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextLong
```
public long nextLong()
```
    Scans the next token of the input as a long. This method will throw NumberFormatException if the next token cannot be translated into a valid long value. If the translation is successful, the scanner advances past the input that matched.
    
    Returns:
    
    the long scanned from the input
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextLong
```
public long nextLong(int radix)
```
    Scans the next token of the input as a long. This method will throw FormatException if the next token cannot be translated into a valid long value. If the translation is successful, the scanner advances past the input that matched.
    
    Parameters:
    
    radix - the radix used to interpret the token as a long value
    
    Returns:
    
    the long scanned from the input
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextShort
```
public short nextShort()
```
    Scans the next token of the input as a short. This method will throw NumberFormatException if the next token cannot be translated into a valid short value. If the translation is successful, the scanner advances past the input that matched.
    
    Returns:
    
    the short scanned from the input
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - nextShort
```
public short nextShort(int radix)
```
    Scans the next token of the input as a short. This method will throw FormatException if the next token cannot be translated into a valid short value. If the translation is successful, the scanner advances past the input that matched.
    
    Parameters:
    
    radix - the radix used to interpret the token as a short value
    
    Returns:
    
    the long scanned from the input
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - radix
```
public int radix()
```
    Returns this scanner's default radix.
    A scanner's radix affects elements of its default number matching regular expressions.
    
    Returns:
    
    the default radix of this scanner
    
    Throws:
    
    NoSuchElementException - if the input is exhausted
    
    IllegalStateException - if this scanner is closed
  - remove
```
public void remove()
```
    The remove operation is not supported by this implementation of Iterator.
    
    Throws:
    
    UnsupportedOperationException - if this method is invoked.
  - setEchoForce
```
public void setEchoForce(boolean value)
```
  - setEchoStream
```
public void setEchoStream(PrintStream stream)
```
  - skip
```
public SimpleScanner skip(Pattern pattern)
```
    Skips input that matches the specified pattern, ignoring delimiters. This method will skip input if an anchored match of the specified pattern succeeds. If a match to the specified pattern is not found at the current position, then no input is skipped and a NoSuchElementException is thrown. Since this method seeks to match the specified pattern starting at the scanner's current position, patterns that can match a lot of input (".*", for example) may cause the scanner to buffer a large amount of input. Note that it is possible to skip something without risking a NoSuchElementException by using a pattern that can match nothing, e.g., sc.skip("[ \t]*").
    
    Parameters:
    
    pattern - a string specifying the pattern to skip over
    
    Returns:
    
    this scanner
    
    Throws:
    
    NoSuchElementException - if the specified pattern is not found
    
    IllegalStateException - if this scanner is closed
  - skip
```
public SimpleScanner skip(String pattern)
```
    Skips input that matches a pattern constructed from the specified string. An invocation of this method of the form skip(pattern) behaves in exactly the same way as the invocation skip(Pattern.compile(pattern)).
    
    Parameters:
    
    pattern - a string specifying the pattern to skip over
    
    Returns:
    
    this scanner
    
    Throws:
    
    IllegalStateException - if this scanner is closed
  - toString
```
public String toString()
```
    Returns the string representation of this Scanner. The string representation of a Scanner contains information that may be useful for debugging. The exact format is unspecified.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    The string representation of this scanner
  - useDelimiter
```
public SimpleScanner useDelimiter(Pattern pattern)
```
    Sets this scanner's delimiting pattern to the specified pattern.
    
    Parameters:
    
    pattern - A delimiting pattern
    
    Returns:
    
    this scanner
  - useDelimiter
```
public SimpleScanner useDelimiter(String pattern)
```
    Sets this scanner's delimiting pattern to a pattern constructed from the specified String. An invocation of this method of the form useDelimiter(pattern) behaves in exactly the same way as the invocation hasDelimiter(Pattern.compile(pattern)).
    
    Parameters:
    
    pattern - A string specifying a delimiting pattern
    
    Returns:
    
    this scanner
  - useLocale
```
public SimpleScanner useLocale(Locale locale)
```
    Sets this scanner's locale to the specified locale. A scanner's locale affects many elements of its default primitive matching regular expressions; see localized numbers above.
    
    Parameters:
    
    locale - A string specifying the locale to use
    
    Returns:
    
    this scanner
  - useRadix
```
public SimpleScanner useRadix(int radix)
```
    Sets this scanner's default radix to the specified radix.
    A scanner's radix affects elements of its default number matching regular expressions.
    If the radix is less than Character.MIN_RADIX or greater than Character.MAX_RADIX, then an IllegalArgumentException is thrown.
    
    Throws:
    
    IllegalArgumentException - if radix is out of range

Class SimpleScanner

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SCANNER_APPLET_MODE_PROPERTY_NAME

SCANNER_ECHO_PROPERTY_NAME

SCANNER_REUSE_PROPERTY_NAME

SCANNER_WORKING_DIR_PROPERTY_NAME

Constructor Detail

SimpleScanner

SimpleScanner

SimpleScanner

SimpleScanner

Method Detail

clearCache

getEcho

getAppletMode

getReuse

getWorkingDir

setAppletMode

setEcho

setReuse

setWorkingDir

close

delimiter

findWithinHorizon

findWithinHorizon

findInLine

findInLine

hasNext

hasNext

hasNext

hasNextBigDecimal

hasNextBigInteger

hasNextBigInteger

hasNextBoolean

hasNextByte

hasNextByte

hasNextDouble

hasNextFloat

hasNextInt

hasNextInt

hasNextLine

hasNextLong

hasNextLong

hasNextShort

hasNextShort

ioException

locale

next

next

next

nextBigDecimal

nextBigInteger

nextBigInteger

nextBoolean

nextByte

nextByte

nextDouble

nextFloat

nextInt

nextInt

nextLine

nextLong

nextLong

nextShort

nextShort

radix

remove

setEchoForce

setEchoStream

skip

skip

toString

useDelimiter

useDelimiter

useLocale

useRadix