站内搜索: 请输入搜索关键词
当前页面: 在线文档首页 > JavaTM 2 Platform Standard Edition 5.0 API 规范中文版

Scanner (Java 2 Platform SE 5.0) - JavaTM 2 Platform Standard Edition 5.0 API 规范中文版

概述  软件包   类  使用  树  已过时  索引  帮助 
JavaTM 2 Platform
Standard Ed. 5.0
 上一个类   下一个类 框架    无框架    
摘要： 嵌套 | 字段 | 构造方法 | 方法 详细信息： 字段 | 构造方法 | 方法

java.util
类 Scanner

java.lang.Object
  继承者 java.util.Scanner
所有已实现的接口：
Iterator<String>
public final class Scanner
extends Object
implements Iterator<String>

一个可以使用正则表达式来分析基本类型和字符串的简单文本扫描器。

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

例如，以下代码使用户能够从 System.in 中读取一个数： 

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

再看一个例子，以下代码使 long 类型可以通过 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

以下代码使用正则表达式同时分析所有的 4 个标记，并可以产生与上例相同的输出结果： 

     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 来识别。

扫描操作可能被阻塞，而等待信息的输入。

next() 和 hasNext() 方法及其基本类型 companion 方法（如 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 的 Readable.read(java.nio.CharBuffer) 方法的调用抛出 IOException，则扫描器认为已经到达了输入的结尾。基础 readable 最新抛出的 IOException 可以通过 ioException() 方法检索。

如果 Scanner 关闭，且其输入源实现 Closeable 接口，则该输入源也将关闭。

若没有外部同步，则 Scanner 的多线程使用是不安全的。

除非另行说明，否则将一个 null 参数传递到 Scanner 的任何一个方法中都将抛出 NullPointerException。

默认情况下扫描器会将数字解释为十进制形式，除非已经使用 useRadix(int) 方法设置了不同的基数。

本地化数字

此类的一个实例能够以标准格式以及扫描器语言环境的格式扫描数字。扫描器的初始语言环境是 Locale.getDefault() 方法返回的值；它可以通过 useLocale(java.util.Locale) 方法更改。

本地化格式是根据以下参数定义的，对于某一特定语言环境来说，这些参数取自该语言环境的 DecimalFormat 对象 df，及其 DecimalFormatSymbols 对象 dfs。

LocalGroupSeparator   用于分隔数千个组的字符，即 dfs.getGroupingSeparator()
LocalDecimalSeparator   用于小数点的字符，即 dfs.getDecimalSeparator()
LocalPositivePrefix   出现在正数前的字符串（可以为空），即 df.getPositivePrefix()
LocalPositiveSuffix   出现在正数后的字符串（可以为空），即 df.getPositiveSuffix()
LocalNegativePrefix   出现在负数前的字符串（可以为空），即 df.getNegativePrefix()
LocalNegativeSuffix   出现在负数后的字符串（可以为空），即 df.getNegativeSuffix()
LocalNaN   表示浮点值的非数字的字符串，即 dfs.getInfinity()
LocalInfinity   表示浮点值的无穷大的字符串，即 dfs.getInfinity()

数字语法

可通过此类的一个实例分析为数字的字符串是根据以下正则表达式语法指定的，在这种情况下 Rmax 是正在使用的基数中的最高数字（例如，在基数 10 中 Rmax 为 9）。

NonASCIIDigit  :: = 非 ASCII 字符 c，对于它，Character.isDigit(c) 返回 true
 
Non0Digit  :: = [1-Rmax] | NonASCIIDigit
 
Digit  :: = [0-Rmax] | NonASCIIDigit
 
GroupedNumeral  ::
= (  Non0Digit Digit? Digit?
( LocalGroupSeparator Digit Digit Digit )+ )
 
Numeral  :: = ( ( Digit+ ) | GroupedNumeral )
 
Integer  :: = ( [-+]? ( Numeral ) )
| LocalPositivePrefix Numeral LocalPositiveSuffix
| LocalNegativePrefix Numeral LocalNegativeSuffix
 
DecimalNumeral  :: = Numeral
| Numeral LocalDecimalSeparator Digit*
| LocalDecimalSeparator Digit+
 
Exponent  :: = ( [eE] [+-]? Digit+ )
 
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(InputStream source)
          构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。
Scanner(InputStream source, String charsetName)
          构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。
Scanner(Readable source)
          构造一个新的 Scanner，它生成的值是从指定源扫描的。
Scanner(ReadableByteChannel source)
          构造一个新的 Scanner，它生成的值是从指定信道扫描的。
