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()方法都可能阻塞等待更多输入。 tokens()方法也可能会阻塞等待输入。

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

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

"\\s+"将不返回空令牌，因为它匹配多个分隔符的实例。分隔模式 "\\s"可能会返回空令牌，因为它一次只传递一个空格。

Readable接口的任何对象中读取文本。如果基础可读的 read()方法的调用引发 IOException，则扫描器会假定已到达输入的末尾。可以通过 ioException()方法检索基础可读对象抛出的最近的 IOException。

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

Scanner在没有外部同步的情况下不适用于多线程使用。

null参数传递给 Scanner的任何方法都将导致抛出 NullPointerException。

useRadix(int)方法设置了不同的基数。无论以前是否更改， reset()方法都将扫描器的基数值重置为 10。

本地化数字

初始区域设置是由 Locale.getDefault(Locale.Category.FORMAT)方法返回的值；可以通过 useLocale()方法更改。无论以前是否更改， reset()方法都将扫描器的区域设置值重置为初始区域设置。

DecimalFormat对象 df及其和 DecimalFormatSymbols对象 dfs。

LocalGroupSeparator

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

LocalDecimalSeparator

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

LocalPositivePrefix

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

LocalPositiveSuffix

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

LocalNegativePrefix

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

LocalNegativeSuffix

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

LocalNaN

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

LocalInfinity

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

数字语法

非ASCII数字:: 一个非ASCII字符c，其中 Character.isDigit(c) 返回true
非0数字:: [1-Rmax] | 非ASCII数字
数字:: [0-Rmax] | 非ASCII数字
分组数字:: ( 非0数字 数字? 数字?; ( 本地分组分隔符 数字数字数字 )+ )
数值:: ( ( 数字+ ) | 分组数字 )
整数:: ( [-+]? ( 数值 ) ); | 本地正数前缀 数值 本地正数后缀; | 本地负数前缀 数值 本地负数后缀
十进制数:: 数值; | 数值 本地小数分隔符 数字*; | 本地小数分隔符 数字+
指数:: ( [eE] [+-]? 数字+ )
十进制:: ( [-+]? 十进制数 指数? ); | 本地正数前缀 十进制数 本地正数后缀 指数?; | 本地负数前缀 十进制数 本地负数后缀 指数?
十六进制浮点数:: [-+]? 0[xX][0-9a-fA-F]*\.[0-9a-fA-F]+ ([pP][-+]?[0-9]+)?
非数字:: NaN | 本地NaN | Infinity | 本地无穷大
带符号非数字:: ( [-+]? 非数字 ); | 本地正数前缀 非数字 本地正数后缀; | 本地负数前缀 非数字 本地负数后缀
浮点数:: 十进制 | 十六进制浮点数 | 带符号非数字

上述正则表达式中空格不重要。

自 JDK 版本:: 1.5

Constructor Summary

Constructors

Constructor

Description

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。
Method Summary

Modifier and Type

Method

Description

void

close()

关闭此扫描器。

Pattern

delimiter()

返回此 Scanner 当前正在使用的用于匹配分隔符的 Pattern。

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() 方法解释为双精度值，则返回 true。

boolean

hasNextFloat()

如果此扫描器的输入中的下一个标记可以使用 nextFloat() 方法解释为浮点值，则返回 true。

boolean

hasNextInt()

如果此扫描器的输入中的下一个标记可以使用 nextInt() 方法在默认基数下解释为整数值，则返回 true。

boolean

hasNextInt(int radix)

如果此扫描器的输入中的下一个标记可以使用 nextInt() 方法在指定基数下解释为整数值，则返回 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()

返回此扫描器的底层 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()

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

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 实现不支持 remove 操作。

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)

将此扫描器的默认基数设置为指定的基数。

Methods declared in class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods declared in interface java.util.Iterator
forEachRemaining

Constructor Details
- 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 - 用于将文件中的字节转换为要扫描的字符的字符集
  
  自 JDK 版本:
  
  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错误
  
  自 JDK 版本:
  
  10
