java.lang.Object

java.util.Scanner

所有已实现的接口：: Closeable , AutoCloseable , Iterator<String>

public final class Scanner extends Object implements Iterator <String >, Closeable

一个简单的文本扫描器，可以使用正则表达式解析原始类型和字符串。

Scanner 使用分隔符模式将其输入分解为标记，默认情况下匹配空格。然后可以使用各种 next 方法将生成的标记转换为不同类型的值。

例如，这段代码允许用户从控制台读取一个数字。

  var con = System.console();
  if (con != null) {
    Scanner sc = new Scanner(con.reader());
    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();

扫描仪使用的默认空白分隔符被 Character.isWhitespace() 识别。 reset() 方法会将扫描器的定界符的值重置为默认的空白定界符，而不管之前是否更改过。

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

next() 和 hasNext() 方法及其配套方法（例如 nextInt() 和 hasNextInt() ）首先跳过与定界符模式匹配的任何输入，然后尝试返回下一个标记。 hasNext() 和 next() 方法都可能阻塞等待进一步输入。 hasNext() 方法是否阻塞与其关联的 next() 方法是否阻塞无关。 tokens() 方法也可能会阻塞等待输入。

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

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

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

扫描器可以从任何实现了Readable 接口的对象中读取文本。如果对底层可读对象的 read() 方法的调用抛出 IOException ，则扫描器假定已到达输入末尾。底层可读对象最近抛出的 IOException 可以通过 ioException() 方法获取。

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

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

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

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

本地化号码

此类的实例能够扫描标准格式以及扫描仪区域设置格式的数字。扫描仪的初始locale 是 Locale.getDefault(Locale.Category.FORMAT) 方法返回的值；它可以通过 useLocale() 方法更改。 reset() 方法会将扫描仪的区域设置值重置为初始区域设置，而不管之前是否更改过。

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

LocalGroupSeparator

用于分隔千组的字符，IE， dfs. getGroupingSeparator()

LocalDecimalSeparator

用于小数点的字符，IE， dfs. getDecimalSeparator()

LocalPositivePrefix

出现在正数之前的字符串（可能为空），IE， df. getPositivePrefix()

LocalPositiveSuffix

出现在正数之后的字符串（可能为空），IE， df. getPositiveSuffix()

LocalNegativePrefix

出现在负数之前的字符串（可能为空），IE， df. getNegativePrefix()

LocalNegativeSuffix

负数后出现的字符串（可能为空），IE， df. getNegativeSuffix()

本地NaN

表示浮点值的非数字的字符串，IE， dfs. getNaN()

LocalInfinity

表示浮点值无穷大的字符串，IE， dfs. getInfinity()

数字句法

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

NonAsciiDigit:: Character.isDigit (c) 返回 true 的非 ASCII 字符 c
Non0Digit:: [1- Rmax] | NonASCIIDigit
数字:: [0- Rmax] | NonASCIIDigit
GroupedNumeral:: ( Non0Digit 数字? 数字?; ( LocalGroupSeparator 数字数字数字 )+ )
Numeral:: ( ( 数字+ ) | GroupedNumeral )
Integer:: ( [-+]? ( Numeral ) ); | LocalPositivePrefix Numeral LocalPositiveSuffix; | LocalNegativePrefix Numeral LocalNegativeSuffix
DecimalNumeral:: Numeral; | Numeral LocalDecimalSeparator 数字*; | LocalDecimalSeparator 数字+
Exponent:: ( [eE] [+-]? 数字+ )
Decimal:: ( [-+]? DecimalNumeral Exponent? ); | LocalPositivePrefix DecimalNumeral LocalPositiveSuffix Exponent?; | LocalNegativePrefix DecimalNumeral LocalNegativeSuffix Exponent?
HexFloat:: [-+]? 0[xX][0-9a-fA-F]*\.[0-9a-fA-F]+ ([pP][-+]?[0-9]+)?
NonNumber:: NaN | LocalNan | Infinity | LocalInfinity
SignedNonNumber:: ( [-+]? NonNumber ); | LocalPositivePrefix NonNumber LocalPositiveSuffix; | LocalNegativePrefix NonNumber LocalNegativeSuffix
Float :: Decimal | 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 this 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”创建的不区分大小写的模式将此扫描器输入中的下一个标记解释为boolean，则返回 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()

返回此 Scanner 的底层 Readable 最后抛出的 IOException。

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()

将输入的下一个标记扫描为boolean并返回该值。

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

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 生成从指定输入流扫描的值。使用默认字符集将流中的字节转换为字符。
  参数：
  
  source - 要扫描的输入流
  
  参见：
  
  Charset.defaultCharset()
- 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 生成从指定文件扫描的值。使用默认字符集将文件中的字节转换为字符。
  参数：
  
  source - 要扫描的文件
  
  抛出：
  
  FileNotFoundException - 如果找不到源
  
  参见：
  
  Charset.defaultCharset()
- 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 生成从指定文件扫描的值。使用默认字符集将文件中的字节转换为字符。
  参数：
  
  source - 要扫描的文件的路径
  
  抛出：
  
  IOException - 如果 I/O 错误发生开源
  
  自从：
  
  1.7
  
  参见：
  
  Charset.defaultCharset()
- 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 生成从指定通道扫描的值。使用默认字符集将来自源的字节转换为字符。
  参数：
  
  source - 要扫描的通道
  
  参见：
  
  Charset.defaultCharset()
- 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()
  
  关闭此扫描仪。
  如果此扫描器尚未关闭，那么如果其底层可读的也实现了 Closeable 接口，那么将调用可读对象的 close 方法。如果此扫描仪已关闭，则调用此方法将无效。
  
  在扫描仪关闭后尝试执行搜索操作将导致 IllegalStateException 。
  
  指定者：
  
  close 在接口 AutoCloseable 中
  
  指定者：
  
  close 在接口 Closeable 中
- ioException
  
  public IOException ioException()
  
  返回此 Scanner 的底层 Readable 最后抛出的 IOException。如果不存在此类异常，则此方法返回 null。
  
  返回：
  
  此扫描仪的可读性抛出的最后一个异常
- delimiter
  
  public Pattern delimiter()
  
  返回 Pattern this Scanner 当前用于匹配定界符。
  
  返回：
  
  此扫描仪的定界图案。
- useDelimiter
  
  public Scanner useDelimiter(Pattern pattern)
  
  将此扫描仪的定界模式设置为指定模式。
  
  参数：
  
  pattern - 定界模式
  
  返回：
  
  这个扫描仪
- useDelimiter
  
  public Scanner useDelimiter(String pattern)
  
  将此扫描器的定界模式设置为从指定的 String 构造的模式。
  调用 useDelimiter(pattern) 形式的此方法的行为方式与调用 useDelimiter(Pattern.compile(pattern)) 的方式完全相同。
  
  调用 reset() 方法会将扫描器的分隔符设置为 default 。
  
  参数：
  
  pattern - 指定定界模式的字符串
  
  返回：
  
  这个扫描仪
- locale
  
  public Locale locale()
  
  返回此扫描仪的区域设置。
  扫描器的区域设置会影响其默认原始匹配正则表达式的许多元素；参见上面的本地化号码。
  
  返回：
  
  此扫描仪的locale
- useLocale
  
  public Scanner useLocale(Locale locale)
  
  将此扫描仪的区域设置为指定的区域设置。
  扫描器的区域设置会影响其默认原始匹配正则表达式的许多元素；参见上面的本地化号码。
  
  调用 reset() 方法会将扫描仪的locale设置为初始locale 。
  
  参数：
  
  locale - 指定要使用的locale的字符串
  
  返回：
  
  这个扫描仪
- radix
  
  public int radix()
  
  返回此扫描仪的默认基数。
  扫描仪的基数会影响其默认数字匹配正则表达式的元素；参见上面的本地化号码。
  
  返回：
  
  此扫描仪的默认基数
- useRadix
  
  public Scanner useRadix(int radix)
  
  将此扫描仪的默认基数设置为指定的基数。
  扫描仪的基数会影响其默认数字匹配正则表达式的元素；参见上面的本地化号码。
  
  如果基数小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX ，则抛出 IllegalArgumentException。
  
  调用 reset() 方法会将扫描仪的基数设置为 10 。
  
  参数：
  
  radix - 扫描数字时使用的基数
  
  返回：
  
  这个扫描仪
  
  抛出：
  
  IllegalArgumentException - 如果基数超出范围
- match
  
  public MatchResult match()
  
  返回本扫描仪最后一次扫描操作的匹配结果。如果未执行任何匹配，或者最后一次匹配不成功，则此方法抛出 IllegalStateException。
  Scanner 的各种 next 方法在完成且未抛出异常的情况下提供匹配结果。例如，在调用返回 int 的 nextInt() 方法后，此方法返回 MatchResult 以搜索上面定义的 Integer 正则表达式。类似地， findInLine() 、 findWithinHorizon() 和 skip() 方法将在成功时进行匹配。
  
  返回：
  
  最后一次匹配操作的匹配结果
  
  抛出：
  
  IllegalStateException - 如果没有可用的匹配结果
- toString
  
  public String toString()
  
  返回此 Scanner 的字符串表示形式。 Scanner 的字符串表示包含可能对调试有用的信息。确切的格式未指定。
  
  重写：
  
  toString 在类 Object 中
  
  返回：
  
  此扫描仪的字符串表示
- hasNext
  
  public boolean hasNext()
  
  如果此扫描器在其输入中有另一个标记，则返回 true。此方法可能会在等待输入扫描时阻塞。扫描仪不会前进超过任何输入。
  指定者：
  
  hasNext 在接口 Iterator<String> 中
  
  返回：
  
  当且仅当此扫描器有另一个令牌时才为真
  
  抛出：
  
  IllegalStateException - 如果此扫描仪已关闭
  
  参见：
  
  Iterator
- next
  
  public String next()
  
  从该扫描器中查找并返回下一个完整的标记。一个完整的令牌之前和之后是与定界符模式匹配的输入。此方法可能会在等待输入扫描时阻塞，即使之前调用 hasNext() 返回了 true 。
  指定者：
  
  next 在接口 Iterator<String> 中
  
  返回：
  
  下一个标记
  
  抛出：
  
  NoSuchElementException - 如果没有更多令牌可用
  
  IllegalStateException - 如果此扫描仪已关闭
  
  参见：
  
  Iterator
- remove
  
  public void remove()
  
  Iterator 的此实现不支持删除操作。
  指定者：
  
  remove 在接口 Iterator<String> 中
  
  抛出：
  
  UnsupportedOperationException - 如果调用此方法。
  
  参见：
  
  Iterator
- hasNext
  
  public boolean hasNext(String pattern)
  
  如果下一个标记匹配从指定字符串构造的模式，则返回 true。扫描仪不会前进超过任何输入。
  调用 hasNext(pattern) 形式的此方法的行为方式与调用 hasNext(Pattern.compile(pattern)) 的方式完全相同。
  
  参数：
  
  pattern - 指定要扫描的模式的字符串
  
  返回：
  
  当且仅当此扫描器具有与指定模式匹配的另一个标记时才为真
  
  抛出：
  
  IllegalStateException - 如果此扫描仪已关闭
- next
  
  public String next(String pattern)
  
  如果下一个标记与从指定字符串构造的模式匹配，则返回下一个标记。如果匹配成功，则扫描器前进到与模式匹配的输入。
  调用 next(pattern) 形式的此方法的行为方式与调用 next(Pattern.compile(pattern)) 的方式完全相同。
  
  参数：
  
  pattern - 指定要扫描的模式的字符串
  
  返回：
  
  下一个标记
  
  抛出：
  
  NoSuchElementException - 如果没有这样的令牌可用
  
  IllegalStateException - 如果此扫描仪已关闭
- hasNext
  
  public boolean hasNext(Pattern pattern)
  
  如果下一个完整标记与指定模式匹配，则返回 true。一个完整的标记由匹配定界符模式的输入作为前缀和后缀。此方法可能会在等待输入时阻塞。扫描仪不会前进超过任何输入。
  
  参数：
  
  pattern - 要扫描的模式
  
  返回：
  
  当且仅当此扫描器具有与指定模式匹配的另一个标记时才为真
  
  抛出：
  
  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) ）。
  
  如果 horizon 是 0 ，则 horizon 被忽略并且此方法继续搜索输入以寻找无边界的指定模式。在这种情况下，它可能会缓冲所有搜索模式的输入。
  
  如果 horizon 为负，则抛出 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”创建的不区分大小写的模式将此扫描器输入中的下一个标记解释为boolean，则返回 true。扫描仪不会前进超过匹配的输入。
  
  返回：
  
  当且仅当此扫描器的下一个标记是有效的boolean时才为真
  
  抛出：
  
  IllegalStateException - 如果此扫描仪已关闭
