实现的所有接口

Closeable ， AutoCloseable ， Iterator<String>
```
public final class Scannerextends Objectimplements Iterator<String>, Closeable
```
一个简单的文本扫描程序，可以使用正则表达式解析基本类型和字符串。
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(); 
```
4502201395911识别扫描仪使用的default whitespace delimiter 。 reset()方法将扫描仪分隔符的值重置为默认的空白分隔符，无论它是否先前已更改。

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

next()和hasNext()方法及其伴随方法（例如nextInt()和hasNextInt() ）首先跳过与分隔符模式匹配的任何输入，然后尝试返回下一个标记。 hasNext()和next()方法都可能阻止等待进一步输入。 hasNext()方法块是否与其关联的next()方法是否将阻止next() 。 tokens()方法还可以阻止等待输入。

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

当扫描程序抛出InputMismatchException时，扫描程序将不会传递导致异常的令牌，因此可以通过其他方法检索或跳过它。

根据分隔模式的类型，可以返回空标记。例如，模式"\\s+"将不返回空标记，因为它匹配分隔符的多个实例。 "\\s"模式"\\s"可以返回空标记，因为它一次只通过一个空格。

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

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

Scanner对于没有外部同步的多线程使用是不安全的。

除非另有说明，否则将null参数传递给null任何方法Scanner将导致抛出NullPointerException 。

除非使用useRadix(int)方法设置了不同的基数，否则扫描仪将默认将数字解释为十进制。无论先前是否更改过扫描仪， reset()方法都会将扫描仪基数的值重置为10 。

Localized numbers

此类的实例能够扫描标准格式的数字以及扫描程序的语言环境的格式。扫描仪initial locale是Locale.getDefault(Locale.Category.FORMAT)方法返回的值; 它可以通过useLocale()方法更改。 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是所使用的基数中的最高位（例如，基数10中的Rmax是9）。

NonAsciiDigit ：

非ASCII字符c， Character.isDigit (c)返回true

Non0Digit ：

[1- Rmax ] | NonASCIIDigit

数字：

[0- Rmax ] | NonASCIIDigit

GroupedNumeral ：

( Non0Digit Digit ? Digit ?

( LocalGroupSeparator 数字位数字 )+ )

数字：

( ( 数字 + ) | GroupedNumeral )

Integer:

( [-+]? ( 数字 ) )

| LocalPositivePrefix 数字 LocalPositiveSuffix

| LocalNegativePrefix 数字 LocalNegativeSuffix

十进制数 ：

数字

| 数字 LocalDecimalSeparator 数字 *

| LocalDecimalSeparator 数字 +

指数：

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

Decimal:

( [-+]? DecimalNumeral 指数 ? )

| LocalPositivePrefix DecimalNumeral LocalPositiveSuffix Exponent ?

| LocalNegativePrefix DecimalNumeral LocalNegativeSuffix Exponent ?

HexFloat ：

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

非数字 ：

NaN | LocalNan | Infinity | LocalInfinity

SignedNonNumber ：

( [-+]? NonNumber )

| LocalPositivePrefix NonNumber LocalPositiveSuffix

| LocalNegativePrefix NonNumber LocalNegativeSuffix

Float ：

十进制 | HexFloat | SignedNonNumber

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

1.5

构造方法摘要

构造方法
构造器	描述
`Scanner(File source)`	构造一个新的 `Scanner` ，它生成从指定文件扫描的值。
`Scanner(File source, String charsetName)`	构造一个新的 `Scanner` ，它生成从指定文件扫描的值。
`Scanner(File source, Charset charset)`	构造一个新的 `Scanner` ，它生成从指定文件扫描的值。
`Scanner(InputStream source)`	构造一个新的 `Scanner` ，它生成从指定输入流扫描的值。
`Scanner(InputStream source, String charsetName)`	构造一个新的 `Scanner` ，它生成从指定输入流扫描的值。
`Scanner(InputStream source, Charset charset)`	构造一个新的 `Scanner` ，它生成从指定输入流扫描的值。
`Scanner(Readable source)`	构造一个新的 `Scanner` ，它生成从指定源扫描的值。
`Scanner(String source)`	构造一个新的 `Scanner` ，它生成从指定字符串扫描的值。
`Scanner(ReadableByteChannel source)`	构造一个新的 `Scanner` ，它可以生成从指定通道扫描的值。
`Scanner(ReadableByteChannel source, String charsetName)`	构造一个新的 `Scanner` ，它可以生成从指定通道扫描的值。
`Scanner(ReadableByteChannel source, Charset charset)`	构造一个新的 `Scanner` ，它可以生成从指定通道扫描的值。
`Scanner(Path source)`	构造一个新的 `Scanner` ，它生成从指定文件扫描的值。
`Scanner(Path source, String charsetName)`	构造一个新的 `Scanner` ，它生成从指定文件扫描的值。
`Scanner(Path source, Charset charset)`	构造一个新的 `Scanner` ，它生成从指定文件扫描的值。

方法摘要

所有方法实例方法具体的方法
变量和类型	方法	描述
`void`	`close()`	关闭此扫描仪。
`Pattern`	`delimiter()`	返回 `Pattern`这 `Scanner`目前用于匹配分隔符。
`Stream<MatchResult>`	`findAll(String patString)`	返回与提供的模式字符串匹配的匹配结果流。
`Stream<MatchResult>`	`findAll(Pattern pattern)`	返回此扫描程序的匹配结果流。
`String`	`findInLine(String pattern)`	尝试查找从指定字符串构造的下一个模式，忽略分隔符。
`String`	`findInLine(Pattern pattern)`	尝试查找指定模式的下一个匹配项，忽略分隔符。
`String`	`findWithinHorizon(String pattern, int horizon)`	尝试查找从指定字符串构造的下一个模式，忽略分隔符。
`String`	`findWithinHorizon(Pattern pattern, int horizon)`	尝试查找指定模式的下一个匹配项。
`boolean`	`hasNext()`	如果此扫描器的输入中有另一个标记，则返回true。
`boolean`	`hasNext(String pattern)`	如果下一个标记与从指定字符串构造的模式匹配，则返回true。
`boolean`	`hasNext(Pattern pattern)`	如果下一个完整标记与指定模式匹配，则返回true。
`boolean`	`hasNextBigDecimal()`	如果此扫描器输入中的下一个标记可以使用 `nextBigDecimal()`方法解释为 `BigDecimal`则返回true。
`boolean`	`hasNextBigInteger()`	如果此扫描器输入中的下一个标记可以使用 `nextBigInteger()`方法在默认基数中解释为 `BigInteger` ，则返回true。
`boolean`	`hasNextBigInteger(int radix)`	如果此扫描器输入中的下一个标记可以使用 `nextBigInteger()`方法在指定的基数中解释为 `BigInteger` ，则返回true。
`boolean`	`hasNextBoolean()`	如果使用从字符串“true \| false”创建的不区分大小写的模式，可以将此扫描器输入中的下一个标记解释为布尔值，则返回true。
`boolean`	`hasNextByte()`	如果使用 `nextByte()`方法将此扫描器输入中的下一个标记解释为默认基数中的字节值，则返回true。
`boolean`	`hasNextByte(int radix)`	如果使用 `nextByte()`方法将此扫描器输入中的下一个标记解释为指定基数中的字节值，则返回true。
`boolean`	`hasNextDouble()`	如果使用 `nextDouble()`方法将此扫描仪输入中的下一个标记解释为double值，则返回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(String pattern)`	如果它与从指定字符串构造的模式匹配，则返回下一个标记。
`String`	`next(Pattern 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`的此实现不支持删除操作。
`Scanner`	`reset()`	重置此扫描仪。
`Scanner`	`skip(String pattern)`	跳过与指定字符串构造的模式匹配的输入。
`Scanner`	`skip(Pattern pattern)`	跳过与指定模式匹配的输入，忽略分隔符。
`Stream<String>`	`tokens()`	从此扫描程序返回分隔符分隔的标记流。
`String`	`toString()`	返回此 `Scanner`的字符串表示 `Scanner` 。
`Scanner`	`useDelimiter(String pattern)`	将此扫描仪的分隔模式设置为从指定的 `String`构造的模式。
`Scanner`	`useDelimiter(Pattern pattern)`	将此扫描仪的分隔模式设置为指定的模式。
`Scanner`	`useLocale(Locale locale)`	将此扫描程序的语言环境设置为指定的语言环境。
`Scanner`	`useRadix(int radix)`	将此扫描仪的默认基数设置为指定的基数。

