鸿蒙OS Scanner

Scanner

java.lang.Object

|—java.util.Scanner

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

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

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

例如，此代码允许用户从 System.in 中读取一个数字：

     Scanner sc = new Scanner(System.in);
     int i = sc.nextInt();

作为另一个示例，此代码允许从文件 myNumbers 中的条目分配长类型：

      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 方法是否会阻塞没有关系。

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

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

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

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

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

如果没有外部同步，扫描器对于多线程使用是不安全的。

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

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

本地化号码

此类的一个实例能够扫描标准格式以及扫描仪区域设置格式的数字。 扫描仪的初始语言环境是 Locale.getDefault(Locale.Category.FORMAT) 方法返回的值； 它可以通过 useLocale(java.util.Locale) 方法进行更改。 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()

Number syntax

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

非ASCII码：

Character.isDigit(c) 为其返回 true 的非 ASCII 字符 c

非零位：

[1-Rmax] | 非ASCII数字

数字:

[0-Rmax] | 非ASCII数字

分组数字:

( Non0Digit Digit? Digit?

( LocalGroupSeparator Digit Digit Digit )+ )

数字:

( ( Digit+ ) | GroupedNumeral )

整数:

( [-+]? ( Numeral ) )

| LocalPositivePrefix Numeral LocalPositiveSuffix

| LocalNegativePrefix Numeral LocalNegativeSuffix

十进制数字:

数字

| Numeral LocalDecimalSeparator *Digit**

| LocalDecimalSeparator Digit+

指数:

( [eE] [+-]? Digit+ )

十进制:

( [-+]? DecimalNumeral Exponent? )

| LocalPositivePrefix DecimalNumeral LocalPositiveSuffix Exponent?

| LocalNegativePrefix DecimalNumeral LocalNegativeSuffix Exponent?

十六进制浮点数:

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

非编号:

NaN | LocalNan | Infinity | LocalInfinity

签名非号码:

( [-+]? NonNumber )

| LocalPositivePrefix NonNumber LocalPositiveSuffix

| LocalNegativePrefix NonNumber LocalNegativeSuffix

浮点数:

Decimal | HexFloat | SignedNonNumber

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

构造函数摘要

方法总结

构造函数详细信息

Scanner

public Scanner(Readable source)

构造一个新的 Scanner，它产生从指定源扫描的值。

参数：

Scanner

public Scanner(InputStream source)

构造一个新的 Scanner，它生成从指定输入流扫描的值。 使用底层平台的默认字符集将流中的字节转换为字符。

参数：

Scanner

public Scanner(InputStream source, String charsetName)

构造一个新的 Scanner，它生成从指定输入流扫描的值。 流中的字节使用指定的字符集转换为字符。

参数：

Throws:

Scanner

public Scanner(File source) throws FileNotFoundException

构造一个新的 Scanner，它产生从指定文件扫描的值。 使用底层平台的默认字符集将文件中的字节转换为字符。

参数：

Throws:

Scanner

public Scanner(File source, String charsetName) throws FileNotFoundException

构造一个新的 Scanner，它产生从指定文件扫描的值。 使用指定的字符集将文件中的字节转换为字符。

参数：

Throws:

Scanner

public Scanner(Path source) throws IOException

构造一个新的 Scanner，它产生从指定文件扫描的值。 使用底层平台的默认字符集将文件中的字节转换为字符。

参数：

Throws:

Scanner

public Scanner(Path source, String charsetName) throws IOException

构造一个新的 Scanner，它产生从指定文件扫描的值。 使用指定的字符集将文件中的字节转换为字符。

参数：

Throws:

Scanner

public Scanner(String source)

构造一个新的 Scanner，它生成从指定字符串扫描的值。

参数：

Scanner

public Scanner(ReadableByteChannel source)

构造一个新的 Scanner，它产生从指定通道扫描的值。 使用底层平台的默认字符集将源中的字节转换为字符。

参数：

Scanner

public Scanner(ReadableByteChannel source, String charsetName)

构造一个新的 Scanner，它产生从指定通道扫描的值。 使用指定的字符集将源中的字节转换为字符。

参数：

Throws:

方法详情

close

public void close()

关闭此扫描仪。

如果这个扫描器还没有关闭，那么如果它的底层可读也实现了 Closeable 接口，那么可读的 close 方法将被调用。 如果此扫描仪已关闭，则调用此方法将无效。

