Scanner (Java Platform SE 8 )

java.lang.Object
- java.util.Scanner

All Implemented Interfaces:

Closeable ， AutoCloseable ， Iterator < String >
```
public final class Scanner
extends Object
implements Iterator<String>, Closeable
```
一个简单的文本扫描器，可以使用正则表达式解析原始类型和字符串。
A Scanner分隔符模式将输入打破到令牌，默认情况下匹配空格。然后可以使用各种next方法将得到的令牌转换成不同类型的值。

例如，该代码允许用户从System.in读取一个数字：
```
     Scanner sc = new Scanner(System.in);
     int i = sc.nextInt();
 
```
另一个例子，该代码允许从文件myNumbers中的条目分配long类型：
```
      Scanner sc = new Scanner(new File("myNumbers"));
      while (sc.hasNextLong()) {
          long aLong = sc.nextLong();
      }
 
```
扫描仪也可以使用除空格之外的分隔符。此示例从字符串读取几个项目：
```
     String input = "1 fish 2 fish red fish blue fish";
     Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*");
     System.out.println(s.nextInt());
     System.out.println(s.nextInt());
     System.out.println(s.next());
     System.out.println(s.next());
     s.close();
 
```
打印以下输出：
```
     1
     2
     red
     blue
 
```
可以使用此代码生成相同的输出，该代码使用正则表达式一次解析所有四个令牌：
```
     String input = "1 fish 2 fish red fish blue fish";
     Scanner s = new Scanner(input);
     s.findInLine("(\\d+) fish (\\d+) fish (\\w+) fish (\\w+)");
     MatchResult result = s.match();
     for (int i=1; i<=result.groupCount(); i++)
         System.out.println(result.group(i));
     s.close();
 
```
该default whitespace delimiter由扫描仪使用的是由认可Character 。 isWhitespace 。 reset()方法将将扫描仪分隔符的值重置为默认空白分隔符，而不管以前是否已更改。

扫描操作可能会阻止等待输入。

next()和hasNext()方法及其原始类型协同方法（例如nextInt()和hasNextInt() ）首先跳过与分隔符模式匹配的任何输入，然后尝试返回下一个令牌。 hasNext和next方法都可能阻止等待进一步的输入。一个hasNext方法块是否没有连接到其关联的next方法是否会阻塞。

的findInLine(java.lang.String) ， findWithinHorizon(java.lang.String, int)和skip(java.util.regex.Pattern)方法定界符模式的独立操作。这些方法将尝试匹配指定的模式，而不考虑输入中的分隔符，因此可以在分隔符不相关的特殊情况下使用。这些方法可能会阻止等待更多的输入。

当扫描仪投掷InputMismatchException时，扫描仪将不会传递导致异常的令牌，以便可以通过其他方法检索或跳过。

根据定界模式的类型，可以返回空令牌。例如，模式"\\s+"将不返回任何空的令牌，因为它符合分隔符的多个实例。定界模式"\\s"可以返回空令牌，因为它只能一次传递一个空格。

一个扫描器可以从实现的任何对象读取文本Readable接口。如果底层可读的Readable.read(java.nio.CharBuffer)方法的调用会抛出一个IOException，则扫描器将假定输入的结尾已经到达。由底层可读最新抛出IOException可以通过检索ioException()方法。

当一个Scanner关闭时，如果源实现了Closeable接口，它将关闭其输入源。

A Scanner对于无需外部同步的多线程使用是不安全的。

除非另有提及，传递一个null参数成的任何方法Scanner将导致NullPointerException被抛出。

扫描仪将默认将数字解释为十进制，除非使用useRadix(int)方法设置了不同的基数。该reset()方法将扫描器的基数的值重置为10不管它以前是否发生变化。

Localized numbers

该类的一个实例能够扫描标准格式的数字以及扫描仪区域的格式。扫描仪的initial locale是由Locale.getDefault(Locale.Category.FORMAT)方法返回的值; 可以通过useLocale(java.util.Locale)方法进行更改。 reset()方法将将扫描仪的区域设置的值重置为初始区域设置，而不管以前是否已更改。

本地化格式根据以下参数定义，特定区域设置取自该区域设置的DecimalFormat对象df及其和DecimalFormatSymbols对象dfs 。

LocalGroupSeparator

The character used to separate thousands groups, i.e., dfs. getGroupingSeparator()

LocalDecimalSeparator

The character used for the decimal point, i.e., dfs. getDecimalSeparator()

LocalPositivePrefix

The string that appears before a positive number (may be empty), i.e., df. getPositivePrefix()

LocalPositiveSuffix

The string that appears after a positive number (may be empty), i.e., df. getPositiveSuffix()

LocalNegativePrefix

The string that appears before a negative number (may be empty), i.e., df. getNegativePrefix()

LocalNegativeSuffix

The string that appears after a negative number (may be empty), i.e., df. getNegativeSuffix()

LocalNaN

The string that represents not-a-number for floating-point values, i.e., dfs. getNaN()

LocalInfinity

The string that represents infinity for floating-point values, i.e., dfs. getInfinity()

Number syntax

可以通过该类的实例解析为数字的字符串使用以下正则表达式语法来指定，其中Rmax是所用基数中的最高位数（例如，Rmax在基数10中为9）。

NonAsciiDigit ：

一个非ASCII字符c，其中Character.isDigit (c)返回true

Non0Digit ：

[1- Rmax ] | NonASCIIDigit

数字：