- Scanner
  
  public Scanner(Path source) throws IOException
  
  构造一个新的Scanner，从指定文件中扫描值。文件中的字节使用默认字符集转换为字符。
  参数:
  
  source - 要扫描的文件的路径
  
  抛出:
  
  IOException - 如果打开源文件时发生I/O错误
  
  自 JDK 版本:
  
  1.7
  
  参见:
  
  Charset.defaultCharset()
- Scanner
  
  public Scanner(Path source, String charsetName) throws IOException
  
  构造一个新的Scanner，从指定文件中扫描值。文件中的字节使用指定的字符集转换为字符。
  
  参数:
  
  source - 要扫描的文件的路径
  
  charsetName - 用于将文件中的字节转换为要扫描的字符的编码类型
  
  抛出:
  
  IOException - 如果打开源文件时发生I/O错误
  
  IllegalArgumentException - 如果找不到指定的编码
  
  自 JDK 版本:
  
  1.7
- Scanner
  
  public Scanner(Path source, Charset charset) throws IOException
  
  构造一个新的Scanner，从指定文件中扫描值。文件中的字节使用指定的字符集转换为字符。
  
  参数:
  
  source - 要扫描的文件的路径
  
  charset - 用于将文件中的字节转换为要扫描的字符的字符集
  
  抛出:
  
  IOException - 如果打开源文件时发生I/O错误
  
  自 JDK 版本:
  
  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 - 用于将通道中的字节转换为要扫描的字符的编码类型
  
  自 JDK 版本:
  
  10
Method Details
- close
  
  public void close()
  
  关闭此扫描器。
  如果此扫描器尚未关闭，且其底层的readable也实现了Closeable接口，则将调用可读对象的close方法。如果此扫描器已关闭，则调用此方法将不起作用。
  
  在扫描器关闭后尝试执行搜索操作将导致IllegalStateException。
  
  由以下接口指定:
  
  close 在接口 AutoCloseable中
  
  由以下接口指定:
  
  close 在接口 Closeable中
- ioException
  
  public IOException ioException()
  
  返回此Scanner的底层Readable最后抛出的IOException。如果不存在这样的异常，则返回null。
  
  返回:
  
  此扫描器的可读对象最后抛出的异常
- delimiter
  
  public Pattern delimiter()
  
  返回此Scanner当前正在使用的Pattern来匹配分隔符。
  
  返回:
  
  此扫描器的分隔模式。
- useDelimiter
  
  public Scanner useDelimiter(Pattern pattern)
  
  将此扫描器的分隔模式设置为指定的模式。
  
  参数:
  
  pattern - 一个分隔模式
  
  返回:
  
  此扫描器
- useDelimiter
  
  public Scanner useDelimiter(String pattern)
  
  将此扫描器的分隔模式设置为从指定String构造的模式。
  形式为useDelimiter(pattern)的此方法调用与useDelimiter(Pattern.compile(pattern))的调用行为完全相同。
  
  调用reset()方法将会将扫描器的分隔符设置为默认值。
  
  参数:
  
  pattern - 指定的分隔模式的字符串
  
  返回:
  
  此扫描器
- locale
  
  public Locale locale()
  
  返回此扫描器的区域设置。
  扫描器的区域设置会影响其默认原始匹配正则表达式的许多元素；请参见上面的本地化数字。
  
  返回:
  
  此扫描器的区域设置
- useLocale
  
  public Scanner useLocale(Locale locale)
  
  将此扫描器的区域设置设置为指定的区域设置。
  扫描器的区域设置会影响其默认原始匹配正则表达式的许多元素；请参见上面的本地化数字。
  
  调用reset()方法将会将扫描器的区域设置设置为初始区域设置。
  
  参数:
  
  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。类似地，findInLine()、findWithinHorizon()和skip()方法在成功时将提供匹配结果。
  
  返回：
  
  上次匹配操作的匹配结果
  
  抛出：
  
  IllegalStateException - 如果没有匹配结果可用