在扫描程序关闭后尝试执行搜索操作将导致 IllegalStateException。

指定者：

在接口 AutoCloseable 中关闭

指定者：

在接口Closeable中关闭

ioException

public IOException ioException()

返回此 Scanner 的底层 Readable 上次抛出的 IOException。 如果不存在此类异常，则此方法返回 null。

返回:

此扫描仪可读的最后一个异常

delimiter

public Pattern delimiter()

返回此扫描器当前用于匹配分隔符的模式。

返回:

此扫描仪的分隔模式。

useDelimiter

public Scanner useDelimiter(Pattern pattern)

将此扫描仪的分隔模式设置为指定的模式。

参数：

返回:

这个扫描仪

useDelimiter

public Scanner useDelimiter(String pattern)

将此扫描仪的分隔模式设置为从指定字符串构造的模式。

调用useDelimiter(pattern) 形式的此方法的行为方式与调用useDelimiter(Pattern.compile(pattern)) 完全相同。

调用 reset() 方法会将扫描仪的分隔符设置为默认值。

参数：

返回:

这个扫描仪

locale

public Locale locale()

返回此扫描仪的语言环境。

扫描仪的语言环境会影响其默认原始匹配正则表达式的许多元素。

返回:

此扫描仪的语言环境

useLocale

public Scanner useLocale(Locale locale)

将此扫描仪的语言环境设置为指定的语言环境。

扫描仪的语言环境会影响其默认原始匹配正则表达式的许多元素。

调用 reset() 方法会将扫描仪的语言环境设置为初始语言环境。

参数：

返回:

这个扫描仪

radix

public int radix()

返回此扫描仪的默认基数。

扫描仪的基数会影响其默认数字匹配正则表达式的元素； 请参阅上面的本地化数字。

返回:

此扫描仪的默认基数

useRadix

public Scanner useRadix(int radix)

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

扫描仪的基数会影响其默认数字匹配正则表达式的元素。

如果基数小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX，则抛出 IllegalArgumentException。

调用 reset() 方法会将扫描仪的基数设置为 10。

参数：

返回:

这个扫描仪

Throws:

match

public MatchResult match()

返回此扫描器执行的最后一次扫描操作的匹配结果。 如果没有执行匹配，或者最后一次匹配不成功，则此方法抛出 IllegalStateException。

如果 Scanner 的各种 next 方法完成而没有抛出异常，则可以使用匹配结果。 例如，在调用返回 int 的 nextInt() 方法后，此方法返回 MatchResult 以搜索上面定义的 Integer 正则表达式。 类似地，如果 findInLine(java.lang.String)、findWithinHorizon(java.lang.String, int) 和 skip(java.util.regex.Pattern) 方法成功，则匹配可用。

返回:

最后一次匹配操作的匹配结果

Throws:

toString

public String toString()

返回此 Scanner 的字符串表示形式。 Scanner 的字符串表示形式包含可能对调试有用的信息。 确切的格式未指定。

覆盖：

类 Object 中的 toString

返回:

此扫描仪的字符串表示形式

hasNext

public boolean hasNext()

如果此扫描器在其输入中有另一个标记，则返回 true。 此方法可能会在等待输入扫描时阻塞。 扫描仪不会超过任何输入。

指定者：

接口 IteratorString 中的 hasNext

返回:

当且仅当此扫描仪有另一个令牌时才为 true

Throws:

next

public String next()

从此扫描器中查找并返回下一个完整的令牌。 一个完整的标记前后是匹配分隔符模式的输入。 此方法可能会在等待输入扫描时阻塞，即使先前调用 hasNext() 返回 true。

指定者：

接口 IteratorString 中的下一个

返回:

下一个令牌

Throws:

remove

public void remove()

Iterator 的此实现不支持删除操作。

指定者：

在接口 IteratorString 中移除

Throws:

hasNext

public boolean hasNext(String pattern)

如果下一个标记与从指定字符串构造的模式匹配，则返回 true。 扫描仪不会超过任何输入。

对这种形式为 hasNext(pattern) 的方法的调用与调用 hasNext(Pattern.compile(pattern)) 的行为方式完全相同。

参数：

返回:

当且仅当此扫描器具有与指定模式匹配的另一个标记时才为 true

Throws:

next

public String next(String pattern)