[0- Rmax ] | NonASCIIDigit

分组数 ：

( Non0Digit Digit ? 数字 ?

( LocalGroupSeparator 数字位数字 )+ )

数字：

( ( 数字 + ) | GroupedNumeral )

Integer:

( [-+]? ( 数字 ) )

| LocalPositivePrefix 数字 LocalPositiveSuffix

| LocalNegativePrefix 数字 LocalNegativeSuffix

小数点数 ：

数字

| 数字 LocalDecimalSeparator 数字 *

| LocalDecimalSeparator Digit +

指数

( [eE] [+-]? 数字 + )

Decimal:

( [-+]? 小数指数 ? )

| LocalPositivePrefix DecimalNumeral LocalPositiveSuffix 指数 ?

| LocalNegativePrefix DecimalNumeral LocalNegativeSuffix 指数 ?

HexFloat ：

[-+]? 0[xX][0-9a-fA-F]*\.[0-9a-fA-F]+ ([pP][-+]?[0-9]+)?

非数字 ：

NaN | LocalNan | Infinity | LocalInfinity

签名号 ：

( [-+]? NonNumber )

| LocalPositivePrefix NonNumber LocalPositiveSuffix

| LocalNegativePrefix NonNumber LocalNegativeSuffix

Float ：

十进制 | HexFloat |已 签署号码

上述正则表达式中的空格不重要。
从以下版本开始：

1.5

构造方法摘要

构造方法
Constructor and Description
`Scanner(File source)` 构造一个新的 `Scanner` ，产生从指定文件扫描的值。
`Scanner(File source, String charsetName)` 构造一个新的 `Scanner` ，产生从指定文件扫描的值。
`Scanner(InputStream source)` 构造一个新的 `Scanner` ，产生从指定输入流扫描的值。
`Scanner(InputStream source, String charsetName)` 构造一个新的 `Scanner` ，产生从指定输入流扫描的值。
`Scanner(Path source)` 构造一个新的 `Scanner` ，产生从指定文件扫描的值。
`Scanner(Path source, String charsetName)` 构造一个新的 `Scanner` ，产生从指定文件扫描的值。
`Scanner(Readable source)` 构造一个新的 `Scanner` ，产生从指定源扫描的值。
`Scanner(ReadableByteChannel source)` 构造一个新的 `Scanner` ，产生从指定通道扫描的值。
`Scanner(ReadableByteChannel source, String charsetName)` 构造一个新的 `Scanner` ，产生从指定通道扫描的值。
`Scanner(String source)` 构造一个新的 `Scanner` ，产生从指定字符串扫描的值。

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`void`	`close()` 关闭此扫描仪。
`Pattern`	`delimiter()` 返回 `Pattern`这个 `Scanner`正在使用来匹配分隔符。
`String`	`findInLine(Pattern pattern)` 尝试找到忽略分隔符的指定模式的下一个出现。
`String`	`findInLine(String pattern)` 尝试查找从指定字符串构造的模式的下一个出现，忽略分隔符。
`String`	`findWithinHorizon(Pattern pattern, int horizon)` 尝试找到指定模式的下一个出现。
`String`	`findWithinHorizon(String pattern, int horizon)` 尝试查找从指定字符串构造的模式的下一个出现，忽略分隔符。
`boolean`	`hasNext()` 如果此扫描仪在其输入中有另一个令牌，则返回true。
`boolean`	`hasNext(Pattern pattern)` 如果下一个完整的令牌匹配指定的模式，则返回true。
`boolean`	`hasNext(String pattern)` 如果下一个令牌匹配从指定字符串构造的模式，则返回true。
`boolean`	`hasNextBigDecimal()` 如果在此扫描器输入信息的下一个标记可以解释为，则返回true `BigDecimal`使用 `nextBigDecimal()`方法。
`boolean`	`hasNextBigInteger()` 如果在此扫描器输入信息的下一个标记可以解释为，则返回true `BigInteger`在使用默认基数 `nextBigInteger()`方法。
`boolean`	`hasNextBigInteger(int radix)` 如果在此扫描器输入信息的下一个标记可以解释为，则返回true `BigInteger`在使用指定基数 `nextBigInteger()`方法。
`boolean`	`hasNextBoolean()` 如果此扫描器输入中的下一个标记可以使用从字符串“true \| false”创建的不区分大小写的模式解释为布尔值，则返回true。
`boolean`	`hasNextByte()` 如果此扫描仪输入中的下一个标记可以使用 `nextByte()`方法将其解释为默认基数中的字节值，则返回true。
`boolean`	`hasNextByte(int radix)` 如果扫描仪输入中的下一个标记可以使用 `nextByte()`方法解释为指定基数中的字节值，则返回true。
`boolean`	`hasNextDouble()` 如果扫描仪的输入中的下一个标记可以使用 `nextDouble()`方法将其解释为双重值，则返回true。
`boolean`	`hasNextFloat()` 如果扫描仪输入中的下一个标记可以使用 `nextFloat()`方法将其解释为浮点值，则返回true。
`boolean`	`hasNextInt()` 如果此扫描仪输入中的下一个标记可以使用 `nextInt()`方法解释为默认基数中的int值，则返回true。
`boolean`	`hasNextInt(int radix)` 如果此扫描仪输入中的下一个标记可以使用 `nextInt()`方法解释为指定基数中的int值，则返回true。
`boolean`	`hasNextLine()` 如果扫描仪的输入中有另一行，则返回true。
`boolean`	`hasNextLong()` 如果此扫描仪输入中的下一个标记可以使用 `nextLong()`方法将其解释为默认基数中的长整型值，则返回true。
`boolean`	`hasNextLong(int radix)` 如果扫描仪的输入中的下一个标记可以使用 `nextLong()`方法解释为指定基数中的长整型值，则返回true。
`boolean`	`hasNextShort()` 如果此扫描仪输入中的下一个标记可以使用 `nextShort()`方法将其解释为默认基数中的一个短值，则返回true。
`boolean`	`hasNextShort(int radix)` 如果扫描仪的输入中的下一个标记可以使用 `nextShort()`方法解释为指定基数中的一个短值，则返回true。
`IOException`	`ioException()` 返回 `IOException`最后通过此抛出 `Scanner`的基本 `Readable` 。
`Locale`	`locale()` 返回此扫描仪的区域设置。
`MatchResult`	`match()` 返回此扫描仪执行的最后扫描操作的匹配结果。
`String`	`next()` 查找并返回此扫描仪的下一个完整令牌。
`String`	`next(Pattern pattern)` 如果匹配指定的模式，则返回下一个令牌。
`String`	`next(String pattern)` 如果匹配从指定字符串构造的模式，则返回下一个令牌。
`BigDecimal`	`nextBigDecimal()` 将输入的下一个标记扫描为`BigDecimal` 。
`BigInteger`	`nextBigInteger()` 将输入的下一个标记扫描为`BigInteger` 。
`BigInteger`	`nextBigInteger(int radix)` 将输入的下一个标记扫描为`BigInteger` 。
`boolean`	`nextBoolean()` 将输入的下一个标记扫描为布尔值，并返回该值。
`byte`	`nextByte()` 将输入的下一个标记扫描为 `byte` 。
`byte`	`nextByte(int radix)` 将输入的下一个标记扫描为 `byte` 。
`double`	`nextDouble()` 将输入的下一个标记扫描为 `double` 。
`float`	`nextFloat()` 将输入的下一个标记扫描为 `float` 。
`int`	`nextInt()` 将输入的下一个标记扫描为 `int` 。
`int`	`nextInt(int radix)` 将输入的下一个标记扫描为 `int` 。
`String`	`nextLine()` 将此扫描仪推进到当前行并返回跳过的输入。
`long`	`nextLong()` 将输入的下一个标记扫描为 `long` 。
`long`	`nextLong(int radix)` 将输入的下一个标记扫描为 `long` 。
`short`	`nextShort()` 将输入的下一个标记扫描为 `short` 。
`short`	`nextShort(int radix)` 将输入的下一个标记扫描为 `short` 。
`int`	`radix()` 返回此扫描仪的默认基数。
`void`	`remove()` Iterator的此实现不支持删除 `Iterator` 。
`Scanner`	`reset()` 重设此扫描仪。
`Scanner`	`skip(Pattern pattern)` 跳过与指定模式匹配的输入，忽略分隔符。
`Scanner`	`skip(String pattern)` 跳过与指定字符串构成的模式匹配的输入。
`String`	`toString()` 返回此 `Scanner`的字符串表示 `Scanner` 。
`Scanner`	`useDelimiter(Pattern pattern)` 将此扫描仪的分隔模式设置为指定的模式。
`Scanner`	`useDelimiter(String pattern)` 将此扫描器的分隔模式设置为从指定的构造的模式 `String` 。
`Scanner`	`useLocale(Locale locale)` 将此扫描仪的区域设置设置为指定的区域设置。
`Scanner`	`useRadix(int radix)` 将此扫描仪的默认基数设置为指定的基数。

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