- toString
  
  public String toString()
  
  返回此Scanner的字符串表示形式。 Scanner的字符串表示形式包含可能对调试有用的信息。确切的格式未指定。
  
  覆盖：
  
  toString 在类 Object
  
  返回：
  
  此扫描器的字符串表示形式
- hasNext
  
  public boolean hasNext()
  
  如果此扫描器在其输入中有另一个标记，则返回true。此方法在等待输入进行扫描时可能会阻塞。扫描器不会超越任何输入。
  指定者：
  
  hasNext 在接口 Iterator<String>
  
  返回：
  
  如果此扫描器有另一个标记，则返回true
  
  抛出：
  
  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 - 指定要扫描的模式的字符串
  
  返回：
  
  如果此扫描器有另一个与指定模式匹配的标记，则返回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。此方法在等待输入时可能会阻塞。扫描器不会超越任何输入。
  
  返回：
  
  如果剩余输入中有行分隔符或输入中有其他剩余字符，则返回true
  
  抛出：
  
  IllegalStateException - 如果此扫描器已关闭
- nextLine
  
  public String nextLine()
  
  将此扫描器推进到当前行的末尾并返回跳过的输入。此方法返回当前行的其余部分，不包括末尾的任何行分隔符。位置设置为下一行的开头。
  由于此方法继续搜索输入以查找行分隔符，如果没有行分隔符，则可能缓冲所有输入以搜索要跳过的行。
  
  返回：
  
  跳过的行
  
  抛出：
  
  NoSuchElementException - 如果未找到行
  
  IllegalStateException - 如果此扫描器已关闭
- findInLine
  
  public String findInLine(String pattern)
  
  尝试查找从指定字符串构造的模式的下一个出现，忽略分隔符。
  形式为findInLine(pattern)的此方法的调用行为与调用findInLine(Pattern.compile(pattern))的行为完全相同。
  
  Parameters:
  
  pattern - a string specifying the pattern to search for
  
  Returns:
  
  the text that matched the specified pattern
  
  Throws:
  
  IllegalStateException - if this scanner is closed
- findInLine
  
  public String findInLine(Pattern pattern)
  
  Attempts to find the next occurrence of the specified pattern ignoring delimiters. If the pattern is found before the next line separator, the scanner advances past the input that matched and returns the string that matched the pattern. If no such pattern is detected in the input up to the next line separator, then null is returned and the scanner's position is unchanged. This method may block waiting for input that matches the pattern.
  Since this method continues to search through the input looking for the specified pattern, it may buffer all of the input searching for the desired token if no line separators are present.
  
  Parameters:
  
  pattern - the pattern to scan for
  
  Returns:
  
  the text that matched the specified pattern
  
  Throws:
  
  IllegalStateException - if this scanner is closed
- findWithinHorizon
  
  public String findWithinHorizon(String pattern, int horizon)
  
  Attempts to find the next occurrence of a pattern constructed from the specified string, ignoring delimiters.
  An invocation of this method of the form findWithinHorizon(pattern) behaves in exactly the same way as the invocation findWithinHorizon(Pattern.compile(pattern), horizon).
  
  参数:
  
  pattern - 指定要搜索的模式的字符串
  
  horizon - 搜索范围
  
  返回:
  
  匹配指定模式的文本
  
  抛出:
  
  IllegalStateException - 如果此扫描器已关闭
  
  IllegalArgumentException - 如果horizon为负
- findWithinHorizon
  
  public String findWithinHorizon(Pattern pattern, int horizon)
  
  尝试查找指定模式的下一个出现。
  此方法搜索输入直到指定的搜索范围，忽略分隔符。如果找到模式，则扫描器将跳过匹配的输入并返回匹配模式的字符串。如果未检测到此类模式，则返回null，扫描器的位置保持不变。此方法可能会阻塞等待匹配模式的输入。
  
  扫描器永远不会搜索超出当前位置horizon代码点。请注意，匹配可能会被范围限制；也就是说，如果范围更大，则任意匹配结果可能会有所不同。扫描器将范围视为透明的、非锚定的边界（参见Matcher.useTransparentBounds(boolean)和Matcher.useAnchoringBounds(boolean)）。
  
  如果horizon为0，则忽略范围，此方法将继续搜索输入，寻找指定模式而不受限制。在这种情况下，它可能会缓冲所有输入以搜索模式。
  
  如果horizon为负，则会抛出IllegalArgumentException。
  
  参数:
  
  pattern - 要扫描的模式
  
  horizon - 搜索范围
  
  返回:
  
  匹配指定模式的文本
  
  抛出:
  
  IllegalStateException - 如果此扫描器已关闭
  
  IllegalArgumentException - 如果horizon为负