声明方法的类 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

声明方法的接口 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(InputStream source,               Charset charset)
```
    构造一个新的Scanner ，它生成从指定输入流扫描的值。使用指定的字符集将流中的字节转换为字符。
    
    参数
    
    source - 要扫描的输入流
    
    charset - 用于将文件中的字节转换为要扫描的字符的字符集
    
    从以下版本开始：
    
    10
  - 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(File source,               Charset charset)        throws IOException
```
    构造一个新的Scanner ，它生成从指定文件扫描的值。使用指定的字符集将文件中的字节转换为字符。
    
    参数
    
    source - 要扫描的文件
    
    charset - 用于将文件中的字节转换为要扫描的字符的字符集
    
    异常
    
    IOException - 如果打开源发生I / O错误
    
    从以下版本开始：
    
    10
  - 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(Path source,               Charset charset)        throws IOException
```
    构造一个新的Scanner ，它生成从指定文件扫描的值。使用指定的字符集将文件中的字节转换为字符。
    
    参数
    
    source - 要扫描的文件的路径
    
    charset - 用于将文件中的字节转换为要扫描的字符的字符集
    
    异常
    
    IOException - 如果打开源发生I / O错误
    
    从以下版本开始：
    
    10
  - 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 - 如果指定的字符集不存在
  - Scanner
```
public Scanner(ReadableByteChannel source,               Charset charset)
```
    构造一个新的Scanner ，它可以生成从指定通道扫描的值。使用指定的字符集将源中的字节转换为字符。
    
    参数
    
    source - 要扫描的频道
    
    charset - 用于将字节从通道转换为要扫描的字符的编码类型
    
    从以下版本开始：
    
    10
- 方法详细信息
  - close
```
public void close()
```
    关闭此扫描仪。
    如果此扫描程序尚未关闭，那么如果其底层readable也实现了Closeable接口，则将调用可读的close方法。如果此扫描仪已关闭，则调用此方法将不起作用。
    
    扫描仪关闭后尝试执行搜索操作将导致IllegalStateException 。
    
    Specified by:
    
    close在界面 AutoCloseable
    
    Specified by:
    
    close在界面 Closeable
  - ioException
```
public IOException ioException()
```
    返回IOException最后通过此抛出Scanner的基本Readable 。如果不存在此类异常，则此方法返回null 。
    
    结果
    
    此扫描仪可读的最后一个异常
  - delimiter
```
public Pattern delimiter()
```
    返回 Pattern此 Scanner目前用于匹配分隔符。
    
    结果
    
    这个扫描仪的分界模式。
  - useDelimiter
```
public Scanner useDelimiter(Pattern pattern)
```
    将此扫描仪的分隔模式设置为指定的模式。
    
    参数
    
    pattern - pattern模式
    
    结果
    
    这个扫描仪
  - useDelimiter
```
public Scanner useDelimiter(String pattern)
```
    将此扫描仪的分隔模式设置为从指定的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则此方法抛出IllegalStateException 。
    各种next的方法Scanner使，如果他们完成未抛出异常的比赛结果可用。例如，在调用返回int的nextInt()方法之后，此方法返回MatchResult以搜索上面定义的Integer正则表达式。同样， findInLine() ， findWithinHorizon()和skip()方法将一个匹配结果，如果他们取得成功。
    
    结果
    
    最后一次匹配操作的匹配结果
    
    异常
    
    IllegalStateException - 如果没有可用的匹配结果
  - toString
```
public String toString()
```
    返回此Scanner的字符串表示Scanner 。 Scanner的字符串表示Scanner包含可能对调试有用的信息。具体格式未指定。
    
    重写：
    
    toString课程类别 Object
    
    结果
    
    此扫描程序的字符串表示形式
  - hasNext
```
public boolean hasNext()
```
    如果此扫描器的输入中有另一个标记，则返回true。在等待输入扫描时，此方法可能会阻塞。扫描仪不会超过任何输入。
    
    Specified by:
    
    hasNext ，界面 Iterator<String>
    
    结果
    
    当且仅当此扫描器具有另一个令牌时才返回true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
    
    另请参见：
    
    Iterator
  - next
```
public String next()
```
    从此扫描仪查找并返回下一个完整令牌。在完成令牌之前和之后是与分隔符模式匹配的输入。即使先前调用hasNext()返回true ，此方法也可能在等待输入扫描时true 。
    
    Specified by:
    
    next接口 Iterator<String>
    
    结果
    
    下一个标记
    
    异常
    
    NoSuchElementException - 如果没有更多令牌可用
    
    IllegalStateException - 如果此扫描仪已关闭
    
    另请参见：
    
    Iterator
  - remove
```
public void remove()
```
    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))方式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 ，此方法也可能在等待输入扫描时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) ）。
    
    如果horizon是0 ，则忽略horizon，此方法继续搜索输入，查找指定的模式而不绑定。在这种情况下，它可以缓冲搜索模式的所有输入。
    
    如果horizon是负数，则抛出IllegalArgumentException。
    
    参数
    
    pattern - 要扫描的模式
    
    horizon - 搜索范围
    
    结果
    
    与指定模式匹配的文本
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果地平线是负面的
  - skip
```
public Scanner skip(Pattern pattern)
```
    跳过与指定模式匹配的输入，忽略分隔符。如果指定模式的锚定匹配成功，则此方法将跳过输入。
    如果在当前位置找不到与指定模式的匹配，则不跳过任何输入并抛出NoSuchElementException 。
    
    由于此方法试图匹配从扫描仪当前位置开始的指定模式，因此可以匹配大量输入的模式（例如“。*”）可能会导致扫描程序缓冲大量输入。
    
    请注意，可以通过使用无法匹配的模式（例如， sc.skip("[ \t]*")跳过某些内容而不会冒NoSuchElementException的风险。
    
    参数
    
    pattern - 指定要跳过的模式的字符串
    
    结果
    
    这个扫描仪
    
    异常
    
    NoSuchElementException - 如果未找到指定的模式
    
    IllegalStateException - 如果此扫描仪已关闭
  - skip
```
public Scanner skip(String pattern)
```
    跳过与指定字符串构造的模式匹配的输入。
    调用skip(pattern)形式的此方法的行为与调用skip(Pattern.compile(pattern))方式skip(Pattern.compile(pattern)) 。
    
    参数
    
    pattern - 指定要跳过的模式的字符串
    
    结果
    
    这个扫描仪
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextBoolean
```
public boolean hasNextBoolean()
```
    如果使用从字符串“true | false”创建的不区分大小写的模式，可以将此扫描器输入中的下一个标记解释为布尔值，则返回true。扫描仪不会超过匹配的输入。
    
    结果
    
    当且仅当此扫描器的下一个标记是有效的布尔值时才返回true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextBoolean
```
public boolean nextBoolean()
```
    将输入的下一个标记扫描为布尔值并返回该值。如果下一个标记无法转换为有效的布尔值，则此方法将抛出InputMismatchException 。如果匹配成功，扫描仪将超过匹配的输入。
    
    结果
    
    从输入扫描的布尔值
    
    异常
    
    InputMismatchException - 如果下一个标记不是有效的布尔值
    
    NoSuchElementException - 如果输入已用尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextByte
```
public boolean hasNextByte()
```
    如果使用nextByte()方法将此扫描器输入中的下一个标记解释为默认基数中的字节值，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描器的下一个标记是有效字节值时才为true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextByte
```
public boolean hasNextByte(int radix)
```
    如果使用nextByte()方法将此扫描器输入中的下一个标记解释为指定基数中的字节值，则返回true。扫描仪不会超过任何输入。
    如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则抛出IllegalArgumentException 。
    
    参数
    
    radix - 用于将令牌解释为字节值的基数
    
    结果
    
    当且仅当此扫描器的下一个标记是有效字节值时才为true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果基数超出范围
  - 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 。
    
    如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则抛出IllegalArgumentException 。
    
    参数
    
    radix - 用于将令牌解释为字节值的基数
    
    结果
    
    从输入扫描 byte
    
    异常
    
    InputMismatchException - 如果下一个标记与整数正则表达式不匹配，或者超出范围
    
    NoSuchElementException - 如果输入已用尽
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果基数超出范围
  - hasNextShort
```
public boolean hasNextShort()
```
    如果使用nextShort()方法将此扫描器输入中的下一个标记解释为默认基数中的短值，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描器的下一个标记是默认基数中的有效短值时才为true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextShort
```
public boolean hasNextShort(int radix)
```
    如果使用nextShort()方法将此扫描器输入中的下一个标记解释为指定基数中的短值，则返回true。扫描仪不会超过任何输入。
    如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则抛出IllegalArgumentException 。
    
    参数
    
    radix - 用于将令牌解释为短值的基数
    
    结果
    
    当且仅当此扫描器的下一个标记是指定基数中的有效短值时才为true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果基数超出范围
  - nextShort
```
public short nextShort()
```
    将输入的下一个标记扫描为short 。
    调用nextShort()形式的此方法的行为与调用nextShort(radix)完全相同，其中radix是此扫描程序的默认基数。
    
    结果
    
    从输入扫描 short
    
    异常
    
    InputMismatchException - 如果下一个标记与整数正则表达式不匹配，或者超出范围
    
    NoSuchElementException - 如果输入用尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextShort
```
public short nextShort(int radix)
```
    将输入的下一个标记扫描为short 。如果下一个令牌无法转换为有效的短值，则此方法将抛出InputMismatchException ，如下所述。如果翻译成功，扫描仪将超过匹配的输入。
    如果下一个标记与上面定义的Integer正则表达式匹配，则标记将转换为short值，就好像通过删除所有特定于区域设置的前缀，组分隔符和特定于区域设置的后缀，然后通过Character.digit将非ASCII数字映射到ASCII数字，前置如果存在特定于区域设置的负前缀和后缀，则将负号（ - ）传递给具有指定基数的Short.parseShort 。
    
    如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则抛出IllegalArgumentException 。
    
    参数
    
    radix - 用于将令牌解释为短值的基数
    
    结果
    
    short从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个标记与整数正则表达式不匹配，或者超出范围
    
    NoSuchElementException - 如果输入已用尽
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果基数超出范围
  - hasNextInt
```
public boolean hasNextInt()
```
    如果此扫描器输入中的下一个标记可以使用nextInt()方法解释为默认基数中的int值，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描程序的下一个标记是有效的int值时才返回true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextInt
```
public boolean hasNextInt(int radix)
```
    如果此扫描器输入中的下一个标记可以使用nextInt()方法解释为指定基数中的int值，则返回true。扫描仪不会超过任何输入。
    如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则抛出IllegalArgumentException 。
    
    参数
    
    radix - 用于将令牌解释为int值的基数
    
    结果
    
    当且仅当此扫描程序的下一个标记是有效的int值时才返回true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果基数超出范围
  - nextInt
```
public int nextInt()
```
    将输入的下一个标记扫描为int 。
    调用nextInt()形式的此方法的行为与调用nextInt(radix) ，其中radix是此扫描程序的默认基数。
    
    结果
    
    int从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个标记与整数正则表达式不匹配，或者超出范围
    
    NoSuchElementException - 如果输入已用尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextInt
```
public int nextInt(int radix)
```
    将输入的下一个标记扫描为int 。如果下一个令牌无法转换为有效的int值，则此方法将抛出InputMismatchException ，如下所述。如果翻译成功，扫描仪将超过匹配的输入。
    如果下一个标记与上面定义的Integer正则表达式匹配，则标记将转换为int值，就好像通过删除所有特定于区域设置的前缀，组分隔符和特定于区域设置的后缀，然后通过Character.digit将非ASCII数字映射到ASCII数字，前置如果存在特定于区域设置的负前缀和后缀，则使用负号（ - ），并将结果字符串传递给具有指定基数的Integer.parseInt 。
    
    如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则抛出IllegalArgumentException 。
    
    参数
    
    radix - 用于将标记解释为int值的基数
    
    结果
    
    int从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个标记与整数正则表达式不匹配，或者超出范围
    
    NoSuchElementException - 如果输入已用尽
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果基数超出范围
  - hasNextLong
```
public boolean hasNextLong()
```
    如果使用nextLong()方法将此扫描器输入中的下一个标记解释为默认基数中的long值，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描器的下一个标记是有效的长值时才为true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextLong
```
public boolean hasNextLong(int radix)
```
    如果此扫描器输入中的下一个标记可以使用nextLong()方法解释为指定基数中的长值，则返回true。扫描仪不会超过任何输入。
    如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则抛出IllegalArgumentException 。
    
    参数
    
    radix - 用于将令牌解释为长值的基数
    
    结果
    
    当且仅当此扫描器的下一个标记是有效的长值时才为true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果基数超出范围
  - 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 。
    
    如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则抛出IllegalArgumentException 。
    
    参数
    
    radix - 用于将标记解释为int值的基数
    
    结果
    
    从输入扫描 long
    
    异常
    
    InputMismatchException - 如果下一个标记与整数正则表达式不匹配，或者超出范围
    
    NoSuchElementException - 如果输入已用尽
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果基数超出范围
  - hasNextFloat
```
public boolean hasNextFloat()
```
    如果使用nextFloat()方法可以将此扫描器输入中的下一个标记解释为浮点值，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描器的下一个标记是有效的浮点值时才返回true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextFloat
```
public float nextFloat()
```
    将输入的下一个标记扫描为float 。如果下一个令牌无法转换为有效的浮点值，则此方法将抛出InputMismatchException ，如下所述。如果翻译成功，扫描仪将超过匹配的输入。
    如果下一个标记与上面定义的Float正则表达式匹配，则将标记转换为float值，就好像通过删除所有特定于区域设置的前缀，组分隔符和特定于区域设置的后缀，然后通过Character.digit将非ASCII数字映射到ASCII数字，前置如果存在特定于区域设置的负前缀和后缀，则为负号（ - ），并将结果字符串传递给Float.parseFloat 。如果令牌与本地化的NaN或无穷大字符串匹配，则“Nan”或“Infinity”将根据需要传递给Float.parseFloat 。
    
    结果
    
    从输入扫描 float
    
    异常
    
    InputMismatchException - 如果下一个标记与 Float正则表达式不匹配，或者超出范围
    
    NoSuchElementException - 如果输入已用尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextDouble
```
public boolean hasNextDouble()
```
    如果使用nextDouble()方法将此扫描仪输入中的下一个标记解释为double值，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描器的下一个标记是有效的double值时才为true
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextDouble
```
public double nextDouble()
```
    将输入的下一个标记扫描为double 。如果下一个标记无法转换为有效的double值，则此方法将抛出InputMismatchException 。如果翻译成功，扫描仪将超过匹配的输入。
    如果下一个标记与上面定义的Float正则表达式匹配，则标记将转换为double值，就好像通过删除所有特定于区域设置的前缀，组分隔符和特定于区域设置的后缀，然后通过Character.digit将非ASCII数字映射到ASCII数字，前置如果存在特定于区域设置的负前缀和后缀，则将负号（ - ）传递给Double.parseDouble 。如果令牌与本地化的NaN或无穷大字符串匹配，则“Nan”或“Infinity”将根据需要传递给Double.parseDouble 。
    
    结果
    
    从输入扫描 double
    
    异常
    
    InputMismatchException - 如果下一个标记与 Float正则表达式不匹配，或者超出范围
    
    NoSuchElementException - 如果输入已用尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextBigInteger
```
public boolean hasNextBigInteger()
```
    如果使用nextBigInteger()方法将此扫描器输入中的下一个标记解释为默认基数中的BigInteger ，则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描器的下一个令牌是有效的 BigInteger
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - hasNextBigInteger
```
public boolean hasNextBigInteger(int radix)
```
    如果此扫描器输入中的下一个标记可以使用nextBigInteger()方法在指定的基数中解释为BigInteger ，则返回true。扫描仪不会超过任何输入。
    如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则抛出IllegalArgumentException 。
    
    参数
    
    radix - 用于将标记解释为整数的基数
    
    结果
    
    当且仅当此扫描程序的下一个标记是有效的 BigInteger
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果基数超出范围
  - nextBigInteger
```
public BigInteger nextBigInteger()
```
    将输入的下一个标记扫描为BigInteger 。
    调用nextBigInteger()形式的此方法的行为与调用nextBigInteger(radix) ，其中radix是此扫描程序的默认基数。
    
    结果
    
    BigInteger从输入扫描
    
    异常
    
    InputMismatchException - 如果下一个标记与整数正则表达式不匹配，或者超出范围
    
    NoSuchElementException - 如果输入已用尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextBigInteger
```
public BigInteger nextBigInteger(int radix)
```
    将输入的下一个标记扫描为BigInteger 。
    如果下一个标记与上面定义的Integer正则表达式匹配，则标记将转换为BigInteger值，就好像通过删除所有组分隔符，通过Character.digit将非ASCII数字映射为ASCII数字，并将结果字符串传递给BigInteger(String, int)构造函数指定的基数。
    
    如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则抛出IllegalArgumentException 。
    
    参数
    
    radix - 用于解释令牌的基数
    
    结果
    
    从输入扫描 BigInteger
    
    异常
    
    InputMismatchException - 如果下一个标记与整数正则表达式不匹配，或者超出范围
    
    NoSuchElementException - 如果输入已用尽
    
    IllegalStateException - 如果此扫描仪已关闭
    
    IllegalArgumentException - 如果基数超出范围
  - hasNextBigDecimal
```
public boolean hasNextBigDecimal()
```
    如果此扫描器输入中的下一个标记可以使用nextBigDecimal()方法解释为BigDecimal则返回true。扫描仪不会超过任何输入。
    
    结果
    
    当且仅当此扫描器的下一个令牌是有效的 BigDecimal
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
  - nextBigDecimal
```
public BigDecimal nextBigDecimal()
```
    将输入的下一个标记扫描为BigDecimal 。
    如果下一个标记与上面定义的Decimal正则表达式匹配，则标记将转换为BigDecimal值，就好像通过删除所有组分隔符，通过Character.digit将非ASCII数字映射为ASCII数字，并将结果字符串传递给BigDecimal(String)构造函数。
    
    结果
    
    从输入扫描 BigDecimal
    
    异常
    
    InputMismatchException - 如果下一个标记与 十进制正则表达式不匹配，或者超出范围
    
    NoSuchElementException - 如果输入已用尽
    
    IllegalStateException - 如果此扫描仪已关闭
  - reset
```
public Scanner reset()
```
    重置此扫描仪。
    重置扫描器会丢弃所有可能已经通过调用改变了明确的状态信息useDelimiter() ， useLocale() ，或useRadix() 。
    
    调用scanner.reset()形式的此方法的行为与调用的方式完全相同
    
    scanner.useDelimiter("\\p{javaWhitespace}+") .useLocale(Locale.getDefault(Locale.Category.FORMAT)) .useRadix(10);
    结果
    
    这个扫描仪
    
    从以下版本开始：
    
    1.6
  - tokens
```
public Stream<String> tokens()
```
    从此扫描程序返回分隔符分隔的标记流。该流包含将从此扫描器的当前状态开始返回的相同标记，方法是重复调用next()方法，直到hasNext()方法返回false。
    生成的流是顺序的并且是有序的。所有流元素都是非null。
    
    使用该扫描仪的当前状态，在启动终端流操作时开始扫描。对close()和ioException()以外的此扫描仪上的任何方法的后续调用可能会返回未定义的结果，或者可能会对返回的流造成不确定的影响。返回流的源Spliterator是快速失败的 ，并且如果在流管道执行期间检测到任何此类调用，则将尽最大努力抛出ConcurrentModificationException 。
    
    流管道执行完成后，此扫描程序将处于不确定状态，无法重复使用。
    
    如果此扫描程序包含必须释放的资源，则应通过调用其close()方法或关闭返回的流来关闭此扫描程序。关闭流将关闭底层扫描程序。如果在调用此方法时扫描程序已关闭，或者在流管道执行期间关闭此扫描程序，则抛出IllegalStateException 。
    
    此方法可能会阻止等待更多输入。
    API Note:
    
    例如，以下代码将从字符串创建逗号分隔的标记列表：
    List<String> result = new Scanner("abc,def,,ghi") .useDelimiter(",") .tokens() .collect(Collectors.toList());
    
    结果列表将包含"abc" ， "def" ，空字符串，和"ghi" 。
    
    结果
    
    令牌字符串的连续流
    
    异常
    
    IllegalStateException - 如果此扫描仪已关闭
    
    从以下版本开始：
    
    9
  - findAll
```
public Stream<MatchResult> findAll(Pattern pattern)
```
    返回此扫描程序的匹配结果流。只要findWithinHorizon()找到匹配项，流就会以相同的顺序包含相同的结果，通过调用findWithinHorizon(pattern, 0)和match()返回。
    生成的流是顺序的并且是有序的。所有流元素都是非null。
    
    使用该扫描仪的当前状态，在启动终端流操作时开始扫描。对close()和ioException()以外的此扫描仪上的任何方法的后续调用可能会返回未定义的结果，或者可能会对返回的流造成未定义的影响。返回的流的源Spliterator是快速失败的 ，如果在流管道执行期间检测到任何此类调用，则将尽最大努力抛出ConcurrentModificationException 。
    
    流管道执行完成后，此扫描程序将处于不确定状态，无法重复使用。
    
    如果此扫描程序包含必须释放的资源，则应通过调用其close()方法或关闭返回的流来关闭此扫描程序。关闭流将关闭底层扫描程序。如果在调用此方法时扫描程序已关闭，或者在流管道执行期间关闭此扫描程序，则抛出IllegalStateException 。
    
    与findWithinHorizon()方法一样，此方法可能会阻止等待其他输入，并且可能会缓冲搜索匹配的无限量输入。
    API Note:
    
    例如，以下代码将读取文件并返回由七个或更多拉丁大写字母组成的所有字符序列的列表：
    try (Scanner sc = new Scanner(Path.of("input.txt"))) { Pattern pat = Pattern.compile("[A-Z]{7,}"); List<String> capWords = sc.findAll(pat) .map(MatchResult::group) .collect(Collectors.toList()); }
    
    参数
    
    pattern - 要匹配的模式
    
    结果
    
    连续的匹配结果流
    
    异常
    
    NullPointerException - 如果pattern为null
    
    IllegalStateException - 如果此扫描仪已关闭
    
    从以下版本开始：
    
    9
  - findAll
```
public Stream<MatchResult> findAll(String patString)
```
    返回与提供的模式字符串匹配的匹配结果流。效果等同于以下代码：
    scanner.findAll(Pattern.compile(patString))
    参数
    
    patString - 模式字符串
    
    结果
    
    连续的匹配结果流
    
    异常
    
    NullPointerException - 如果patString为null
    
    IllegalStateException - 如果此扫描仪已关闭
    
    PatternSyntaxException - 如果正则表达式的语法无效
    
    从以下版本开始：
    
    9
    
    另请参见：
    
    Pattern

Class Scanner

Localized numbers

Number syntax

构造方法摘要

方法摘要

声明方法的类 java.lang.Object

声明方法的接口 java.util.Iterator

构造方法详细信息

Scanner

Scanner

Scanner

Scanner

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

tokens

findAll