Methods inherited from interface java.util.Iterator
forEachRemaining

- 构造方法详细信息
  - Scanner
```
public Scanner(Readable source)
```
    构造一个新的 Scanner ，产生从指定源扫描的值。
    
    参数
    
    source - 一个实现Readable接口的字符源
  - Scanner
```
public Scanner(InputStream source)
```
    构造一个新的Scanner ，产生从指定的输入流扫描的值。流中的字节将使用底层平台的default charset转换为字符。
    
    参数
    
    source - 要扫描的输入流
  - Scanner
```
public Scanner(InputStream source,
               String charsetName)
```
    构造一个新的Scanner ，产生从指定输入流扫描的值。流中的字节将使用指定的字符集转换为字符。
    
    参数
    
    source - 要扫描的输入流
    
    charsetName - 用于将流中的字节转换为要扫描的字符的编码类型
    
    异常
    
    IllegalArgumentException - 如果指定的字符集不存在
  - Scanner
```
public Scanner(File source)
        throws FileNotFoundException
```
    构造一个新的Scanner ，产生从指定文件扫描的值。使用底层平台的default charset将文件中的字节转换为字符。
    
    参数
    
    source - 要扫描的文件
    
    异常
    
    FileNotFoundException - 如果找不到源
  - Scanner
```
public Scanner(File source,
               String charsetName)
        throws FileNotFoundException
```
    构造一个新的Scanner ，产生从指定文件扫描的值。使用指定的字符集将文件中的字节转换为字符。
    
    参数
    
    source - 要扫描的文件
    
    charsetName - 用于将文件中的字节转换为要扫描的字符的编码类型
    
    异常
    
    FileNotFoundException - 如果没有找到源
    
    IllegalArgumentException - 如果没有找到指定的编码
  - Scanner