- 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))的行为完全相同。
  
  参数:
  
  pattern - 指定要跳过的模式的字符串
  
  返回:
  
  此扫描器
  
  抛出:
  
  IllegalStateException - 如果此扫描器已关闭
- hasNextBoolean
  
  public boolean hasNextBoolean()
  
  返回true，如果此扫描器输入中的下一个标记可以使用从字符串“true|false”创建的不区分大小写的模式解释为布尔值。扫描器不会超过匹配的输入。
  
  返回:
  
  如果此扫描器的下一个标记是有效的布尔值，则为true
  
  抛出:
  
  IllegalStateException - 如果此扫描器已关闭
- nextBoolean
  
  public boolean nextBoolean()
  
  将输入的下一个标记扫描为布尔值并返回该值。如果下一个标记无法转换为有效的布尔值，则此方法将抛出InputMismatchException。如果匹配成功，则扫描器将跳过匹配的输入。
  
  返回:
  
  从输入中扫描到的布尔值
  
  抛出:
  
  InputMismatchException - 如果下一个标记不是有效的布尔值
  
  NoSuchElementException - 如果输入已耗尽
  
  IllegalStateException - 如果此扫描器已关闭
- hasNextByte
  
  public boolean hasNextByte()
  
  返回true，如果此扫描器输入中的下一个标记可以使用默认基数中的nextByte()方法解释为字节值。扫描器不会超过任何输入。
  
  返回:
  
  如果此扫描器的下一个标记是有效的字节值，则为true
  
  抛出:
  
  IllegalStateException - 如果此扫描器已关闭
- hasNextByte
  
  public boolean hasNextByte(int radix)
  
  返回true，如果此扫描器输入中的下一个标记可以使用指定基数中的nextByte()方法解释为字节值。扫描器不会超过任何输入。
  如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX，则会抛出IllegalArgumentException。
  
  参数:
  
  radix - 用于将标记解释为字节值的基数
  
  返回:
  
  如果此扫描器的下一个标记是有效的字节值，则为true
  
  抛出:
  
  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数字，如果存在区域设置特定的负前缀和后缀，则添加负号（-），最后将结果字符串传递给Byte.parseByte以指定的基数。
  
  如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX，则会抛出IllegalArgumentException。
  
  参数:
  
  radix - 用于将标记解释为字节值的基数
  
  返回:
  
  从输入中扫描到的byte
  
  抛出:
  
  InputMismatchException - 如果下一个标记不匹配Integer正则表达式，或超出范围
  
  NoSuchElementException - 如果输入已耗尽
  
  IllegalStateException - 如果此扫描器已关闭
  
  IllegalArgumentException - 如果基数超出范围
- hasNextShort
  
  public boolean hasNextShort()
  
  返回true，如果此扫描器输入中的下一个标记可以使用nextShort()方法中的默认基数解释为short值。扫描器不会超过任何输入。
  
  返回:
  
  如果此扫描器的下一个标记是默认基数中的有效short值，则为true
  
  抛出:
  
  IllegalStateException - 如果此扫描器已关闭
- hasNextShort
  
  public boolean hasNextShort(int radix)
  
  返回true，如果此扫描器输入中的下一个标记可以使用nextShort()方法中的指定基数解释为short值。扫描器不会超过任何输入。
  如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX，则会抛出IllegalArgumentException。
  
  参数:
  
  radix - 用于将令牌解释为short值的基数
  
  返回:
  
  如果且仅当此扫描器的下一个令牌是指定基数中的有效short值时返回true
  
  抛出:
  
  IllegalStateException - 如果此扫描器已关闭
  
  IllegalArgumentException - 如果基数超出范围