- nextBoolean
  
  public boolean nextBoolean()
  
  将输入的下一个标记扫描为boolean并返回该值。如果无法将下一个标记转换为有效的boolean，此方法将抛出 InputMismatchException。如果匹配成功，则扫描器前进超过匹配的输入。
  
  返回：
  
  从输入扫描的boolean
  
  抛出：
  
  InputMismatchException - 如果下一个标记不是有效的boolean
  
  NoSuchElementException - 如果输入耗尽
  
  IllegalStateException - 如果此扫描仪已关闭
- hasNextByte
  
  public boolean hasNextByte()
  
  如果可以使用 nextByte() 方法将此扫描器输入中的下一个标记解释为默认基数中的字节值，则返回 true。扫描仪不会前进超过任何输入。
  
  返回：
  
  当且仅当此扫描器的下一个标记是有效字节值时才为真
  
  抛出：
  
  IllegalStateException - 如果此扫描仪已关闭
- hasNextByte
  
  public boolean hasNextByte(int radix)
  
  如果可以使用 nextByte() 方法将此扫描器输入中的下一个标记解释为指定基数中的字节值，则返回 true。扫描仪不会前进超过任何输入。
  如果基数小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX ，则抛出 IllegalArgumentException。
  
  参数：
  
  radix - 用于将令牌解释为字节值的基数
  
  返回：
  
  当且仅当此扫描器的下一个标记是有效字节值时才为真
  
  抛出：
  
  IllegalStateException - 如果此扫描仪已关闭
  
  IllegalArgumentException - 如果基数超出范围