如果它与从指定字符串构造的模式匹配，则返回下一个标记。 如果匹配成功，扫描器会前进超过匹配模式的输入。

调用 next(pattern) 形式的此方法的行为与调用 next(Pattern.compile(pattern)) 完全相同。

参数：

返回:

下一个令牌

Throws:

hasNext

public boolean hasNext(Pattern pattern)

如果下一个完整的标记与指定的模式匹配，则返回 true。 完整的标记由匹配分隔符模式的输入添加前缀和后缀。 此方法可能会在等待输入时阻塞。 扫描仪不会超过任何输入。

参数：

返回:

当且仅当此扫描器具有与指定模式匹配的另一个标记时才为 true

Throws:

next

public String next(Pattern pattern)

如果它与指定的模式匹配，则返回下一个标记。 即使先前调用 hasNext(java.util.regex.Pattern) 返回 true，此方法也可能在等待输入扫描时阻塞。 如果匹配成功，扫描器会前进超过匹配模式的输入。

参数：

返回:

下一个令牌

Throws:

hasNextLine

public boolean hasNextLine()

如果此扫描仪的输入中有另一行，则返回 true。 此方法可能会在等待输入时阻塞。 扫描仪不会超过任何输入。

返回:

当且仅当此扫描仪有另一行输入时才为 true

Throws:

nextLine

public String nextLine()

将此扫描器前进到当前行并返回被跳过的输入。 此方法返回当前行的其余部分，不包括末尾的任何行分隔符。 位置设置为下一行的开头。

由于此方法继续搜索输入以查找行分隔符，因此如果不存在行分隔符，它可能会缓冲所有搜索要跳过的行的输入。

返回:

被跳过的行

Throws:

findInLine

public String findInLine(String pattern)

尝试查找从指定字符串构造的模式的下一个匹配项，忽略分隔符。

对这种形式为 findInLine(pattern) 的方法的调用与调用 findInLine(Pattern.compile(pattern)) 的行为方式完全相同。

参数：

返回:

与指定模式匹配的文本

Throws:

findInLine

public String findInLine(Pattern pattern)

尝试查找指定模式忽略分隔符的下一个匹配项。 如果在下一行分隔符之前找到该模式，则扫描程序会越过匹配的输入并返回与该模式匹配的字符串。 如果在直到下一行分隔符的输入中没有检测到这样的模式，则返回 null 并且扫描仪的位置不变。 此方法可能会阻止等待与模式匹配的输入。

由于此方法继续搜索输入以查找指定的模式，因此如果不存在行分隔符，它可能会缓冲所有输入以搜索所需的标记。

参数：

返回:

与指定模式匹配的文本

Throws:

findWithinHorizon

public String findWithinHorizon(String pattern, int horizon)

尝试查找从指定字符串构造的模式的下一个匹配项，忽略分隔符。

对这种形式为 findWithinHorizon(pattern) 的方法的调用与调用 findWithinHorizon(Pattern.compile(pattern, horizon)) 的行为方式完全相同。

参数：

返回:

与指定模式匹配的文本

Throws:

findWithinHorizon

public String findWithinHorizon(Pattern pattern, int horizon)

尝试查找指定模式的下一个匹配项。

此方法搜索输入直到指定的搜索范围，忽略分隔符。如果找到模式，则扫描程序会越过匹配的输入并返回与模式匹配的字符串。如果没有检测到这样的模式，则返回 null 并且扫描仪的位置保持不变。此方法可能会阻止等待与模式匹配的输入。

扫描器永远不会搜索超出其当前位置的水平代码点。请注意，匹配可能会被 horizon 剪裁；也就是说，如果视野更大，任意匹配结果可能会有所不同。扫描仪将 horizon 视为透明的非锚定边界。

如果 horizon 为0，则 horizon 被忽略，并且此方法继续搜索输入以寻找指定的模式而不受限制。在这种情况下，它可能会缓冲所有搜索模式的输入。

如果 Horizon 为负数，则抛出 IllegalArgumentException。

参数：

返回:

与指定模式匹配的文本

Throws:

skip

public Scanner skip(Pattern pattern)

跳过与指定模式匹配的输入，忽略分隔符。 如果指定模式的锚定匹配成功，此方法将跳过输入。

如果在当前位置未找到与指定模式的匹配项，则不跳过任何输入并抛出 NoSuchElementException。