- nextShort
  
  public short nextShort()
  
  作为short扫描输入的下一个令牌。
  以nextShort()形式调用此方法的行为与调用nextShort(radix)的行为完全相同，其中radix是此扫描器的默认基数。
  
  返回:
  
  从输入中扫描到的short
  
  抛出:
  
  InputMismatchException - 如果下一个令牌不匹配Integer正则表达式，或超出范围
  
  NoSuchElementException - 如果输入已耗尽
  
  IllegalStateException - 如果此扫描器已关闭
- nextShort
  
  public short nextShort(int radix)
  
  作为short扫描输入的下一个令牌。如果下一个令牌无法转换为有效的short值，则此方法将抛出InputMismatchException，具体描述如下。如果转换成功，则扫描器将跳过匹配的输入。
  如果下一个令牌与上面定义的Integer正则表达式匹配，则将该令牌转换为short值，方法是删除所有特定于区域设置的前缀、组分隔符和特定于区域设置的后缀，然后通过Character.digit将非ASCII数字映射为ASCII数字，如果存在特定于区域设置的负前缀和后缀，则添加负号(-)，并将结果字符串传递给Short.parseShort以指定的基数。
  
  如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX，则会抛出IllegalArgumentException。
  
  参数:
  
  radix - 用于将令牌解释为short值的基数
  
  返回:
  
  从输入中扫描到的short
  
  抛出:
  
  InputMismatchException - 如果下一个令牌不匹配Integer正则表达式，或超出范围
  
  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 - 如果下一个令牌不匹配Integer正则表达式，或超出范围
  
  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 - 如果下一个令牌不匹配Integer正则表达式，或超出范围
  
  NoSuchElementException - 如果输入已耗尽
  
  IllegalStateException - 如果此扫描器已关闭
  
  IllegalArgumentException - 如果基数超出范围
- hasNextLong
  
  public boolean hasNextLong()
  
  如果此扫描器的输入中的下一个令牌可以使用nextLong()方法在默认基数中解释为long值，则返回true。扫描器不会跳过任何输入。
  
  返回:
  
  如果且仅当此扫描器的下一个令牌是有效的long值时返回true
  
  抛出:
  
  IllegalStateException - 如果此扫描器已关闭
- hasNextLong
  
  public boolean hasNextLong(int radix)
  
  如果此扫描器的输入中的下一个令牌可以使用nextLong()方法在指定基数中解释为long值，则返回true。扫描器不会跳过任何输入。
  如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX，则会抛出IllegalArgumentException。
  
  参数:
  
  radix - 用于将令牌解释为long值的基数
  
  返回:
  
  如果且仅当此扫描器的下一个令牌是有效的long值时返回true
  
  抛出:
  
  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，如下所述。如果转换成功，扫描器将继续前进到匹配的输入之后。
  如果下一个标记与上面定义的整数正则表达式匹配，则将该标记转换为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()方法解释为float值，则返回true。扫描器不会继续前进到任何输入。
  
  返回:
  
  如果此扫描器的下一个标记是有效的float值，则返回true
  
  抛出:
  
  IllegalStateException - 如果此扫描器已关闭
- nextFloat
  
  public float nextFloat()
  
  扫描输入的下一个标记作为float。如果下一个标记无法转换为有效的float值，则此方法将抛出InputMismatchException，如下所述。如果转换成功，扫描器将继续前进到匹配的输入之后。
  如果下一个标记与上面定义的浮点数正则表达式匹配，则将该标记转换为float值，就好像删除了所有特定于区域设置的前缀、组分隔符和特定于区域设置的后缀，然后通过Character.digit将非ASCII数字映射为ASCII数字，如果区域设置的负前缀和后缀存在，则添加负号(-)，并将结果字符串传递给Float.parseFloat。如果标记与本地化的NaN或无穷大字符串匹配，则适当地将"Nan"或"Infinity"传递给Float.parseFloat。
  
  返回:
  
  从输入中扫描到的float
  
  抛出:
  
  InputMismatchException - 如果下一个标记不匹配浮点数正则表达式，或超出范围
  
  NoSuchElementException - 如果输入已耗尽
  
  IllegalStateException - 如果此扫描器已关闭