```
public Scanner(Path source)
        throws IOException
```
    构造一个新的Scanner ，产生从指定文件扫描的值。使用底层平台的default charset将文件中的字节转换为字符。
    
    参数
    
    source - 要扫描的文件的路径
    
    异常
    
    IOException - 如果I / O错误发生开源
    
    从以下版本开始：
    
    1.7
  - Scanner
```
public Scanner(Path source,
               String charsetName)
        throws IOException
```
    构造一个新的Scanner ，产生从指定文件扫描的值。使用指定的字符集将文件中的字节转换为字符。
    
    参数
    
    source - 要扫描的文件的路径
    
    charsetName - 用于将文件中的字节转换为要扫描的字符的编码类型
    
    异常
    
    IOException - 如果I / O错误发生开源
    
    IllegalArgumentException - 如果未找到指定的编码
    
    从以下版本开始：
    
    1.7
  - Scanner
```
public Scanner(String source)
```
    构造一个新的 Scanner ，产生从指定字符串扫描的值。
    
    参数
    
    source - 要扫描的字符串
  - Scanner
```
public Scanner(ReadableByteChannel source)
```
    构造一个新的Scanner ，产生从指定通道扫描的值。来源的字节将使用底层平台的default charset转换为字符。
    
    参数
    
    source - 要扫描的通道
  - Scanner
```
public Scanner(ReadableByteChannel source,
               String charsetName)
```
    构造一个新的Scanner ，产生从指定通道扫描的值。来自源的字节将使用指定的字符集转换为字符。
    
    参数
    
    source - 要扫描的频道
    
    charsetName - 用于将字节从通道转换为要扫描的字符的编码类型
    
    异常
    
    IllegalArgumentException - 如果指定的字符集不存在
- 方法详细信息
  - close
```
public void close()
```
    关闭此扫描仪。
    如果此扫描仪尚未关闭，那么如果其底层readable还实现了Closeable接口，那么可调用的close方法将被调用。如果此扫描仪已关闭，则调用此方法将不起作用。
    
    扫描仪关闭后尝试执行搜索操作将导致IllegalStateException 。
    
    Specified by:
    
    close在接口 Closeable
    
    Specified by:
    
    close在接口 AutoCloseable
  - ioException
```
public IOException ioException()
```
    返回IOException最后通过此抛出Scanner的基本Readable 。如果不存在这种异常，此方法返回null 。
    
    结果
    
    这个扫描仪可读的抛出的最后一个异常
  - delimiter
```
public Pattern delimiter()
```
    返回 Pattern这个 Scanner目前用于匹配分隔符。
    
    结果
    
    这个扫描仪的划分模式。
  - useDelimiter
```
public Scanner useDelimiter(Pattern pattern)
```
    将此扫描仪的分隔模式设置为指定的模式。
    
    参数
    
    pattern - 定界模式
    
    结果
    
    这个扫描仪
  - useDelimiter
```
public Scanner useDelimiter(String pattern)
```
    将此扫描仪的划分模式设置为从指定的String String的模式。
    调用此方法的形式useDelimiter(pattern)的行为方式与调用useDelimiter(Pattern.compile(pattern))完全相同 。
    
    调用reset()方法将扫描仪的分隔符设置为default 。
    
    参数
    
    pattern - 一个指定定界模式的字符串
    
    结果
    
    这个扫描仪
  - locale
```
public Locale locale()
```
    返回此扫描仪的区域设置。
    扫描仪的区域设置会影响其默认基元匹配正则表达式的许多元素; 见上面localized numbers 。
    
    结果
    
    这个扫描仪的区域设置
  - useLocale
```
public Scanner useLocale(Locale locale)
```
    将此扫描仪的区域设置设置为指定的区域设置。
    扫描仪的区域设置会影响其默认基元匹配正则表达式的许多元素; 见上面localized numbers 。
    
    调用reset()方法将扫描仪的区域设置设置为initial locale 。
    
    参数
    
    locale - 指定要使用的区域设置的字符串
    
    结果
    
    这个扫描仪
  - radix
```
public int radix()
```
    返回此扫描仪的默认基数。
    扫描仪的基数影响与正则表达式匹配的默认数字的元素; 见上文localized numbers 。
    
    结果
    
    该扫描仪的默认基数
  - useRadix
```
public Scanner useRadix(int radix)
```
    将此扫描仪的默认基数设置为指定的基数。
    扫描仪的基数影响与正则表达式匹配的默认数字的元素; 见上面localized numbers 。
    
    如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则抛出IllegalArgumentException 。
    
    调用reset()方法将扫描仪的基数设置为10 。
    
    参数
    
    radix - 扫描数字时使用的基数
    
    结果
    
    这个扫描仪
    
    异常
    
    IllegalArgumentException - 如果基数超出范围
  - match
```
public MatchResult match()
```
    返回此扫描仪执行的最后扫描操作的匹配结果。该方法将抛出IllegalStateException如果没有匹配已执行，或者如果最后一场比赛并不成功。
    各种next的方法Scanner做，如果他们完成未抛出异常的比赛结果可用。例如，在调用返回一个int的nextInt()方法之后，该方法返回一个MatchResult ，用于搜索上面定义的Integer正则表达式。类似地，如果成功， findInLine(java.lang.String),findWithinHorizon(java.lang.String, int)和skip(java.util.regex.Pattern)方法将使匹配可用。
    
    结果
    
    最后一场比赛的比赛结果
    
    异常
    
    IllegalStateException - 如果没有匹配结果可用
  - toString