- nextByte
  
  public byte nextByte()
  
  将输入的下一个标记扫描为 byte 。
  调用 nextByte() 形式的此方法的行为方式与调用 nextByte(radix) 的方式完全相同，其中 radix 是此扫描器的默认基数。
  
  返回：
  
  从输入扫描的 byte
  
  抛出：
  
  InputMismatchException - 如果下一个标记不匹配Integer正则表达式，或者超出范围
  
  NoSuchElementException - 如果输入耗尽
  
  IllegalStateException - 如果此扫描仪已关闭
- nextByte
  
  public byte nextByte(int radix)
  
  将输入的下一个标记扫描为 byte 。如果无法将下一个标记转换为如下所述的有效字节值，则此方法将抛出 InputMismatchException。如果翻译成功，扫描器会前进到匹配的输入。
  如果下一个标记与上面定义的 Integer 正则表达式匹配，则标记被转换为 byte 值，就好像通过删除所有区域设置特定前缀、组分隔符和区域设置特定后缀，然后通过 Character.digit 将非 ASCII 数字映射到 ASCII 数字，在前面加上如果存在特定于locale的负前缀和后缀，则为负号 (-)，并将结果字符串传递给具有指定基数的 Byte.parseByte 。
  
  如果基数小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX ，则抛出 IllegalArgumentException。
  
  参数：
  
  radix - 用于将令牌解释为字节值的基数
  
  返回：
  
  从输入扫描的 byte
  
  抛出：
  
  InputMismatchException - 如果下一个标记不匹配Integer正则表达式，或者超出范围
  
  NoSuchElementException - 如果输入耗尽
  
  IllegalStateException - 如果此扫描仪已关闭
  
  IllegalArgumentException - 如果基数超出范围