由于此方法试图从扫描仪的当前位置开始匹配指定的模式，因此可以匹配大量输入（例如“.*”）的模式可能会导致扫描仪缓冲大量输入。

请注意，通过使用不匹配任何内容的模式（例如 sc.skip(“[ \t]*”)），可以跳过某些内容而不会冒 NoSuchElementException 的风险。

参数：

返回:

这个扫描仪

Throws:

skip

public Scanner skip(String pattern)

跳过与从指定字符串构造的模式匹配的输入。

对这种形式为 skip(pattern) 的方法的调用与调用 skip(Pattern.compile(pattern)) 的行为方式完全相同。

参数：

返回:

这个扫描仪

Throws:

hasNextBoolean

public boolean hasNextBoolean()

如果此扫描器输入中的下一个标记可以使用从字符串“true|false”创建的不区分大小写的模式解释为布尔值，则返回 true。 扫描仪不会超过匹配的输入。

返回:

当且仅当此扫描器的下一个标记是有效的布尔值时才为 true

Throws:

nextBoolean

public boolean nextBoolean()

将输入的下一个标记扫描为布尔值并返回该值。 如果下一个标记无法转换为有效的布尔值，此方法将抛出 InputMismatchException。 如果匹配成功，则扫描仪会超过匹配的输入。

回报：

从输入扫描的布尔值

Throws:

hasNextByte

public boolean hasNextByte()

如果此扫描器输入中的下一个标记可以使用 nextByte() 方法解释为默认基数中的字节值，则返回 true。 扫描仪不会超过任何输入。

返回:

当且仅当此扫描器的下一个令牌是有效字节值时才为 true

Throws:

hasNextByte

public boolean hasNextByte(int radix)

如果此扫描器输入中的下一个标记可以使用 nextByte() 方法解释为指定基数中的字节值，则返回 true。 扫描仪不会超过任何输入。

参数：

返回:

当且仅当此扫描器的下一个令牌是有效字节值时才为 true

Throws:

nextByte

public byte nextByte()

将输入的下一个标记扫描为一个字节。

调用 nextByte() 形式的此方法的行为与调用 nextByte(radix) 完全相同，其中 radix 是此扫描仪的默认基数。

返回:

从输入扫描的字节

Throws:

nextByte

public byte nextByte(int radix)

将输入的下一个标记扫描为一个字节。 如果下一个标记无法转换为如下所述的有效字节值，则此方法将抛出 InputMismatchException。 如果翻译成功，扫描仪会超过匹配的输入。

如果下一个标记与上面定义的整数正则表达式匹配，则该标记被转换为字节值，就像通过删除所有区域设置特定的前缀、组分隔符和区域设置特定的后缀，然后通过 Character#digit 将非 ASCII 数字映射到 ASCII 数字 , 如果存在特定于语言环境的负前缀和后缀，则在前面加上负号 (-)，并将结果字符串传递给具有指定基数的 Byte#parseByte(String, int)。

参数：

返回:

从输入扫描的字节

Throws:

hasNextShort

public boolean hasNextShort()

如果此扫描器输入中的下一个标记可以使用 nextShort() 方法解释为默认基数中的短值，则返回 true。 扫描仪不会超过任何输入。

返回:

当且仅当此扫描器的下一个标记是默认基数中的有效短值时才为 true

Throws:

hasNextShort

public boolean hasNextShort(int radix)

如果此扫描器输入中的下一个标记可以使用 nextShort() 方法解释为指定基数中的短值，则返回 true。 扫描仪不会超过任何输入。

参数：

返回:

当且仅当此扫描器的下一个标记是指定基数中的有效短值时才为 true

Throws:

nextShort

public short nextShort()

将输入的下一个标记扫描为短标记。

调用 nextShort() 形式的此方法的行为方式与调用 nextShort(radix) 完全相同，其中 radix 是此扫描仪的默认基数。

返回:

从输入扫描的 short

Throws:

nextShort

public short nextShort(int radix)

将输入的下一个标记扫描为短标记。 如果下一个标记无法转换为有效的短值，则此方法将抛出 InputMismatchException，如下所述。 如果翻译成功，扫描仪会超过匹配的输入。