- hasNextDouble
  
  public boolean hasNextDouble()
  
  如果此扫描器的输入中的下一个标记可以使用nextDouble()方法解释为double值，则返回true。扫描器不会继续前进到任何输入。
  
  返回:
  
  如果此扫描器的下一个标记是有效的double值，则返回true
  
  抛出:
  
  IllegalStateException - 如果此扫描器已关闭
- nextDouble
  
  public double nextDouble()
  
  扫描输入的下一个标记作为double。如果下一个标记无法转换为有效的double值，则此方法将抛出InputMismatchException。如果转换成功，扫描器将继续前进到匹配的输入之后。
  如果下一个标记与上面定义的浮点数正则表达式匹配，则将该标记转换为double值，就好像删除了所有特定于区域设置的前缀、组分隔符和特定于区域设置的后缀，然后通过Character.digit将非ASCII数字映射为ASCII数字，如果区域设置的负前缀和后缀存在，则添加负号(-)，并将结果字符串传递给Double.parseDouble。如果标记与本地化的NaN或无穷大字符串匹配，则适当地将"Nan"或"Infinity"传递给Double.parseDouble。
  
  返回:
  
  从输入中扫描到的double
  
  抛出:
  
  InputMismatchException - 如果下一个标记不匹配浮点数正则表达式，或超出范围
  
  NoSuchElementException - 如果输入已耗尽
  
  IllegalStateException - 如果此扫描器已关闭
- hasNextBigInteger
  
  public boolean hasNextBigInteger()
  
  如果此扫描器的输入中的下一个标记可以使用nextBigInteger()方法在默认基数下解释为BigInteger，则返回true。扫描器不会继续前进到任何输入。
  
  返回:
  
  如果此扫描器的下一个标记是有效的BigInteger，则返回true
  
  抛出:
  
  IllegalStateException - 如果此扫描器已关闭
- hasNextBigInteger
  
  public boolean hasNextBigInteger(int radix)
  
  如果此扫描器的输入中的下一个标记可以使用nextBigInteger()方法在指定基数下解释为BigInteger，则返回true。扫描器不会继续前进到任何输入。
  如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX，则会抛出IllegalArgumentException。
  
  参数:
  
  radix - 用于将标记解释为整数的基数
  
  返回:
  
  如果此扫描器的下一个标记是有效的BigInteger，则返回true
  
  抛出:
  
  IllegalStateException - 如果此扫描器已关闭
  
  IllegalArgumentException - 如果基数超出范围
- nextBigInteger
  
  public BigInteger nextBigInteger()
  
  扫描输入的下一个标记作为BigInteger。
  形式为nextBigInteger()的此方法调用的行为与调用nextBigInteger(radix)的行为完全相同，其中radix是此扫描器的默认基数。
  
  返回:
  
  从输入中扫描到的BigInteger
  
  抛出:
  
  InputMismatchException - 如果下一个标记不匹配整数正则表达式，或超出范围
  
  NoSuchElementException - 如果输入已耗尽
  
  IllegalStateException - 如果此扫描器已关闭
- nextBigInteger
  
  public BigInteger nextBigInteger(int radix)
  
  扫描输入的下一个标记作为BigInteger。
  如果下一个标记与上面定义的整数正则表达式匹配，则将该标记转换为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，则返回true
  
  抛出:
  
  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(pattern, 0)然后连续调用match()直到findWithinHorizon()找到匹配的结果。
  生成的流是顺序且有序的。所有流元素均为非空。
  
  扫描从终端流操作的启动开始，使用此扫描器的当前状态。对此扫描器的任何方法的后续调用，除了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 - 如果模式为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

本地化数字

数字语法

Constructor Summary

Method Summary

Methods declared in class java.lang.Object

Methods declared in interface java.util.Iterator

Constructor Details

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Scanner

Method Details

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