- hasNextShort
  
  public boolean hasNextShort()
  
  如果可以使用 nextShort() 方法将此扫描器输入中的下一个标记解释为默认基数中的短值，则返回 true。扫描仪不会前进超过任何输入。
  
  返回：
  
  当且仅当此扫描器的下一个标记是默认基数中的有效短值时才为真
  
  抛出：
  
  IllegalStateException - 如果此扫描仪已关闭
- hasNextShort
  
  public boolean hasNextShort(int radix)
  
  如果可以使用 nextShort() 方法将此扫描器输入中的下一个标记解释为指定基数中的短值，则返回 true。扫描仪不会前进超过任何输入。
  如果基数小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX ，则抛出 IllegalArgumentException。
  
  参数：
  
  radix - 用于将令牌解释为短值的基数
  
  返回：
  
  当且仅当此扫描器的下一个标记是指定基数中的有效短值时才为真
  
  抛出：
  
  IllegalStateException - 如果此扫描仪已关闭
  
  IllegalArgumentException - 如果基数超出范围
- nextShort
  
  public short nextShort()
  
  将输入的下一个标记扫描为 short 。
  调用 nextShort() 形式的此方法的行为方式与调用 nextShort(radix) 的方式完全相同，其中 radix 是此扫描器的默认基数。
  
  返回：
  
  从输入扫描的 short
  
  抛出：
  
  InputMismatchException - 如果下一个标记不匹配Integer正则表达式，或者超出范围
  
  NoSuchElementException - 如果输入耗尽
  
  IllegalStateException - 如果此扫描仪已关闭