如果下一个标记与上面定义的整数正则表达式匹配，则将标记转换为短值，就像通过删除所有区域设置特定前缀、组分隔符和区域设置特定后缀，然后通过 Character#digit 将非 ASCII 数字映射为 ASCII 数字 , 如果存在特定于语言环境的负前缀和后缀，则在前面加上负号 (-)，并将结果字符串传递给具有指定基数的 Short#parseShort(String, int)。

参数：

返回:

从输入扫描的 short

Throws:

hasNextInt

public boolean hasNextInt()

如果此扫描器输入中的下一个标记可以使用 nextInt() 方法解释为默认基数中的 int 值，则返回 true。 扫描仪不会超过任何输入。

返回:

当且仅当此扫描器的下一个标记是有效的 int 值时才为 true

Throws:

hasNextInt

public boolean hasNextInt(int radix)

如果此扫描仪输入中的下一个标记可以使用 nextInt() 方法解释为指定基数中的 int 值，则返回 true。 扫描仪不会超过任何输入。

参数：

返回:

当且仅当此扫描器的下一个标记是有效的 int 值时才为 true

Throws:

nextInt

public int nextInt()

将输入的下一个标记扫描为 int。

调用 nextInt() 形式的此方法的行为方式与调用 nextInt(radix) 完全相同，其中 radix 是此扫描仪的默认基数。

返回:

从输入扫描的 int

Throws:

nextInt

public int nextInt(int radix)

将输入的下一个标记扫描为 int。 如果下一个标记无法转换为有效的 int 值，则此方法将抛出 InputMismatchException，如下所述。 如果翻译成功，扫描仪会超过匹配的输入。

如果下一个标记与上面定义的 Integer 正则表达式匹配，则将标记转换为 int 值，就像通过删除所有区域设置特定前缀、组分隔符和区域设置特定后缀，然后通过 Character#digit 将非 ASCII 数字映射为 ASCII 数字 ，如果存在特定于语言环境的负前缀和后缀，则在前面加上负号 (-)，并将结果字符串传递给具有指定基数的 Integer#parseInt(String, int)。

参数：

返回:

从输入扫描的 int

Throws:

hasNextLong

public boolean hasNextLong()

如果此扫描仪输入中的下一个标记可以使用 nextLong() 方法解释为默认基数中的 long 值，则返回 true。 扫描仪不会超过任何输入。

返回:

当且仅当此扫描器的下一个标记是有效的长值时才为 true

Throws:

hasNextLong

public boolean hasNextLong(int radix)

如果此扫描器输入中的下一个标记可以使用 nextLong() 方法解释为指定基数中的 long 值，则返回 true。 扫描仪不会超过任何输入。

参数：

返回:

当且仅当此扫描器的下一个标记是有效的长值时才为 true

Throws:

nextLong

public long nextLong()

将输入的下一个标记扫描为 long。

调用 nextLong() 形式的此方法的行为方式与调用 nextLong(radix) 完全相同，其中 radix 是此扫描仪的默认基数。

返回:

从输入中扫描的 long

Throws:

nextLong

public long nextLong(int radix)

将输入的下一个标记扫描为 long。 如果下一个标记无法转换为如下所述的有效长值，则此方法将抛出 InputMismatchException。 如果翻译成功，扫描仪会超过匹配的输入。

如果下一个标记与上面定义的整数正则表达式匹配，则该标记被转换为长值，就像通过删除所有区域设置特定前缀、组分隔符和区域设置特定后缀，然后通过 Character#digit 将非 ASCII 数字映射为 ASCII 数字 , 如果存在特定于语言环境的负前缀和后缀，则在前面加上负号 (-)，并将结果字符串传递给具有指定基数的 Long#parseLong(String, int)。

参数：

返回:

从输入中扫描的 long

Throws:

hasNextFloat

public boolean hasNextFloat()

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

返回:

当且仅当此扫描器的下一个标记是有效的浮点值时才为 true

Throws:

nextFloat

public float nextFloat()

将输入的下一个标记扫描为浮点数。 如果下一个标记无法转换为如下所述的有效浮点值，则此方法将抛出 InputMismatchException。 如果翻译成功，扫描仪会超过匹配的输入。

如果下一个标记与上面定义的 Float 正则表达式匹配，则将标记转换为浮点值，就像通过删除所有区域设置特定前缀、组分隔符和区域设置特定后缀，然后通过 Character#digit 将非 ASCII 数字映射为 ASCII 数字 , 如果存在特定于语言环境的负前缀和后缀，则在前面加上负号 (-)，并将结果字符串传递给 Float#parseFloat。 如果令牌与本地化的 NaN 或无穷大字符串匹配，则“Nan”或“Infinity”将酌情传递给 Float#parseFloat(String)。