```
public String toString()
```
    返回此Scanner的字符串表示Scanner 。 a的字符串表示Scanner包含了对调试可能有用的信息。确切的格式是未指定的。
    
    重写：
    
    toString在 Object
    
    结果
    
    该扫描仪的字符串表示
  - hasNext
```
public boolean hasNext()
```
    如果此扫描仪在其输入中有另一个令牌，则返回true。此方法可能会在等待输入扫描时屏蔽。扫描仪不会超过任何输入。
    
    Specified by:
    
    hasNext在接口 Iterator<String>
    
    结果
    
    当且仅当该扫描仪具有另一个令牌时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
    
    另请参见：
    
    Iterator
  - next
```
public String next()
```
    查找并返回此扫描仪的下一个完整令牌。一个完整的令牌在分隔符模式之前和之后是与分隔符模式匹配的输入。这种方法可能会在等待输入扫描时阻塞，即使以前的调用hasNext()返回了true 。
    
    Specified by:
    
    next在接口 Iterator<String>
    
    结果
    
    下一个标记
    
    异常
    
    NoSuchElementException - 如果没有更多的令牌可用
    
    IllegalStateException - 如果此扫描仪已关闭
    
    另请参见：
    
    Iterator
  - remove
```
public void remove()
```
    Iterator的此实现不支持删除 Iterator 。
    
    Specified by:
    
    remove在接口 Iterator<String>
    
    异常
    
    UnsupportedOperationException - 如果这个方法被调用。
    
    另请参见：
    
    Iterator
  - hasNext
```
public boolean hasNext(String pattern)
```
    如果下一个令牌匹配从指定字符串构造的模式，则返回true。扫描仪不会超过任何输入。
    形式hasNext(pattern)的这种方法的调用行为以完全相同的方式调用hasNext(Pattern.compile(pattern))。
    
    参数
    
    pattern - 指定要扫描的模式的字符串
    
    结果
    
    如果且仅当此扫描仪具有与指定模式匹配的另一个令牌，则为true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - next
```
public String next(String pattern)
```
    如果匹配从指定字符串构造的模式，则返回下一个令牌。如果匹配成功，扫描仪将超过符合图案的输入。
    调用此方法的形式next(pattern)的行为方式与调用next(Pattern.compile(pattern))完全相同 。
    
    参数
    
    pattern - 指定要扫描的模式的字符串
    
    结果
    
    下一个标记
    
    异常
    
    NoSuchElementException - 如果没有这样的令牌可用
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNext
```
public boolean hasNext(Pattern pattern)
```
    如果下一个完整的令牌匹配指定的模式，则返回true。完整的令牌前缀并通过与分隔符模式匹配的输入进行后缀。此方法可能会在等待输入时阻塞。扫描仪不会超过任何输入。
    
    参数
    
    pattern - 要扫描的模式
    
    结果
    
    如果且仅当此扫描仪具有与指定模式匹配的另一个令牌，则为true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - next
```
public String next(Pattern pattern)
```
    如果匹配指定的模式，则返回下一个令牌。这种方法可能会在等待输入扫描时阻塞，即使以前的调用hasNext(Pattern)返回了true 。如果匹配成功，扫描仪将超过符合图案的输入。
    
    参数
    
    pattern - 要扫描的模式
    
    结果
    
    下一个标记
    
    异常
    
    NoSuchElementException - 如果没有更多的令牌可用
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextLine
```
public boolean hasNextLine()
```
    如果扫描仪的输入中有另一行，则返回true。此方法可能会在等待输入时阻塞。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描仪具有另一行输入时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextLine
```
public String nextLine()
```
    将此扫描仪推进到当前行并返回跳过的输入。此方法返回当前行的其余部分，不包括末尾的任何行分隔符。该位置设置为下一行的开头。
    由于该方法继续搜索通过输入寻找行分隔符的输入，所以如果不存在行分隔符，则它可以缓冲搜索行的所有输入，以跳过该行。
    
    结果
    
    被跳过的行
    
    异常
    
    NoSuchElementException - 如果没有找到行
    
    IllegalStateException - 如果此扫描仪已关闭
  - findInLine
```
public String findInLine(String pattern)
```
    尝试查找从指定字符串构造的模式的下一个出现，忽略分隔符。
    形式findInLine(pattern)的这种方法的调用行为以完全相同的方式调用findInLine(Pattern.compile(pattern))。
    
    参数
    
    pattern - 指定要搜索的模式的字符串
    
    结果
    
    匹配指定模式的文本
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - findInLine
```
public String findInLine(Pattern pattern)
```
    尝试找到忽略分隔符的指定模式的下一个出现。如果在下一行分隔符之前找到模式，则扫描器将超过匹配的输入，并返回匹配该模式的字符串。如果在输入端检测到下一行分离器没有这样的图案，然后null被返回和扫描仪的位置不变。此方法可能会阻止等待与模式匹配的输入。
    由于该方法继续搜索输入寻找指定的模式，所以如果不存在线分隔符，它可能会缓冲搜索所需令牌的所有输入。
    
    参数
    
    pattern - 要扫描的模式
    
    结果
    
    匹配指定模式的文本
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - findWithinHorizon
```
public String findWithinHorizon(String pattern,
                                int horizon)
```
    尝试查找从指定字符串构造的模式的下一个出现，忽略分隔符。
    调用此方法的形式findWithinHorizon(pattern)的行为方式与调用findWithinHorizon(Pattern.compile(pattern, horizon))完全相同 。
    
    参数
    
    pattern - 一个指定要搜索的模式的字符串
    
    horizon - 搜索范围
    
    结果
    
    匹配指定模式的文本
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果地平线是负的
  - findWithinHorizon