- nextShort
  
  public short nextShort(int radix)
  
  将输入的下一个标记扫描为 short 。如果无法将下一个标记转换为有效的短值，则此方法将抛出 InputMismatchException，如下所述。如果翻译成功，扫描器会前进到匹配的输入。
  如果下一个标记与上面定义的 Integer 正则表达式匹配，则标记被转换为 short 值，就好像通过删除所有区域设置特定前缀、组分隔符和区域设置特定后缀，然后通过 Character.digit 将非 ASCII 数字映射到 ASCII 数字，在前面加上如果存在特定于locale的负前缀和后缀，则为负号 (-)，并将结果字符串传递给具有指定基数的 Short.parseShort 。
  
  如果基数小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX ，则抛出 IllegalArgumentException。
  
  参数：
  
  radix - 用于将令牌解释为短值的基数
  
  返回：
  
  从输入扫描的 short
  
  抛出：
  
  InputMismatchException - 如果下一个标记不匹配Integer正则表达式，或者超出范围
  
  NoSuchElementException - 如果输入耗尽
  
  IllegalStateException - 如果此扫描仪已关闭
  
  IllegalArgumentException - 如果基数超出范围
- hasNextInt
  
  public boolean hasNextInt()
  
  如果可以使用 nextInt() 方法将此扫描器输入中的下一个标记解释为默认基数中的 int 值，则返回 true。扫描仪不会前进超过任何输入。
  
  返回：
  
  当且仅当此扫描器的下一个标记是有效的 int 值时才为真
  
  抛出：
  
  IllegalStateException - 如果此扫描仪已关闭
- hasNextInt
  
  public boolean hasNextInt(int radix)
  
  如果可以使用 nextInt() 方法将此扫描器输入中的下一个标记解释为指定基数中的 int 值，则返回 true。扫描仪不会前进超过任何输入。
  如果基数小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX ，则抛出 IllegalArgumentException。
  
  参数：
  
  radix - 用于将令牌解释为 int 值的基数
  
  返回：
  
  当且仅当此扫描器的下一个标记是有效的 int 值时才为真
  
  抛出：
  
  IllegalStateException - 如果此扫描仪已关闭
  
  IllegalArgumentException - 如果基数超出范围
- nextInt
  
  public int nextInt()
  
  将输入的下一个标记扫描为 int 。
  调用 nextInt() 形式的此方法的行为方式与调用 nextInt(radix) 的方式完全相同，其中 radix 是此扫描器的默认基数。
  
  返回：
  
  从输入扫描的 int
  
  抛出：
  
  InputMismatchException - 如果下一个标记不匹配Integer正则表达式，或者超出范围
  
  NoSuchElementException - 如果输入耗尽
  
  IllegalStateException - 如果此扫描仪已关闭