Scanner(ReadableByteChannel source, String charsetName)
          构造一个新的 Scanner，它生成的值是从指定信道扫描的。
Scanner(String source)
          构造一个新的 Scanner，它生成的值是从指定字符串扫描的。
 
方法摘要
 void close()
          关闭此扫描器。
 Pattern delimiter()
          返回此 Scanner 当前正在用于匹配分隔符的 Pattern。
 String findInLine(Pattern pattern)
          试图在忽略分隔符的情况下查找下一个指定模式。
 String findInLine(String pattern)
          试图在忽略分隔符的情况下查找下一个从指定字符串构造的模式。
 String findWithinHorizon(Pattern pattern, int horizon)
          试图查找下一个指定模式。
 String findWithinHorizon(String pattern, int horizon)
          试图在忽略分隔符的情况下查找下一个从指定字符串构造的模式。
 boolean hasNext()
          如果此扫描器的输入中有另一个标记，则返回 true。
 boolean hasNext(Pattern pattern)
          如果下一个完整标记与指定模式匹配，则返回 true。
 boolean hasNext(String pattern)
          如果下一个标记与从指定字符串构造的模式匹配，则返回 true。
 boolean hasNextBigDecimal()
          如果通过使用 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() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 float 值，则返回 true。
 boolean hasNextInt()
          如果通过使用 nextInt() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 int 值，则返回 true。
 boolean hasNextInt(int radix)
          如果通过使用 nextInt() 方法，此扫描器输入信息中的下一个标记可以解释为指定基数中的一个 int 值，则返回 true。
 boolean hasNextLine()
          如果在此扫描器的输入中存在另一行，则返回 true。
 boolean hasNextLong()
          如果通过使用 nextLong() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 long 值，则返回 true。
 boolean hasNextLong(int radix)
          如果通过使用 nextLong() 方法，此扫描器输入信息中的下一个标记可以解释为指定基数中的一个 long 值，则返回 true。
 boolean hasNextShort()
          如果通过使用 nextShort() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 short 值，则返回 true。
 boolean hasNextShort(int radix)
          如果通过使用 nextShort() 方法，此扫描器输入信息中的下一个标记可以解释为指定基数中的一个 short 值，则返回 true。
 IOException ioException()
          返回此 Scanner 的基础 Readable 最后抛出的 IOException。
 Locale locale()
          返回此扫描器的语言环境。
 MatchResult match()
          返回此扫描器所执行的最后扫描操作的匹配结果。
 String next()
          查找并返回来自此扫描器的下一个完整标记。
 String next(Pattern pattern)
          如果下一个标记与指定模式匹配，则返回下一个标记。
 String next(String pattern)
          如果下一个标记与从指定字符串构造的模式匹配，则返回下一个标记。
 BigDecimal nextBigDecimal()
          将输入信息的下一个标记扫描为一个 BigDecimal。
 BigInteger nextBigInteger()
          将输入信息的下一个标记扫描为一个 BigInteger。
 BigInteger nextBigInteger(int radix)
          将输入信息的下一个标记扫描为一个 BigInteger。
 boolean nextBoolean()
          扫描解释为一个布尔值的输入标记并返回该值。
 byte nextByte()
          将输入信息的下一个标记扫描为一个 byte。
 byte nextByte(int radix)
          将输入信息的下一个标记扫描为一个 byte。
 double nextDouble()
          将输入信息的下一个标记扫描为一个 double。
 float nextFloat()
          将输入信息的下一个标记扫描为一个 float。
 int nextInt()
          将输入信息的下一个标记扫描为一个 int。
 int nextInt(int radix)
          将输入信息的下一个标记扫描为一个 int。
 String nextLine()
          此扫描器执行当前行，并返回跳过的输入信息。
 long nextLong()
          将输入信息的下一个标记扫描为一个 long。
 long nextLong(int radix)
          将输入信息的下一个标记扫描为一个 long。
 short nextShort()
          将输入信息的下一个标记扫描为一个 short。
 short nextShort(int radix)
          将输入信息的下一个标记扫描为一个 short。
 int radix()
          返回此扫描器的默认基数。
 void remove()
          Iterator 的这种实现不支持移除操作。
 Scanner skip(Pattern pattern)
          在忽略分隔符的情况下跳过与指定模式匹配的输入信息。
 Scanner skip(String pattern)
          跳过与从指定字符串构造的模式匹配的输入信息。
 String toString()
          返回此 Scanner 的字符串表示形式。
 Scanner useDelimiter(Pattern pattern)
          将此扫描器的分隔模式设置为指定模式。
 Scanner useDelimiter(String pattern)
          将此扫描器的分隔模式设置为从指定 String 构造的模式。
 Scanner useLocale(Locale locale)
          将此扫描器的语言环境设置为指定的语言环境。
 Scanner useRadix(int radix)
          将此扫描器的默认基数设置为指定基数。
 