```
public String findWithinHorizon(Pattern pattern,
                                int horizon)
```
    尝试找到指定模式的下一个出现。
    该方法通过输入搜索直到指定的搜索范围，忽略分隔符。如果找到模式，扫描仪将超过匹配的输入，并返回匹配该模式的字符串。如果没有检测到这种模式，则返回null，扫描仪的位置保持不变。此方法可能会阻止等待与模式匹配的输入。
    
    扫描仪将不会搜索超过其当前位置的horizon代码点。请注意，比赛可能会被地平线所限制; 也就是说，如果地平线较大，任意匹配结果可能不同。扫描仪将地平线视为透明的非锚定界限（见Matcher.useTransparentBounds(boolean)和Matcher.useAnchoringBounds(boolean) ）。
    
    如果地平线是0 ，那么地平线被忽略，并且该方法继续搜索通过输入寻找指定的模式而不受限制。在这种情况下，它可以缓冲搜索模式的所有输入。
    
    如果地平线为负，则抛出IllegalArgumentException。
    
    参数
    
    pattern - 要扫描的模式
    
    horizon - 搜索范围
    
    结果
    
    匹配指定模式的文本
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果地平线是负的
  - skip
```
public Scanner skip(Pattern pattern)
```
    跳过与指定模式匹配的输入，忽略分隔符。如果指定模式的锚定匹配成功，此方法将跳过输入。
    如果在当前位置找不到与指定模式的匹配，则不跳过输入，并抛出NoSuchElementException 。
    
    由于该方法旨在匹配从扫描仪当前位置开始的指定模式，因此可以匹配大量输入（例如“。*”）的模式可能会导致扫描程序缓冲大量输入。
    
    请注意，有可能跳过一些，而不用担心一NoSuchElementException使用模式，可以匹配什么，例如， sc.skip("[ \t]*") 。
    
    参数
    
    pattern - 指定要跳过的模式的字符串
    
    结果
    
    这个扫描仪
    
    异常
    
    NoSuchElementException - 如果未找到指定的模式
    
    IllegalStateException - 如果此扫描仪已关闭
  - skip
```
public Scanner skip(String pattern)
```
    跳过与指定字符串构成的模式匹配的输入。
    调用此方法的形式为skip(pattern)的行为方式与调用skip(Pattern.compile(pattern))完全相同 。
    
    参数
    
    pattern - 指定要跳过的模式的字符串
    
    结果
    
    这个扫描仪
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextBoolean
```
public boolean hasNextBoolean()
```
    如果此扫描器输入中的下一个标记可以使用从字符串“true | false”创建的不区分大小写的模式解释为布尔值，则返回true。扫描仪不会超过匹配的输入。
    
    结果
    
    当且仅当此扫描器的下一个令牌是有效的布尔值时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextBoolean
```
public boolean nextBoolean()
```
    将输入的下一个标记扫描为布尔值，并返回该值。如果下一个标记无法转换为有效的布尔值，则此方法将抛出InputMismatchException 。如果匹配成功，扫描仪将超过匹配的输入。
    
    结果
    
    从输入中扫描的布尔值
    
    异常
    
    InputMismatchException - 如果下一个令牌不是有效的布尔值
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextByte
```
public boolean hasNextByte()
```
    如果此扫描仪输入中的下一个标记可以使用nextByte()方法将其解释为默认基数中的字节值，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描仪的下一个令牌是有效的字节值时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextByte
```
public boolean hasNextByte(int radix)
```
    如果扫描仪输入中的下一个标记可以使用nextByte()方法解释为指定基数中的字节值，则返回true。扫描仪不会超过任何输入。
    
    参数
    
    radix - 用于将令牌解释为字节值的基数
    
    结果
    
    当且仅当此扫描仪的下一个令牌是有效的字节值时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextByte
```
public byte nextByte()
```
    将输入的下一个标记扫描为byte 。
    调用此方法的形式为nextByte()的行为方式与调用nextByte(radix)完全相同 ，其中radix是此扫描程序的默认基数。
    
    结果
    
    byte从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个令牌与整型正则表达式不匹配或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextByte
```
public byte nextByte(int radix)
```
    将输入的下一个标记扫描为byte 。如果下一个令牌不能转换成有效的字节值，则此方法将抛出InputMismatchException ，如下所述。如果翻译成功，扫描仪将超过匹配的输入。
    如果下一个令牌与上面定义的Integer正则表达式匹配，则令牌将转换为byte值，如同通过删除所有特定于语言环境的前缀，组分隔符和特定于语言环境的后缀一样，然后通过Character.digit将非ASCII数字映射为ASCII数字，负号（ - ）如果区域特定负前缀和后缀存在，并且将所得的字符串传递给Byte.parseByte带有指定基数。
    
    参数
    
    radix - 用于将令牌解释为字节值的基数
    
    结果
    
    byte从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个标记与整型正则表达式不匹配，或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextShort
```
public boolean hasNextShort()
```
    如果此扫描仪输入中的下一个标记可以使用nextShort()方法将其解释为默认基数中的一个短值，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描仪的下一个标记是默认基数中的有效短值时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextShort
```
public boolean hasNextShort(int radix)
```
    如果扫描仪输入中的下一个标记可以使用nextShort()方法解释为指定基数中的一个短值，则返回true。扫描仪不会超过任何输入。
    
    参数
    
    radix - 用于将令牌解释为短值的基数
    
    结果
    
    当且仅当此扫描器的下一个标记是指定基数中的有效的短值时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextShort
```
public short nextShort()
```
    将输入的下一个标记扫描为short 。
    形式nextShort()这个方法调用的行为完全相同的方式调用nextShort(radix)，其中radix是此扫描器的默认基数。
    
    结果
    
    short从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个令牌与整数正则表达式不匹配，或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextShort
```
public short nextShort(int radix)
```
    将输入的下一个标记扫描为short 。如果下一个令牌不能转换为有效的短值，则此方法将抛出InputMismatchException ，如下所述。如果翻译成功，扫描仪将超过匹配的输入。
    如果下一个令牌与上面定义的884647333934正则表达式匹配，则令牌将转换为short值，就像删除所有特定于语言环境的前缀，组分隔符和特定于语言环境的后缀一样，然后通过Character.digit将非ASCII数字映射为ASCII数字如果存在特定的区域设置的前缀和后缀，并将结果字符串传递给具有指定基数的Short.parseShort，则为负号（ - ）。
    
    参数
    
    radix - 用于将令牌解释为短值的基数
    
    结果
    
    short从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个令牌与整型正则表达式不匹配，或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextInt
```
public boolean hasNextInt()
```
    如果此扫描器输入中的下一个标记可以使用nextInt()方法将其解释为默认基数中的int值，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描器的下一个令牌是有效的int值时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextInt
```
public boolean hasNextInt(int radix)
```
    如果此扫描仪输入中的下一个标记可以使用nextInt()方法解释为指定基数中的int值，则返回true。扫描仪不会超过任何输入。
    
    参数
    
    radix - 用于将令牌解释为int值的基数
    
    结果
    
    当且仅当此扫描器的下一个令牌是有效的int值时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextInt
```
public int nextInt()
```
    将输入的下一个标记扫描为int 。
    形式nextInt()这个方法调用的行为完全相同的方式调用nextInt(radix)，其中radix是此扫描器的默认基数。
    
    结果
    
    int从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个令牌与整数正则表达式不匹配或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextInt
```
public int nextInt(int radix)
```
    将输入的下一个标记扫描为int 。如果下一个令牌不能转换为有效的int值，则此方法将抛出InputMismatchException ，如下所述。如果翻译成功，扫描仪将超过匹配的输入。
    如果下一个令牌与上面定义的8846473373232正则表达式匹配，则令牌将转换为int值，就像删除所有特定于语言环境的前缀，组分隔符和特定于语言环境的后缀一样，然后通过Character.digit将非ASCII数字映射为ASCII数字负号（ - ）如果区域特定负前缀和后缀存在，并且将所得的字符串传递给Integer.parseInt带有指定基数。
    
    参数
    
    radix - 用于将令牌解释为int值的基数
    
    结果
    
    int从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个令牌与整型正则表达式不匹配，或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextLong
```
public boolean hasNextLong()
```
    如果扫描仪的输入中的下一个标记可以使用nextLong()方法将其解释为默认基数中的长整型值，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描仪的下一个令牌是有效的长值时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextLong
```
public boolean hasNextLong(int radix)
```
    如果该扫描仪输入中的下一个标记可以使用nextLong()方法解释为指定基数中的长整型值，则返回true。扫描仪不会超过任何输入。
    
    参数
    
    radix - 用于将令牌解释为长值的基数
    
    结果
    
    当且仅当此扫描仪的下一个令牌是有效的长值时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextLong
```
public long nextLong()
```
    将输入的下一个标记扫描为long 。
    调用此方法的形式nextLong()的行为方式与调用nextLong(radix)完全相同 ，其中radix是此扫描程序的默认基数。
    
    结果
    
    long从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个标记与整型正则表达式不匹配，或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextLong
```
public long nextLong(int radix)
```
    将输入的下一个标记扫描为long 。如果下一个令牌不能转换为有效的长值，则此方法将抛出InputMismatchException ，如下所述。如果翻译成功，扫描仪将超过匹配的输入。
    如果下一个令牌与上面定义的Integer正则表达式匹配，则令牌将转换为long值，就像删除所有特定于语言环境的前缀，组分隔符和特定于语言环境的后缀一样，然后通过Character.digit将非ASCII数字映射为ASCII数字负号（ - ）如果区域特定负前缀和后缀存在，并且将所得的字符串传递给Long.parseLong带有指定基数。
    
    参数
    
    radix - 用于将令牌解释为int值的基数
    
    结果
    
    long从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个令牌与整型正则表达式不匹配，或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextFloat
```
public boolean hasNextFloat()
```
    如果此扫描仪输入中的下一个标记可以使用nextFloat()方法将其解释为浮点值，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描仪的下一个令牌是有效的浮点值时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextFloat
```
public float nextFloat()
```
    将输入的下一个标记扫描为float 。如果下一个令牌不能转换为有效的浮点值，则此方法将抛出InputMismatchException ，如下所述。如果翻译成功，扫描仪将超过匹配的输入。
    如果下一个令牌与上面定义的Float正则表达式匹配，则令牌将转换为float值，如同删除所有特定于语言环境的前缀，组分隔符和特定于语言环境的后缀一样，然后通过Character.digit将非ASCII数字映射为ASCII数字如果区域设置特定的负前缀和后缀存在，并将结果字符串传递给Float.parseFloat，则为负号（ - ）。如果标记与本地化的NaN或无穷大字符串相匹配，则将“Nan”或“无限”传递给Float.parseFloat适当。
    
    结果
    
    float从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个标记与 Float正则表达式不匹配或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextDouble
```
public boolean hasNextDouble()
```
    如果此扫描仪输入中的下一个标记可以使用nextDouble()方法将其解释为双精度值，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描器的下一个令牌是有效的双重值时才为真
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextDouble
```
public double nextDouble()
```
    将输入的下一个标记扫描为double 。如果下一个令牌无法转换为有效的双精度值，则此方法将抛出InputMismatchException 。如果翻译成功，扫描仪将超过匹配的输入。
    如果下一个令牌与上面定义的Float正则表达式匹配，则令牌将转换为double值，就像删除所有特定于区域设置的前缀，组分隔符和特定于语言环境的后缀一样，然后通过Character.digit将非ASCII数字映射为ASCII数字如果区域设置特定的负前缀和后缀存在，并将结果字符串传递给Double.parseDouble，则为负号（ - ）。如果标记与本地化的NaN或无穷大字符串相匹配，则将“Nan”或“无限”传递给Double.parseDouble适当。
    
    结果
    
    double从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个标记与 Float正则表达式不匹配，或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextBigInteger
```
public boolean hasNextBigInteger()
```
    如果在此扫描器输入信息的下一个标记可以解释为，则返回true BigInteger在使用默认基数nextBigInteger()方法。扫描仪不会超过任何输入。
    
    结果
    
    如果且仅当此扫描仪的下一个令牌是有效的 BigInteger
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextBigInteger
```
public boolean hasNextBigInteger(int radix)
```
    如果在此扫描器输入信息的下一个标记可以解释为，则返回true BigInteger在使用指定基数nextBigInteger()方法。扫描仪不会超过任何输入。
    
    参数
    
    radix - 用于将令牌解释为整数的基数
    
    结果
    
    如果且仅当此扫描仪的下一个令牌是有效的 BigInteger
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextBigInteger
```
public BigInteger nextBigInteger()
```
    将输入的下一个标记扫描为BigInteger 。
    调用此方法的形式nextBigInteger()的行为方式与调用nextBigInteger(radix)完全相同 ，其中radix是此扫描程序的默认基数。
    
    结果
    
    BigInteger从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个标记与整型正则表达式不匹配，或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextBigInteger
```
public BigInteger nextBigInteger(int radix)
```
    将输入的下一个标记扫描为BigInteger 。
    如果下一个标记的匹配Integer就好像通过移除所有组分隔符，经由映射非ASCII数字为ASCII数字以上则该标记被转换为BigInteger值定义的正则表达式Character.digit ，并将所得的字符串传递给BigInteger(String, int)构造与指定的基数。
    
    参数
    
    radix - 用于解释令牌的基数
    
    结果
    
    BigInteger从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个标记与整数正则表达式不匹配，或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextBigDecimal
```
public boolean hasNextBigDecimal()
```
    如果在此扫描器输入信息的下一个标记可以解释为，则返回true BigDecimal使用nextBigDecimal()方法。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描仪的下一个令牌是有效的 BigDecimal
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextBigDecimal
```
public BigDecimal nextBigDecimal()
```
    将输入的下一个标记扫描为BigDecimal 。
    如果下一个标记匹配Decimal就好像通过移除所有组分隔符，经由映射非ASCII数字为ASCII数字以上则该标记被转换为BigDecimal值定义的正则表达式Character.digit ，并将所得的字符串传递给BigDecimal(String)构造函数。
    
    结果
    
    BigDecimal从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个标记与 Decimal正则表达式不匹配，或超出范围
    
    NoSuchElementException - 输入是否耗尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - reset
```
public Scanner reset()
```
    重设此扫描仪。
    重置扫描器会丢弃所有可能已经通过调用改变了明确的状态信息useDelimiter(java.util.regex.Pattern) ， useLocale(java.util.Locale) ，或useRadix(int) 。
    
    调用此方法的形式为scanner.reset()的行为方式与调用完全相同
    scanner.useDelimiter("\\p{javaWhitespace}+") .useLocale(Locale.getDefault(Locale.Category.FORMAT)) .useRadix(10);
    结果
    
    这个扫描仪
    
    从以下版本开始：
    
    1.6

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class Scanner

Localized numbers

Number syntax

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Iterator

构造方法详细信息

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

方法详细信息

close

ioException

delimiter

useDelimiter

useDelimiter

locale

useLocale

radix

useRadix

match

toString

hasNext

next

remove

hasNext

next

hasNext

next

hasNextLine

nextLine

findInLine

findInLine

findWithinHorizon

findWithinHorizon

skip

skip

hasNextBoolean

nextBoolean

hasNextByte

hasNextByte

nextByte

nextByte

hasNextShort

hasNextShort

nextShort

nextShort

hasNextInt

hasNextInt

nextInt

nextInt

hasNextLong

hasNextLong

nextLong

nextLong

hasNextFloat

nextFloat

hasNextDouble

nextDouble

hasNextBigInteger

hasNextBigInteger

nextBigInteger

nextBigInteger

hasNextBigDecimal

nextBigDecimal

reset