- nextInt
  
  public int nextInt(int radix)
  
  将输入的下一个标记扫描为 int 。如果无法将下一个标记转换为有效的 int 值，则此方法将抛出 InputMismatchException，如下所述。如果翻译成功，扫描器会前进到匹配的输入。
  如果下一个标记与上面定义的 Integer 正则表达式匹配，则标记被转换为 int 值，就好像通过删除所有区域设置特定前缀、组分隔符和区域设置特定后缀，然后通过 Character.digit 将非 ASCII 数字映射到 ASCII 数字，在前面加上如果存在特定于locale的负前缀和后缀，则为负号 (-)，并将结果字符串传递给具有指定基数的 Integer.parseInt 。
  
  如果基数小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX ，则抛出 IllegalArgumentException。
  
  参数：
  
  radix - 用于将令牌解释为 int 值的基数
  
  返回：
  
  从输入扫描的 int
  
  抛出：
  
  InputMismatchException - 如果下一个标记不匹配Integer正则表达式，或者超出范围
  
  NoSuchElementException - 如果输入耗尽
  
  IllegalStateException - 如果此扫描仪已关闭
  
  IllegalArgumentException - 如果基数超出范围
- hasNextLong
  
  public boolean hasNextLong()
  
  如果可以使用 nextLong() 方法将此扫描器输入中的下一个标记解释为默认基数中的长值，则返回 true。扫描仪不会前进超过任何输入。
  
  返回：
  
  当且仅当此扫描器的下一个标记是有效的 long 值时才为真
  
  抛出：
  
  IllegalStateException - 如果此扫描仪已关闭
- hasNextLong
  
  public boolean hasNextLong(int radix)
  
  如果可以使用 nextLong() 方法将此扫描器输入中的下一个标记解释为指定基数中的长值，则返回 true。扫描仪不会前进超过任何输入。
  如果基数小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX ，则抛出 IllegalArgumentException。
  
  参数：
  
  radix - 用于将令牌解释为长值的基数
  
  返回：
  
  当且仅当此扫描器的下一个标记是有效的 long 值时才为真
  
  抛出：
  
  IllegalStateException - 如果此扫描仪已关闭
  
  IllegalArgumentException - 如果基数超出范围
- nextLong
  
  public long nextLong()
  
  将输入的下一个标记扫描为 long 。
  调用 nextLong() 形式的此方法的行为方式与调用 nextLong(radix) 的方式完全相同，其中 radix 是此扫描器的默认基数。
  
  返回：
  
  从输入扫描的 long
  
  抛出：
  
  InputMismatchException - 如果下一个标记不匹配Integer正则表达式，或者超出范围
  
  NoSuchElementException - 如果输入耗尽
  
  IllegalStateException - 如果此扫描仪已关闭
- nextLong
  
  public long nextLong(int radix)
  
  将输入的下一个标记扫描为 long 。如果无法将下一个标记转换为有效的 long 值，则此方法将抛出 InputMismatchException，如下所述。如果翻译成功，扫描器会前进到匹配的输入。
  如果下一个标记与上面定义的 Integer 正则表达式匹配，则标记被转换为 long 值，就好像通过删除所有区域设置特定前缀、组分隔符和区域设置特定后缀，然后通过 Character.digit 将非 ASCII 数字映射到 ASCII 数字，在前面加上如果存在特定于locale的负前缀和后缀，则为负号 (-)，并将结果字符串传递给具有指定基数的 Long.parseLong 。
  
  如果基数小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX ，则抛出 IllegalArgumentException。
  
  参数：
  
  radix - 用于将令牌解释为 int 值的基数
  
  返回：
  
  从输入扫描的 long
  
  抛出：
  
  InputMismatchException - 如果下一个标记不匹配Integer正则表达式，或者超出范围
  
  NoSuchElementException - 如果输入耗尽
  
  IllegalStateException - 如果此扫描仪已关闭
  
  IllegalArgumentException - 如果基数超出范围
- hasNextFloat
  
  public boolean hasNextFloat()
  
  如果可以使用 nextFloat() 方法将此扫描器输入中的下一个标记解释为浮点值，则返回 true。扫描仪不会前进超过任何输入。
  
  返回：
  
  当且仅当此扫描器的下一个标记是有效的浮点值时才为真
  
  抛出：
  
  IllegalStateException - 如果此扫描仪已关闭