返回:

从输入扫描的浮点数

Throws:

hasNextDouble

public boolean hasNextDouble()

如果此扫描器输入中的下一个标记可以使用 nextDouble() 方法解释为双精度值，则返回 true。 扫描仪不会超过任何输入。

返回:

当且仅当此扫描器的下一个标记是有效的双精度值时才为 true

Throws:

nextDouble

public double nextDouble()

将输入的下一个标记扫描为双精度。 如果下一个标记无法转换为有效的双精度值，此方法将抛出 InputMismatchException。 如果翻译成功，扫描仪会超过匹配的输入。

如果下一个标记与上面定义的 Float 正则表达式匹配，则将标记转换为双精度值，就像通过删除所有区域设置特定前缀、组分隔符和区域设置特定后缀，然后通过 Character#digit 将非 ASCII 数字映射为 ASCII 数字 , 如果存在特定于语言环境的负前缀和后缀，则在前面加上负号 (-)，并将结果字符串传递给 Double#parseDouble。 如果令牌与本地化的 NaN 或无穷大字符串匹配，则“Nan”或“Infinity”将酌情传递给 Double#parseDouble(String)。

返回:

从输入扫描的 double

Throws:

hasNextBigInteger

public boolean hasNextBigInteger()

如果此扫描器输入中的下一个标记可以使用 nextBigInteger() 方法解释为默认基数中的 BigInteger，则返回 true。 扫描仪不会超过任何输入。

返回:

当且仅当此扫描器的下一个令牌是有效的 BigInteger 时才为 true

Throws:

hasNextBigInteger

public boolean hasNextBigInteger(int radix)

如果此扫描器输入中的下一个标记可以使用 nextBigInteger() 方法解释为指定基数中的 BigInteger，则返回 true。 扫描仪不会超过任何输入。

参数：

返回:

当且仅当此扫描器的下一个令牌是有效的 BigInteger 时才为 true

Throws:

nextBigInteger

public BigInteger nextBigInteger()

将输入的下一个标记扫描为 BigInteger。

调用 nextBigInteger() 形式的此方法的行为方式与调用 nextBigInteger(radix) 完全相同，其中 radix 是此扫描仪的默认基数。

返回:

从输入扫描的 BigInteger

Throws:

nextBigInteger

public BigInteger nextBigInteger(int radix)

将输入的下一个标记扫描为 BigInteger。

如果下一个标记与上面定义的整数正则表达式匹配，则该标记被转换为 BigInteger 值，就好像通过删除所有组分隔符，通过 Character#digit 将非 ASCII 数字映射为 ASCII 数字，并将生成的字符串传递给 BigInteger (String, int) 具有指定基数的构造函数。

参数：

返回:

从输入扫描的 BigInteger

Throws:

hasNextBigDecimal

public boolean hasNextBigDecimal()

如果此扫描器输入中的下一个标记可以使用 nextBigDecimal() 方法解释为 BigDecimal，则返回 true。 扫描仪不会超过任何输入。

返回:

当且仅当此扫描器的下一个令牌是有效的 BigDecimal 时才为 true

Throws:

nextBigDecimal

public BigDecimal nextBigDecimal()

将输入的下一个标记扫描为 BigDecimal。

如果下一个标记与上面定义的 Decimal 正则表达式匹配，则该标记被转换为 BigDecimal 值，就好像通过删除所有组分隔符，通过 Character#digit 将非 ASCII 数字映射为 ASCII 数字，并将结果字符串传递给 BigDecimal （字符串）构造函数。

返回:

从输入扫描的 BigDecimal

Throws:

reset

public Scanner reset()

重置此扫描仪。

重置扫描器会丢弃其所有显式状态信息，这些信息可能已被 useDelimiter(java.util.regex.Pattern)、useLocale(java.util.Locale) 或 useRadix(int) 调用更改。

形式为scanner.reset() 的此方法的调用与调用的行为方式完全相同

   scanner.useDelimiter("\\p{javaWhitespace}+")
          .useLocale(Locale.getDefault(Locale.Category.FORMAT))
          .useRadix(10);

返回:

这个扫描仪