从类 java.lang.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

构造方法详细信息

Scanner

public Scanner(Readable source)
构造一个新的 Scanner，它生成的值是从指定源扫描的。

参数：
source - 实现 Readable 接口的字符源

Scanner

public Scanner(InputStream source)
构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。来自该流的字节通过基础平台的默认字符集转换成字符。

参数：
source - 要扫描的输入流

Scanner

public Scanner(InputStream source,
               String charsetName)
构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。来自该流的字节通过指定字符集转换成字符。

参数：
source - 要扫描的输入流
charsetName - 用于将来自该流的字节转换成要扫描的字符的编码类型
抛出：
IllegalArgumentException - 如果指定字符集不存在

Scanner

public Scanner(File source)
        throws FileNotFoundException
构造一个新的 Scanner，它生成的值是从指定文件扫描的。来自该文件的字节通过基础平台的默认字符集转换成字符。

参数：
source - 要扫描的文件
抛出：
FileNotFoundException - 如果源文件未找到

Scanner

public Scanner(File source,
               String charsetName)
        throws FileNotFoundException
构造一个新的 Scanner，它生成的值是从指定文件扫描的。来自该文件的字节通过指定字符集转换成字符。

参数：
source - 要扫描的文件
charsetName - 用于将来自该文件的字节转换成要扫描的字符的编码类型
抛出：
FileNotFoundException - 如果源文件未找到
IllegalArgumentException - 如果指定的编码未找到

Scanner

public Scanner(String source)
构造一个新的 Scanner，它生成的值是从指定字符串扫描的。

参数：
source - 要扫描的字符串

Scanner

public Scanner(ReadableByteChannel source)
构造一个新的 Scanner，它生成的值是从指定信道扫描的。来自该源的字节通过基础平台的默认字符集转换成字符。

参数：
source - 要扫描的信道

Scanner

public Scanner(ReadableByteChannel source,
               String charsetName)
构造一个新的 Scanner，它生成的值是从指定信道扫描的。来自该源的字节通过指定字符集转换成字符。

参数：
source - 要扫描的信道
charsetName - 用于将来自该信道的字节转换成要扫描的字符的编码类型
抛出：
IllegalArgumentException - 如果指定字符集不存在
方法详细信息

close

public void close()
关闭此扫描器。

如果此扫描器尚未关闭，并且其基础 readable 也实现 Closeable 接口，则该 readable 的 close 方法将被调用。如果此扫描器已经关闭，则调用此方法无效。

在扫描器关闭后执行搜索操作将导致 IllegalStateException。

ioException

public IOException ioException()
返回此 Scanner 的基础 Readable 最后抛出的 IOException。如果不存在这样的异常，则此方法返回 null。

返回：
此扫描器的 readable 最后抛出的异常

delimiter

public Pattern delimiter()
返回此 Scanner 当前正在用于匹配分隔符的 Pattern。

返回：
此扫描器的分隔模式。

useDelimiter

public Scanner useDelimiter(Pattern pattern)
将此扫描器的分隔模式设置为指定模式。

参数：
pattern - 分隔模式
返回：
此扫描器

useDelimiter

public Scanner useDelimiter(String pattern)
将此扫描器的分隔模式设置为从指定 String 构造的模式。

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

参数：
pattern - 指定分隔模式的字符串
返回：
此扫描器

locale

public Locale locale()
返回此扫描器的语言环境。

扫描器的语言环境会影响其与正则表达式匹配的默认基元的许多元素；参见上面的本地化数字。

返回：
此扫描器的语言环境

useLocale

public Scanner useLocale(Locale locale)
将此扫描器的语言环境设置为指定的语言环境。

扫描器的语言环境会影响其与正则表达式匹配的默认基元的许多元素；参见上面的本地化数字。

参数：
locale - 指定要使用的语言环境的字符串
返回：
此扫描器

radix

public int radix()
返回此扫描器的默认基数。

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

返回：
此扫描器的默认基数

useRadix

public Scanner useRadix(int radix)
将此扫描器的默认基数设置为指定基数。

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

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

参数：
radix - 扫描数时要使用的基数
返回：
此扫描器
抛出：
IllegalArgumentException - 如果基数超出范围