- nextFloat
  
  public float nextFloat()
  
  将输入的下一个标记扫描为 float 。如果无法将下一个标记转换为有效的浮点值，则此方法将抛出 InputMismatchException，如下所述。如果翻译成功，扫描器会前进到匹配的输入。
  如果下一个标记与上面定义的 Float 正则表达式匹配，则标记被转换为 float 值，就好像通过删除所有特定于区域设置的前缀、组分隔符和特定于区域设置的后缀，然后通过 Character.digit 将非 ASCII 数字映射到 ASCII 数字，在前面加上如果存在特定于locale的负前缀和后缀，则为负号 (-)，并将结果字符串传递给 Float.parseFloat 。如果令牌与本地化的 NaN 或无穷大字符串匹配，则“Nan”或“Infinity”会根据需要传递给 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 数字，在前面加上如果存在特定于locale的负前缀和后缀，则为负号 (-)，并将结果字符串传递给 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 - 如果下一个标记不匹配Integer正则表达式，或者超出范围
  
  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 - 如果下一个标记不匹配Integer正则表达式，或者超出范围
  
  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 - 如果下一个标记不匹配Decimal正则表达式，或者超出范围
  
  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。
  生成的流是顺序的和有序的。所有流元素都是非空的。
  
  使用此扫描器的当前状态，扫描在终端流操作启动时开始。随后调用此扫描仪上除 close() 和 ioException() 之外的任何方法可能会返回未定义的结果或可能对返回的流造成未定义的影响。返回的流的源 Spliterator 是 fail-fast，如果在流管道执行期间检测到任何此类调用，将尽最大努力抛出 ConcurrentModificationException 。
  
  流管道执行完成后，此扫描器处于不确定状态且无法重复使用。
  
  如果此扫描器包含必须释放的资源，则应关闭此扫描器，方法是调用其 close() 方法或关闭返回的流。关闭流将关闭底层扫描器。如果调用此方法时扫描器已关闭，或者如果此扫描器在流管道执行期间关闭，则抛出 IllegalStateException。
  
  此方法可能会阻止等待更多输入。
  API 注意：
  
  例如，以下代码将从字符串创建逗号分隔标记列表：
  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() 返回相同的结果。
  生成的流是顺序的和有序的。所有流元素都是非空的。
  
  使用此扫描器的当前状态，扫描在终端流操作启动时开始。随后调用此扫描仪上除 close() 和 ioException() 之外的任何方法可能会返回未定义的结果或可能对返回的流造成未定义的影响。返回的流的源 Spliterator 是 fail-fast，如果在流管道执行期间检测到任何此类调用，将尽最大努力抛出 ConcurrentModificationException 。
  
  流管道执行完成后，此扫描器处于不确定状态且无法重复使用。
  
  如果此扫描器包含必须释放的资源，则应关闭此扫描器，方法是调用其 close() 方法或关闭返回的流。关闭流将关闭底层扫描器。如果调用此方法时扫描器已关闭，或者如果此扫描器在流管道执行期间关闭，则抛出 IllegalStateException。
  
  与 findWithinHorizon() 方法一样，此方法可能会阻止等待其他输入，并且可能会缓冲无限量的输入以搜索匹配项。
  API 注意：
  
  例如，以下代码将读取一个文件并返回由七个或更多拉丁大写字母组成的所有字符序列的列表：
  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 - 如果模式为空
  
  IllegalStateException - 如果此扫描仪已关闭
  
  自从：
  
  9
- findAll
  
  public Stream <MatchResult > findAll(String patString)
  返回匹配提供的模式字符串的匹配结果流。效果相当于下面的代码：
  scanner.findAll(Pattern.compile(patString))
  参数：
  
  patString - 模式字符串
  
  返回：
  
  匹配结果的顺序流
  
  抛出：
  
  NullPointerException - 如果 patString 为空
  
  IllegalStateException - 如果此扫描仪已关闭
  
  PatternSyntaxException - 如果正则表达式的语法无效
  
  自从：
  
  9
  
  参见：
  
  Pattern

类 Scanner

本地化号码

数字句法

构造方法总结

方法总结

在类 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