match

public MatchResult match()
返回此扫描器所执行的最后扫描操作的匹配结果。如果未执行匹配操作，或者最后的匹配操作失败，则此方法抛出 IllegalStateException。

如果 Scanner 的不同 next 方法执行结束时未抛出异常，则它们会给出一个匹配结果。例如，调用了 nextInt() 方法（它返回一个 int）后，此方法返回一个 MatchResult，作为搜索上述 Integer 正则表达式的结果。类似地，如果 findInLine(java.lang.String)、findWithinHorizon(java.lang.String, int) 和 skip(java.util.regex.Pattern) 方法的调用成功，则它们会给出一个匹配结果。

返回：
最后一次匹配操作的匹配结果
抛出：
IllegalStateException - 如果未给出匹配结果

toString

public String toString()

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

覆盖：
类 Object 中的 toString
返回：
此扫描器的字符串表示形式。

hasNext

public boolean hasNext()
如果此扫描器的输入中有另一个标记，则返回 true。在等待要扫描的输入时，此方法可能阻塞。扫描器将不执行任何输入。

指定者：
接口 Iterator<String> 中的 hasNext
返回：
当且仅当此扫描器有另一个标记时才返回 true
抛出：
IllegalStateException - 如果此扫描器已关闭
另请参见：
Iterator

next

public String next()
查找并返回来自此扫描器的下一个完整标记。完整标记的前后是与分隔模式匹配的输入信息。即使以前调用 hasNext() 返回了 true，在等待要扫描的输入时此方法也可能阻塞。

指定者：
接口 Iterator<String> 中的 next
返回：
下一个标记
抛出：
NoSuchElementException - 如果没有更多标记可用
IllegalStateException - 如果此扫描器已关闭
另请参见：
Iterator

remove

public void remove()
Iterator 的这种实现不支持移除操作。

指定者：
接口 Iterator<String> 中的 remove
抛出：
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)) 完全相同。

参数：
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 - 指定要搜索的模式的字符串
返回：
与指定模式匹配的文本
抛出：
IllegalStateException - 如果此扫描器已关闭
IllegalArgumentException - 如果 horizon 为负

findWithinHorizon

public String findWithinHorizon(Pattern pattern,
                                int horizon)
试图查找下一个指定模式。

此方法在忽略分隔符的情况下在指定的搜索范围内搜索输入信息。如果找到了该模式，则扫描器执行匹配的输入信息，并返回与该模式匹配的字符串。如果未找到，则返回 null，且扫描器的位置不变。在等待与该模式匹配的输入信息时，此方法可能阻塞。

扫描器的搜索永远都不超出其当前位置以外的 horizon 代码点。注意，匹配可能被 horizon 剪裁；也就是说，如果 horizon 变大，则任意匹配结果都可能不同。扫描器将 horizon 看作一个不固定的透明边界（请参见 Matcher.useTransparentBounds(boolean) 和 Matcher.useAnchoringBounds(boolean)）。

如果 horizon 为 0，则忽略 horizon，此方法继续在输入信息中查找指定的模式，且不设边界。在这种情况下，它可能会缓冲所有输入信息，并搜索该模式。

如果 horizon 为负，则抛出 IllegalArgumentException。

参数：
pattern - 要扫描的模式
返回：
与指定模式匹配的文本
抛出：
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|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。扫描器不执行任何输入。

参数：
radix - 用于将标记解释为一个字节值的基数
返回：
当且仅当此扫描器的下一个标记是有效的字节值时才返回 true
抛出：
IllegalStateException - 如果此扫描器已关闭

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。

参数：
radix - 用于将标记解释为字节值的基数
返回：
从输入信息扫描的 byte
抛出：
InputMismatchException - 如果下一个标记与 Integer 正则表达式不匹配，或者超出范围
NoSuchElementException - 如果输入信息已耗尽
IllegalStateException - 如果此扫描器已关闭

hasNextShort

public boolean hasNextShort()
如果通过使用 nextShort() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 short 值，则返回 true。扫描器不执行任何输入。

返回：
当且仅当此扫描器的下一个标记是默认基数中的有效的 short 值时才返回 true
抛出：
IllegalStateException - 如果此扫描器已关闭

hasNextShort

public boolean hasNextShort(int radix)
如果通过使用 nextShort() 方法，此扫描器输入信息中的下一个标记可以解释为指定基数中的一个 short 值，则返回 true。扫描器不执行任何输入。

参数：
radix - 用于将标记解释为一个 short 值的基数
返回：
当且仅当此扫描器的下一个标记是指定基数中的有效的 short 值时才返回 true
抛出：
IllegalStateException - 如果此扫描器已关闭

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。

参数：
radix - 用于将标记解释为 short 值的基数
返回：
从输入信息扫描的 short
抛出：
InputMismatchException - 如果下一个标记与 Integer 正则表达式不匹配，或者超出范围
NoSuchElementException - 如果输入信息已耗尽
IllegalStateException - 如果此扫描器已关闭

hasNextInt

public boolean hasNextInt()
如果通过使用 nextInt() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 int 值，则返回 true。扫描器不执行任何输入。

返回：
当且仅当此扫描器的下一个标记是有效的 int 值时才返回 true
抛出：
IllegalStateException - 如果此扫描器已关闭

hasNextInt

public boolean hasNextInt(int radix)
如果通过使用 nextInt() 方法，此扫描器输入信息中的下一个标记可以解释为指定基数中的一个 int 值，则返回 true。扫描器不执行任何输入。

参数：
radix - 用于将标记解释为一个 int 值的基数
返回：
当且仅当此扫描器的下一个标记是有效的 int 值时才返回 true
抛出：
IllegalStateException - 如果此扫描器已关闭

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。

参数：
radix - 用于将标记解释为 int 值的基数
返回：
从输入信息扫描的 int
抛出：
InputMismatchException - 如果下一个标记与 Integer 正则表达式不匹配，或者超出范围
NoSuchElementException - 如果输入信息已耗尽
IllegalStateException - 如果此扫描器已关闭

hasNextLong

public boolean hasNextLong()
如果通过使用 nextLong() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 long 值，则返回 true。扫描器不执行任何输入。

返回：
当且仅当此扫描器的下一个标记是有效的 long 值时才返回 true
抛出：
IllegalStateException - 如果此扫描器已关闭

hasNextLong

public boolean hasNextLong(int radix)
如果通过使用 nextLong() 方法，此扫描器输入信息中的下一个标记可以解释为指定基数中的一个 long 值，则返回 true。扫描器不执行任何输入。

参数：
radix - 用于将标记解释为一个 long 值的基数
返回：
当且仅当此扫描器的下一个标记是有效的 long 值时才返回 true
抛出：
IllegalStateException - 如果此扫描器已关闭

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 数字, 如果存在特定于语言环境的负前缀和后缀则预先挂起负号 (-)，以及将得到的字符串传递给带有指定基数的 Long.parseLong。

参数：
radix - 用于将标记解释为 long 值的基数
返回：
从输入信息扫描的 long
抛出：
InputMismatchException - 如果下一个标记与 Integer 正则表达式不匹配，或者超出范围
NoSuchElementException - 如果输入信息已耗尽
IllegalStateException - 如果此扫描器已关闭

hasNextFloat

public boolean hasNextFloat()
如果通过使用 nextFloat() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 float 值，则返回 true。扫描器不执行任何输入。

返回：
当且仅当此扫描器的下一个标记是有效的 float 值时才返回 true
抛出：
IllegalStateException - 如果此扫描器已关闭

nextFloat

public float nextFloat()
将输入信息的下一个标记扫描为一个 float。如果下一个标记不能转换为有效的 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 值时才返回 true
抛出：
IllegalStateException - 如果此扫描器已关闭

hasNextBigInteger

public boolean hasNextBigInteger(int radix)
如果通过使用 nextBigInteger() 方法，此扫描器输入信息中的下一个标记可以解释为指定基数中的一个 BigInteger 值，则返回 true。扫描器不执行任何输入。

参数：
radix - 用于将标记解释为一个 integer 的基数
返回：
当且仅当此扫描器的下一个标记是有效的 BigInteger 时才返回 true
抛出：
IllegalStateException - 如果此扫描器已关闭

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) 构造方法。

参数：
radix - 用于解释标记的基数
返回：
从输入信息扫描的 BigInteger
抛出：
InputMismatchException - 如果下一个标记与 Integer 正则表达式不匹配，或者超出范围
NoSuchElementException - 如果输入信息已耗尽
IllegalStateException - 如果此扫描器已关闭

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 - 如果此扫描器已关闭
概述  软件包   类  使用  树  已过时  索引  帮助 
JavaTM 2 Platform
Standard Ed. 5.0
 上一个类   下一个类 框架    无框架    
摘要： 嵌套 | 字段 | 构造方法 | 方法 详细信息： 字段 | 构造方法 | 方法
提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

版权所有 2004 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。