模块  java.base
软件包  java.util

Class Scanner

  • 实现的所有接口
    CloseableAutoCloseableIterator<String>

    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条目分配long类型:

    
          Scanner sc = new Scanner(new File("myNumbers"));
          while (sc.hasNextLong()) {
              long aLong = sc.nextLong();
          }
     

    扫描仪还可以使用除空白之外的分隔符。 此示例从字符串中读取几个项目:

    
         String input = "1 fish 2 fish red fish blue fish";
         Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*");
         System.out.println(s.nextInt());
         System.out.println(s.nextInt());
         System.out.println(s.next());
         System.out.println(s.next());
         s.close();
     

    打印以下输出:

    
         1
         2
         red
         blue
     

    使用此代码可以生成相同的输出,该代码使用正则表达式一次解析所有四个标记:

    
         String input = "1 fish 2 fish red fish blue fish";
         Scanner s = new Scanner(input);
         s.findInLine("(\\d+) fish (\\d+) fish (\\w+) fish (\\w+)");
         MatchResult result = s.match();
         for (int i=1; i<=result.groupCount(); i++)
             System.out.println(result.group(i));
         s.close();
     

    4502201395911识别扫描仪使用的default whitespace delimiter reset()方法将扫描仪分隔符的值重置为默认的空白分隔符,无论它是否先前已更改。

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

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

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

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

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

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

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

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

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

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

    Localized numbers

    此类的实例能够扫描标准格式的数字以及扫描程序的语言环境的格式。 扫描仪initial localeLocale.getDefault(Locale.Category.FORMAT)方法返回的值; 它可以通过useLocale()方法更改。 reset()方法将扫描程序的语言环境的值重置为初始语言环境,无论它是否先前已更改。

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

    LocalGroupSeparator  
    The character used to separate thousands groups, i.e.,  dfs. getGroupingSeparator()
    LocalDecimalSeparator  
    The character used for the decimal point, i.e.,  dfs. getDecimalSeparator()
    LocalPositivePrefix  
    The string that appears before a positive number (may be empty), i.e.,  df. getPositivePrefix()
    LocalPositiveSuffix  
    The string that appears after a positive number (may be empty), i.e.,  df. getPositiveSuffix()
    LocalNegativePrefix  
    The string that appears before a negative number (may be empty), i.e.,  df. getNegativePrefix()
    LocalNegativeSuffix  
    The string that appears after a negative number (may be empty), i.e.,  df. getNegativeSuffix()
    LocalNaN  
    The string that represents not-a-number for floating-point values, i.e.,  dfs. getNaN()
    LocalInfinity  
    The string that represents infinity for floating-point values, i.e.,  dfs. getInfinity()

    Number syntax

    可以通过以下正则表达式语法来指定可由该类的实例解析为数字的字符串,其中Rmax是所使用的基数中的最高位(例如,基数10中的Rmax是9)。

    NonAsciiDigit
    非ASCII字符c, Character.isDigit (c)返回true
    Non0Digit
    [1- Rmax ] | NonASCIIDigit
    数字
    [0- Rmax ] | NonASCIIDigit
    GroupedNumeral
    Non0Digit Digit ? Digit ?
    LocalGroupSeparator 数字 数字 )+ )
    数字
    ( ( 数字 + ) | GroupedNumeral )
    Integer:
    ( [-+]? ( 数字 ) )
    | LocalPositivePrefix 数字 LocalPositiveSuffix
    | LocalNegativePrefix 数字 LocalNegativeSuffix
    十进制数
    数字
    | 数字 LocalDecimalSeparator 数字 *
    | LocalDecimalSeparator 数字 +
    指数
    ( [eE] [+-]? 数字 + )
    Decimal:
    ( [-+]? DecimalNumeral 指数 ? )
    | LocalPositivePrefix DecimalNumeral LocalPositiveSuffix Exponent ?
    | LocalNegativePrefix DecimalNumeral LocalNegativeSuffix Exponent ?
    HexFloat
    [-+]? 0[xX][0-9a-fA-F]*\.[0-9a-fA-F]+ ([pP][-+]?[0-9]+)?
    非数字
    NaN | LocalNan | Infinity | LocalInfinity
    SignedNonNumber
    ( [-+]? NonNumber )
    | LocalPositivePrefix NonNumber LocalPositiveSuffix
    | LocalNegativePrefix NonNumber LocalNegativeSuffix
    Float
    十进制 | HexFloat | SignedNonNumber

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

    从以下版本开始:
    1.5
    • 构造方法摘要

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

      所有方法  实例方法 具体的方法 
      变量和类型 方法 描述
      void close()
      关闭此扫描仪。
      Pattern delimiter()
      返回 PatternScanner目前用于匹配分隔符。
      Stream<MatchResult> findAll​(String patString)
      返回与提供的模式字符串匹配的匹配结果流。
      Stream<MatchResult> findAll​(Pattern pattern)
      返回此扫描程序的匹配结果流。
      String findInLine​(String pattern)
      尝试查找从指定字符串构造的下一个模式,忽略分隔符。
      String findInLine​(Pattern pattern)
      尝试查找指定模式的下一个匹配项,忽略分隔符。
      String findWithinHorizon​(String pattern, int horizon)
      尝试查找从指定字符串构造的下一个模式,忽略分隔符。
      String findWithinHorizon​(Pattern pattern, int horizon)
      尝试查找指定模式的下一个匹配项。
      boolean hasNext()
      如果此扫描器的输入中有另一个标记,则返回true。
      boolean hasNext​(String pattern)
      如果下一个标记与从指定字符串构造的模式匹配,则返回true。
      boolean hasNext​(Pattern pattern)
      如果下一个完整标记与指定模式匹配,则返回true。
      boolean hasNextBigDecimal()
      如果此扫描器输入中的下一个标记可以使用 nextBigDecimal()方法解释为 BigDecimal则返回true。
      boolean hasNextBigInteger()
      如果此扫描器输入中的下一个标记可以使用 nextBigInteger()方法在默认基数中解释为 BigInteger ,则返回true。
      boolean hasNextBigInteger​(int radix)
      如果此扫描器输入中的下一个标记可以使用 nextBigInteger()方法在指定的基数中解释为 BigInteger ,则返回true。
      boolean hasNextBoolean()
      如果使用从字符串“true | false”创建的不区分大小写的模式,可以将此扫描器输入中的下一个标记解释为布尔值,则返回true。
      boolean hasNextByte()
      如果使用 nextByte()方法将此扫描器输入中的下一个标记解释为默认基数中的字节值,则返回true。
      boolean hasNextByte​(int radix)
      如果使用 nextByte()方法将此扫描器输入中的下一个标记解释为指定基数中的字节值,则返回true。
      boolean hasNextDouble()
      如果使用 nextDouble()方法将此扫描仪输入中的下一个标记解释为double值,则返回true。
      boolean hasNextFloat()
      如果使用 nextFloat()方法将此扫描器输入中的下一个标记解释为浮点值,则返回true。
      boolean hasNextInt()
      如果使用 nextInt()方法将此扫描器输入中的下一个标记解释为默认基数中的int值,则返回true。
      boolean hasNextInt​(int radix)
      如果此扫描器输入中的下一个标记可以使用 nextInt()方法解释为指定基数中的int值,则返回true。
      boolean hasNextLine()
      如果此扫描器的输入中有另一行,则返回true。
      boolean hasNextLong()
      如果使用 nextLong()方法将此扫描器输入中的下一个标记解释为默认基数中的长值,则返回true。
      boolean hasNextLong​(int radix)
      如果使用 nextLong()方法可以将此扫描器输入中的下一个标记解释为指定基数中的长值,则返回true。
      boolean hasNextShort()
      如果使用 nextShort()方法可以将此扫描器输入中的下一个标记解释为默认基数中的短值,则返回true。
      boolean hasNextShort​(int radix)
      如果此扫描器输入中的下一个标记可以使用 nextShort()方法解释为指定基数中的短值,则返回true。
      IOException ioException()
      返回 IOException最后通过此抛出 Scanner的基本 Readable
      Locale locale()
      返回此扫描程序的语言环境。
      MatchResult match()
      返回此扫描程序执行的上次扫描操作的匹配结果。
      String next()
      从此扫描仪查找并返回下一个完整令牌。
      String next​(String pattern)
      如果它与从指定字符串构造的模式匹配,则返回下一个标记。
      String next​(Pattern pattern)
      如果匹配指定的模式,则返回下一个标记。
      BigDecimal nextBigDecimal()
      将输入的下一个标记扫描为BigDecimal
      BigInteger nextBigInteger()
      将输入的下一个标记扫描为BigInteger
      BigInteger nextBigInteger​(int radix)
      将输入的下一个标记扫描为BigInteger
      boolean nextBoolean()
      将输入的下一个标记扫描为布尔值并返回该值。
      byte nextByte()
      将输入的下一个标记扫描为 byte
      byte nextByte​(int radix)
      将输入的下一个标记扫描为 byte
      double nextDouble()
      将输入的下一个标记扫描为 double
      float nextFloat()
      将输入的下一个标记扫描为 float
      int nextInt()
      将输入的下一个标记扫描为 int
      int nextInt​(int radix)
      将输入的下一个标记扫描为 int
      String nextLine()
      使此扫描器前进超过当前行并返回跳过的输入。
      long nextLong()
      将输入的下一个标记扫描为 long
      long nextLong​(int radix)
      将输入的下一个标记扫描为 long
      short nextShort()
      将输入的下一个标记扫描为 short
      short nextShort​(int radix)
      将输入的下一个标记扫描为 short
      int radix()
      返回此扫描器的默认基数。
      void remove()
      Iterator的此实现不支持删除操作。
      Scanner reset()
      重置此扫描仪。
      Scanner skip​(String pattern)
      跳过与指定字符串构造的模式匹配的输入。
      Scanner skip​(Pattern pattern)
      跳过与指定模式匹配的输入,忽略分隔符。
      Stream<String> tokens()
      从此扫描程序返回分隔符分隔的标记流。
      String toString()
      返回此 Scanner的字符串表示 Scanner
      Scanner useDelimiter​(String pattern)
      将此扫描仪的分隔模式设置为从指定的 String构造的模式。
      Scanner useDelimiter​(Pattern pattern)
      将此扫描仪的分隔模式设置为指定的模式。
      Scanner useLocale​(Locale locale)
      将此扫描程序的语言环境设置为指定的语言环境。
      Scanner useRadix​(int radix)
      将此扫描仪的默认基数设置为指定的基数。
    • 构造方法详细信息

      • Scanner

        public Scanner​(Readable source)
        构造一个新的 Scanner ,它可以生成从指定源扫描的值。
        参数
        source - 实现Readable接口的字符源
      • Scanner

        public Scanner​(InputStream source)
        构造一个新的Scanner ,它生成从指定输入流扫描的值。 使用底层平台default charset将流中的字节转换为字符。
        参数
        source - 要扫描的输入流
      • Scanner

        public Scanner​(InputStream source,
                       String charsetName)
        构造一个新的Scanner ,它生成从指定输入流扫描的值。 使用指定的字符集将流中的字节转换为字符。
        参数
        source - 要扫描的输入流
        charsetName - 用于将流中的字节转换为要扫描的字符的编码类型
        异常
        IllegalArgumentException - 如果指定的字符集不存在
      • Scanner

        public Scanner​(InputStream source,
                       Charset charset)
        构造一个新的Scanner ,它生成从指定输入流扫描的值。 使用指定的字符集将流中的字节转换为字符。
        参数
        source - 要扫描的输入流
        charset - 用于将文件中的字节转换为要扫描的字符的字符集
        从以下版本开始:
        10
      • Scanner

        public Scanner​(File source,
                       String charsetName)
                throws FileNotFoundException
        构造一个新的Scanner ,它生成从指定文件扫描的值。 使用指定的字符集将文件中的字节转换为字符。
        参数
        source - 要扫描的文件
        charsetName - 用于将文件中的字节转换为要扫描的字符的编码类型
        异常
        FileNotFoundException - 如果找不到来源
        IllegalArgumentException - 如果未找到指定的编码
      • Scanner

        public Scanner​(File source,
                       Charset charset)
                throws IOException
        构造一个新的Scanner ,它生成从指定文件扫描的值。 使用指定的字符集将文件中的字节转换为字符。
        参数
        source - 要扫描的文件
        charset - 用于将文件中的字节转换为要扫描的字符的字符集
        异常
        IOException - 如果打开源发生I / O错误
        从以下版本开始:
        10
      • Scanner

        public Scanner​(Path source)
                throws IOException
        构造一个新的Scanner ,它生成从指定文件扫描的值。 使用底层平台default charset将文件中的字节转换为字符。
        参数
        source - 要扫描的文件的路径
        异常
        IOException - 如果打开源发生I / O错误
        从以下版本开始:
        1.7
      • Scanner

        public Scanner​(Path source,
                       String charsetName)
                throws IOException
        构造一个新的Scanner ,它生成从指定文件扫描的值。 使用指定的字符集将文件中的字节转换为字符。
        参数
        source - 要扫描的文件的路径
        charsetName - 用于将文件中的字节转换为要扫描的字符的编码类型
        异常
        IOException - 如果打开源发生I / O错误
        IllegalArgumentException - 如果未找到指定的编码
        从以下版本开始:
        1.7
      • Scanner

        public Scanner​(Path source,
                       Charset charset)
                throws IOException
        构造一个新的Scanner ,它生成从指定文件扫描的值。 使用指定的字符集将文件中的字节转换为字符。
        参数
        source - 要扫描的文件的路径
        charset - 用于将文件中的字节转换为要扫描的字符的字符集
        异常
        IOException - 如果打开源发生I / O错误
        从以下版本开始:
        10
      • Scanner

        public Scanner​(String source)
        构造一个新的 Scanner ,它生成从指定字符串扫描的值。
        参数
        source - 要扫描的字符串
      • Scanner

        public Scanner​(ReadableByteChannel source)
        构造一个新的Scanner ,它可以生成从指定通道扫描的值。 使用底层平台default charset将来自源的字节转换为字符。
        参数
        source - 要扫描的通道
      • Scanner

        public Scanner​(ReadableByteChannel source,
                       String charsetName)
        构造一个新的Scanner ,它可以生成从指定通道扫描的值。 使用指定的字符集将源中的字节转换为字符。
        参数
        source - 要扫描的通道
        charsetName - 用于将字节从通道转换为要扫描的字符的编码类型
        异常
        IllegalArgumentException - 如果指定的字符集不存在
      • Scanner

        public Scanner​(ReadableByteChannel source,
                       Charset charset)
        构造一个新的Scanner ,它可以生成从指定通道扫描的值。 使用指定的字符集将源中的字节转换为字符。
        参数
        source - 要扫描的频道
        charset - 用于将字节从通道转换为要扫描的字符的编码类型
        从以下版本开始:
        10
    • 方法详细信息

      • close

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

        如果此扫描程序尚未关闭,那么如果其底层readable也实现了Closeable接口,则将调用可读的close方法。 如果此扫描仪已关闭,则调用此方法将不起作用。

        扫描仪关闭后尝试执行搜索操作将导致IllegalStateException

        Specified by:
        close在界面 AutoCloseable
        Specified by:
        close在界面 Closeable
      • ioException

        public IOException ioException()
        返回IOException最后通过此抛出Scanner的基本Readable 如果不存在此类异常,则此方法返回null
        结果
        此扫描仪可读的最后一个异常
      • delimiter

        public Pattern delimiter()
        返回 PatternScanner目前用于匹配分隔符。
        结果
        这个扫描仪的分界模式。
      • useDelimiter

        public Scanner useDelimiter​(Pattern pattern)
        将此扫描仪的分隔模式设置为指定的模式。
        参数
        pattern - pattern模式
        结果
        这个扫描仪
      • useDelimiter

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

        调用useDelimiter(pattern)形式的此方法的行为与调用useDelimiter(Pattern.compile(pattern))

        调用reset()方法会将扫描仪的分隔符设置为default

        参数
        pattern - 指定分隔模式的字符串
        结果
        这个扫描仪
      • locale

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

        扫描程序的语言环境会影响与正则表达式匹配的默认基元的许多元素; 见上面的localized numbers

        结果
        这个扫描仪的语言环境
      • useLocale

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

        扫描程序的语言环境会影响与正则表达式匹配的默认基元的许多元素; 见上面的localized numbers

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

        参数
        locale - 指定要使用的语言环境的字符串
        结果
        这个扫描仪
      • radix

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

        扫描仪的基数会影响与正则表达式匹配的默认数字元素; 见上面的localized numbers

        结果
        此扫描仪的默认基数
      • useRadix

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

        扫描仪的基数会影响与正则表达式匹配的默认数字元素; 见上面的localized numbers

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

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

        参数
        radix - 扫描数字时使用的基数
        结果
        这个扫描仪
        异常
        IllegalArgumentException - 如果基数超出范围
      • match

        public MatchResult match()
        返回此扫描程序执行的上次扫描操作的匹配结果。 如果未执行匹配,或者最后一次匹配IllegalStateException则此方法抛出IllegalStateException

        各种next的方法Scanner使,如果他们完成未抛出异常的比赛结果可用。 例如,在调用返回int的nextInt()方法之后,此方法返回MatchResult以搜索上面定义的Integer正则表达式。 同样, findInLine()findWithinHorizon()skip()方法将一个匹配结果,如果他们取得成功。

        结果
        最后一次匹配操作的匹配结果
        异常
        IllegalStateException - 如果没有可用的匹配结果
      • toString

        public String toString()

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

        重写:
        toString课程类别 Object
        结果
        此扫描程序的字符串表示形式
      • hasNext

        public boolean hasNext()
        如果此扫描器的输入中有另一个标记,则返回true。 在等待输入扫描时,此方法可能会阻塞。 扫描仪不会超过任何输入。
        Specified by:
        hasNext ,界面 Iterator<String>
        结果
        当且仅当此扫描器具有另一个令牌时才返回true
        异常
        IllegalStateException - 如果此扫描仪已关闭
        另请参见:
        Iterator
      • next

        public String next()
        从此扫描仪查找并返回下一个完整令牌。 在完成令牌之前和之后是与分隔符模式匹配的输入。 即使先前调用hasNext()返回true ,此方法也可能在等待输入扫描时true
        Specified by:
        next接口 Iterator<String>
        结果
        下一个标记
        异常
        NoSuchElementException - 如果没有更多令牌可用
        IllegalStateException - 如果此扫描仪已关闭
        另请参见:
        Iterator
      • hasNext

        public boolean hasNext​(String pattern)
        如果下一个标记与从指定字符串构造的模式匹配,则返回true。 扫描仪不会超过任何输入。

        调用hasNext(pattern)形式的此方法的行为与调用hasNext(Pattern.compile(pattern))

        参数
        pattern - 指定要扫描的模式的字符串
        结果
        当且仅当此扫描程序具有与指定模式匹配的另一个标记时才返回true
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • next

        public String next​(String pattern)
        如果它与从指定字符串构造的模式匹配,则返回下一个标记。 如果匹配成功,扫描仪将超过与模式匹配的输入。

        调用next(pattern)形式的此方法的行为与调用next(Pattern.compile(pattern))方式next(Pattern.compile(pattern))

        参数
        pattern - 指定要扫描的模式的字符串
        结果
        下一个标记
        异常
        NoSuchElementException - 如果没有此类令牌可用
        IllegalStateException - 如果此扫描仪已关闭
      • hasNext

        public boolean hasNext​(Pattern pattern)
        如果下一个完整标记与指定模式匹配,则返回true。 一个完整的标记是前缀,后缀是与分隔符模式匹配的输入。 此方法可能在等待输入时阻塞。 扫描仪不会超过任何输入。
        参数
        pattern - 要扫描的模式
        结果
        当且仅当此扫描程序具有与指定模式匹配的另一个标记时才返回true
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • next

        public String next​(Pattern pattern)
        如果匹配指定的模式,则返回下一个标记。 即使先前调用hasNext(Pattern)返回true ,此方法也可能在等待输入扫描时true 如果匹配成功,扫描仪将超过与模式匹配的输入。
        参数
        pattern - 要扫描的模式
        结果
        下一个标记
        异常
        NoSuchElementException - 如果没有更多令牌可用
        IllegalStateException - 如果此扫描仪已关闭
      • hasNextLine

        public boolean hasNextLine()
        如果此扫描器的输入中有另一行,则返回true。 此方法可能在等待输入时阻塞。 扫描仪不会超过任何输入。
        结果
        当且仅当此扫描仪具有另一行输入时才为真
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • nextLine

        public String nextLine()
        使此扫描器前进超过当前行并返回跳过的输入。 此方法返回当前行的其余部分,不包括末尾的任何行分隔符。 该位置设置为下一行的开头。

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

        结果
        跳过的行
        异常
        NoSuchElementException - 如果未找到任何行
        IllegalStateException - 如果此扫描仪已关闭
      • findInLine

        public String findInLine​(String pattern)
        尝试查找从指定字符串构造的下一个模式,忽略分隔符。

        调用findInLine(pattern)形式的此方法的行为与调用findInLine(Pattern.compile(pattern))

        参数
        pattern - 指定要搜索的模式的字符串
        结果
        与指定模式匹配的文本
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • findInLine

        public String findInLine​(Pattern pattern)
        尝试查找指定模式的下一个匹配项,忽略分隔符。 如果在下一行分隔符之前找到该模式,则扫描程序将超过匹配的输入并返回与该模式匹配的字符串。 如果在直到下一行分隔符的输入中未检测到此类模式,则返回null并且扫描仪的位置保持不变。 此方法可能会阻止等待与模式匹配的输入。

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

        参数
        pattern - 要扫描的模式
        结果
        与指定模式匹配的文本
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • findWithinHorizon

        public String findWithinHorizon​(String pattern,
                                        int horizon)
        尝试查找从指定字符串构造的下一个模式,忽略分隔符。

        调用findWithinHorizon(pattern)形式的此方法的行为与调用findWithinHorizon(Pattern.compile(pattern), horizon)

        参数
        pattern - 指定要搜索的模式的字符串
        horizon - 搜索范围
        结果
        与指定模式匹配的文本
        异常
        IllegalStateException - 如果此扫描仪已关闭
        IllegalArgumentException - 如果地平线是负面的
      • findWithinHorizon

        public String findWithinHorizon​(Pattern pattern,
                                        int horizon)
        尝试查找指定模式的下一个匹配项。

        此方法搜索输入到指定的搜索范围,忽略分隔符。 如果找到模式,扫描仪将超过匹配的输入并返回与模式匹配的字符串。 如果未检测到此类模式,则返回null并且扫描仪的位置保持不变。 此方法可能会阻止等待与模式匹配的输入。

        扫描仪永远不会搜索超过其当前位置的horizon代码点。 请注意,匹配可能会被地平线限制; 也就是说,如果地平线较大,任意匹配结果可能会有所不同。 扫描仪将地平线视为透明的非锚定边界(参见Matcher.useTransparentBounds(boolean)Matcher.useAnchoringBounds(boolean) )。

        如果horizon是0 ,则忽略horizon,此方法继续搜索输入,查找指定的模式而不绑定。 在这种情况下,它可以缓冲搜索模式的所有输入。

        如果horizon是负数,则抛出IllegalArgumentException。

        参数
        pattern - 要扫描的模式
        horizon - 搜索范围
        结果
        与指定模式匹配的文本
        异常
        IllegalStateException - 如果此扫描仪已关闭
        IllegalArgumentException - 如果地平线是负面的
      • skip

        public Scanner skip​(Pattern pattern)
        跳过与指定模式匹配的输入,忽略分隔符。 如果指定模式的锚定匹配成功,则此方法将跳过输入。

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

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

        请注意,可以通过使用无法匹配的模式(例如, sc.skip("[ \t]*")跳过某些内容而不会冒NoSuchElementException的风险。

        参数
        pattern - 指定要跳过的模式的字符串
        结果
        这个扫描仪
        异常
        NoSuchElementException - 如果未找到指定的模式
        IllegalStateException - 如果此扫描仪已关闭
      • skip

        public Scanner skip​(String pattern)
        跳过与指定字符串构造的模式匹配的输入。

        调用skip(pattern)形式的此方法的行为与调用skip(Pattern.compile(pattern))方式skip(Pattern.compile(pattern))

        参数
        pattern - 指定要跳过的模式的字符串
        结果
        这个扫描仪
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • hasNextBoolean

        public boolean hasNextBoolean()
        如果使用从字符串“true | false”创建的不区分大小写的模式,可以将此扫描器输入中的下一个标记解释为布尔值,则返回true。 扫描仪不会超过匹配的输入。
        结果
        当且仅当此扫描器的下一个标记是有效的布尔值时才返回true
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • nextBoolean

        public boolean nextBoolean()
        将输入的下一个标记扫描为布尔值并返回该值。 如果下一个标记无法转换为有效的布尔值,则此方法将抛出InputMismatchException 如果匹配成功,扫描仪将超过匹配的输入。
        结果
        从输入扫描的布尔值
        异常
        InputMismatchException - 如果下一个标记不是有效的布尔值
        NoSuchElementException - 如果输入已用尽
        IllegalStateException - 如果此扫描仪已关闭
      • hasNextByte

        public boolean hasNextByte()
        如果使用nextByte()方法将此扫描器输入中的下一个标记解释为默认基数中的字节值,则返回true。 扫描仪不会超过任何输入。
        结果
        当且仅当此扫描器的下一个标记是有效字节值时才为true
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • hasNextByte

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

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

        参数
        radix - 用于将令牌解释为字节值的基数
        结果
        当且仅当此扫描器的下一个标记是有效字节值时才为true
        异常
        IllegalStateException - 如果此扫描仪已关闭
        IllegalArgumentException - 如果基数超出范围
      • nextByte

        public byte nextByte()
        将输入的下一个标记扫描为byte

        调用nextByte()形式的此方法的行为与调用nextByte(radix) ,其中radix是此扫描程序的默认基数。

        结果
        byte从输入扫描
        异常
        InputMismatchException - 如果下一个标记与 整数正则表达式不匹配,或者超出范围
        NoSuchElementException - 如果输入已用尽
        IllegalStateException - 如果此扫描仪已关闭
      • nextByte

        public byte nextByte​(int radix)
        将输入的下一个标记扫描为byte 如果下一个令牌无法转换为有效字节值,则此方法将抛出InputMismatchException ,如下所述。 如果翻译成功,扫描仪将超过匹配的输入。

        如果下一个标记与上面定义的Integer正则表达式匹配,则标记将转换为byte值,就像删除所有特定于区域设置的前缀,组分隔符和特定于区域设置的后缀一样,然后通过Character.digit将非ASCII数字映射为ASCII数字, 前置如果存在特定于区域设置的负前缀和后缀,则将负号( - )传递给具有指定基数的Byte.parseByte

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

        参数
        radix - 用于将令牌解释为字节值的基数
        结果
        从输入扫描 byte
        异常
        InputMismatchException - 如果下一个标记与 整数正则表达式不匹配,或者超出范围
        NoSuchElementException - 如果输入已用尽
        IllegalStateException - 如果此扫描仪已关闭
        IllegalArgumentException - 如果基数超出范围
      • hasNextShort

        public boolean hasNextShort()
        如果使用nextShort()方法将此扫描器输入中的下一个标记解释为默认基数中的短值,则返回true。 扫描仪不会超过任何输入。
        结果
        当且仅当此扫描器的下一个标记是默认基数中的有效短值时才为true
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • hasNextShort

        public boolean hasNextShort​(int radix)
        如果使用nextShort()方法将此扫描器输入中的下一个标记解释为指定基数中的短值,则返回true。 扫描仪不会超过任何输入。

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

        参数
        radix - 用于将令牌解释为短值的基数
        结果
        当且仅当此扫描器的下一个标记是指定基数中的有效短值时才为true
        异常
        IllegalStateException - 如果此扫描仪已关闭
        IllegalArgumentException - 如果基数超出范围
      • nextShort

        public short nextShort​(int radix)
        将输入的下一个标记扫描为short 如果下一个令牌无法转换为有效的短值,则此方法将抛出InputMismatchException ,如下所述。 如果翻译成功,扫描仪将超过匹配的输入。

        如果下一个标记与上面定义的Integer正则表达式匹配,则标记将转换为short值,就好像通过删除所有特定于区域设置的前缀,组分隔符和特定于区域设置的后缀,然后通过Character.digit将非ASCII数字映射到ASCII数字, 前置如果存在特定于区域设置的负前缀和后缀,则将负号( - )传递给具有指定基数的Short.parseShort

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

        参数
        radix - 用于将令牌解释为短值的基数
        结果
        short从输入扫描
        异常
        InputMismatchException - 如果下一个标记与 整数正则表达式不匹配,或者超出范围
        NoSuchElementException - 如果输入已用尽
        IllegalStateException - 如果此扫描仪已关闭
        IllegalArgumentException - 如果基数超出范围
      • hasNextInt

        public boolean hasNextInt()
        如果此扫描器输入中的下一个标记可以使用nextInt()方法解释为默认基数中的int值,则返回true。 扫描仪不会超过任何输入。
        结果
        当且仅当此扫描程序的下一个标记是有效的int值时才返回true
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • hasNextInt

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

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

        参数
        radix - 用于将令牌解释为int值的基数
        结果
        当且仅当此扫描程序的下一个标记是有效的int值时才返回true
        异常
        IllegalStateException - 如果此扫描仪已关闭
        IllegalArgumentException - 如果基数超出范围
      • nextInt

        public int nextInt()
        将输入的下一个标记扫描为int

        调用nextInt()形式的此方法的行为与调用nextInt(radix) ,其中radix是此扫描程序的默认基数。

        结果
        int从输入扫描
        异常
        InputMismatchException - 如果下一个标记与 整数正则表达式不匹配,或者超出范围
        NoSuchElementException - 如果输入已用尽
        IllegalStateException - 如果此扫描仪已关闭
      • nextInt

        public int nextInt​(int radix)
        将输入的下一个标记扫描为int 如果下一个令牌无法转换为有效的int值,则此方法将抛出InputMismatchException ,如下所述。 如果翻译成功,扫描仪将超过匹配的输入。

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

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

        参数
        radix - 用于将标记解释为int值的基数
        结果
        int从输入扫描
        异常
        InputMismatchException - 如果下一个标记与 整数正则表达式不匹配,或者超出范围
        NoSuchElementException - 如果输入已用尽
        IllegalStateException - 如果此扫描仪已关闭
        IllegalArgumentException - 如果基数超出范围
      • hasNextLong

        public boolean hasNextLong()
        如果使用nextLong()方法将此扫描器输入中的下一个标记解释为默认基数中的long值,则返回true。 扫描仪不会超过任何输入。
        结果
        当且仅当此扫描器的下一个标记是有效的长值时才为true
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • hasNextLong

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

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

        参数
        radix - 用于将令牌解释为长值的基数
        结果
        当且仅当此扫描器的下一个标记是有效的长值时才为true
        异常
        IllegalStateException - 如果此扫描仪已关闭
        IllegalArgumentException - 如果基数超出范围
      • nextLong

        public long nextLong()
        将输入的下一个标记扫描为long

        调用nextLong()形式的此方法的行为与调用nextLong(radix) ,其中radix是此扫描程序的默认基数。

        结果
        long从输入扫描
        异常
        InputMismatchException - 如果下一个标记与 整数正则表达式不匹配,或者超出范围
        NoSuchElementException - 如果输入已用尽
        IllegalStateException - 如果此扫描仪已关闭
      • nextLong

        public long nextLong​(int radix)
        将输入的下一个标记扫描为long 如果下一个令牌无法转换为有效的长值,则此方法将抛出InputMismatchException ,如下所述。 如果翻译成功,扫描仪将超过匹配的输入。

        如果下一个标记与上面定义的Integer正则表达式匹配, 则将标记转换为long值,就好像通过删除所有特定于区域设置的前缀,组分隔符和特定于区域设置的后缀,然后通过Character.digit将非ASCII数字映射到ASCII数字, 前置如果存在特定于区域设置的负前缀和后缀,则使用负号( - ),并将结果字符串传递给具有指定基数的Long.parseLong

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

        参数
        radix - 用于将标记解释为int值的基数
        结果
        从输入扫描 long
        异常
        InputMismatchException - 如果下一个标记与 整数正则表达式不匹配,或者超出范围
        NoSuchElementException - 如果输入已用尽
        IllegalStateException - 如果此扫描仪已关闭
        IllegalArgumentException - 如果基数超出范围
      • hasNextFloat

        public boolean hasNextFloat()
        如果使用nextFloat()方法可以将此扫描器输入中的下一个标记解释为浮点值,则返回true。 扫描仪不会超过任何输入。
        结果
        当且仅当此扫描器的下一个标记是有效的浮点值时才返回true
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • nextFloat

        public float nextFloat()
        将输入的下一个标记扫描为float 如果下一个令牌无法转换为有效的浮点值,则此方法将抛出InputMismatchException ,如下所述。 如果翻译成功,扫描仪将超过匹配的输入。

        如果下一个标记与上面定义的Float正则表达式匹配, 则将标记转换为float值,就好像通过删除所有特定于区域设置的前缀,组分隔符和特定于区域设置的后缀,然后通过Character.digit将非ASCII数字映射到ASCII数字, 前置如果存在特定于区域设置的负前缀和后缀,则为负号( - ),并将结果字符串传递给Float.parseFloat 如果令牌与本地化的NaN或无穷大字符串匹配,则“Nan”或“Infinity”将根据需要传递给Float.parseFloat

        结果
        从输入扫描 float
        异常
        InputMismatchException - 如果下一个标记与 Float正则表达式不匹配,或者超出范围
        NoSuchElementException - 如果输入已用尽
        IllegalStateException - 如果此扫描仪已关闭
      • hasNextDouble

        public boolean hasNextDouble()
        如果使用nextDouble()方法将此扫描仪输入中的下一个标记解释为double值,则返回true。 扫描仪不会超过任何输入。
        结果
        当且仅当此扫描器的下一个标记是有效的double值时才为true
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • nextDouble

        public double nextDouble()
        将输入的下一个标记扫描为double 如果下一个标记无法转换为有效的double值,则此方法将抛出InputMismatchException 如果翻译成功,扫描仪将超过匹配的输入。

        如果下一个标记与上面定义的Float正则表达式匹配,则标记将转换为double值,就好像通过删除所有特定于区域设置的前缀,组分隔符和特定于区域设置的后缀,然后通过Character.digit将非ASCII数字映射到ASCII数字, 前置如果存在特定于区域设置的负前缀和后缀,则将负号( - )传递给Double.parseDouble 如果令牌与本地化的NaN或无穷大字符串匹配,则“Nan”或“Infinity”将根据需要传递给Double.parseDouble

        结果
        从输入扫描 double
        异常
        InputMismatchException - 如果下一个标记与 Float正则表达式不匹配,或者超出范围
        NoSuchElementException - 如果输入已用尽
        IllegalStateException - 如果此扫描仪已关闭
      • hasNextBigInteger

        public boolean hasNextBigInteger()
        如果使用nextBigInteger()方法将此扫描器输入中的下一个标记解释为默认基数中的BigInteger ,则返回true。 扫描仪不会超过任何输入。
        结果
        当且仅当此扫描器的下一个令牌是有效的 BigInteger
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • hasNextBigInteger

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

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

        参数
        radix - 用于将标记解释为整数的基数
        结果
        当且仅当此扫描程序的下一个标记是有效的 BigInteger
        异常
        IllegalStateException - 如果此扫描仪已关闭
        IllegalArgumentException - 如果基数超出范围
      • nextBigInteger

        public BigInteger nextBigInteger()
        将输入的下一个标记扫描为BigInteger

        调用nextBigInteger()形式的此方法的行为与调用nextBigInteger(radix) ,其中radix是此扫描程序的默认基数。

        结果
        BigInteger从输入扫描
        异常
        InputMismatchException - 如果下一个标记与 整数正则表达式不匹配,或者超出范围
        NoSuchElementException - 如果输入已用尽
        IllegalStateException - 如果此扫描仪已关闭
      • hasNextBigDecimal

        public boolean hasNextBigDecimal()
        如果此扫描器输入中的下一个标记可以使用nextBigDecimal()方法解释为BigDecimal则返回true。 扫描仪不会超过任何输入。
        结果
        当且仅当此扫描器的下一个令牌是有效的 BigDecimal
        异常
        IllegalStateException - 如果此扫描仪已关闭
      • reset

        public Scanner reset()
        重置此扫描仪。

        重置扫描器会丢弃所有可能已经通过调用改变了明确的状态信息useDelimiter()useLocale() ,或useRadix()

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

        
           scanner.useDelimiter("\\p{javaWhitespace}+")
                  .useLocale(Locale.getDefault(Locale.Category.FORMAT))
                  .useRadix(10);
         
        结果
        这个扫描仪
        从以下版本开始:
        1.6
      • tokens

        public Stream<String> tokens()
        从此扫描程序返回分隔符分隔的标记流。 该流包含将从此扫描器的当前状态开始返回的相同标记,方法是重复调用next()方法,直到hasNext()方法返回false。

        生成的流是顺序的并且是有序的。 所有流元素都是非null。

        使用该扫描仪的当前状态,在启动终端流操作时开始扫描。 close()ioException()以外的此扫描仪上的任何方法的后续调用可能会返回未定义的结果,或者可能会对返回的流造成不确定的影响。 返回流的源Spliterator快速失败的并且如果在流管道执行期间检测到任何此类调用,则将尽最大努力抛出ConcurrentModificationException

        流管道执行完成后,此扫描程序将处于不确定状态,无法重复使用。

        如果此扫描程序包含必须释放的资源,则应通过调用其close()方法或关闭返回的流来关闭此扫描程序。 关闭流将关闭底层扫描程序。 如果在调用此方法时扫描程序已关闭,或者在流管道执行期间关闭此扫描程序,则抛出IllegalStateException

        此方法可能会阻止等待更多输入。

        API Note:
        例如,以下代码将从字符串创建逗号分隔的标记列表:
           List<String> result = new Scanner("abc,def,,ghi") .useDelimiter(",") .tokens() .collect(Collectors.toList());  

        结果列表将包含"abc""def" ,空字符串,和"ghi"

        结果
        令牌字符串的连续流
        异常
        IllegalStateException - 如果此扫描仪已关闭
        从以下版本开始:
        9
      • findAll

        public Stream<MatchResult> findAll​(Pattern pattern)
        返回此扫描程序的匹配结果流。 只要findWithinHorizon()找到匹配项,流就会以相同的顺序包含相同的结果,通过调用findWithinHorizon(pattern, 0)match()返回。

        生成的流是顺序的并且是有序的。 所有流元素都是非null。

        使用该扫描仪的当前状态,在启动终端流操作时开始扫描。 close()ioException()以外的此扫描仪上的任何方法的后续调用可能会返回未定义的结果,或者可能会对返回的流造成未定义的影响。 返回的流的源Spliterator快速失败的 ,如果在流管道执行期间检测到任何此类调用,则将尽最大努力抛出ConcurrentModificationException

        流管道执行完成后,此扫描程序将处于不确定状态,无法重复使用。

        如果此扫描程序包含必须释放的资源,则应通过调用其close()方法或关闭返回的流来关闭此扫描程序。 关闭流将关闭底层扫描程序。 如果在调用此方法时扫描程序已关闭,或者在流管道执行期间关闭此扫描程序,则抛出IllegalStateException

        findWithinHorizon()方法一样,此方法可能会阻止等待其他输入,并且可能会缓冲搜索匹配的无限量输入。

        API Note:
        例如,以下代码将读取文件并返回由七个或更多拉丁大写字母组成的所有字符序列的列表:
           try (Scanner sc = new Scanner(Path.of("input.txt"))) { Pattern pat = Pattern.compile("[A-Z]{7,}"); List<String> capWords = sc.findAll(pat) .map(MatchResult::group) .collect(Collectors.toList()); }  
        参数
        pattern - 要匹配的模式
        结果
        连续的匹配结果流
        异常
        NullPointerException - 如果pattern为null
        IllegalStateException - 如果此扫描仪已关闭
        从以下版本开始:
        9
      • findAll

        public Stream<MatchResult> findAll​(String patString)
        返回与提供的模式字符串匹配的匹配结果流。 效果等同于以下代码:
           scanner.findAll(Pattern.compile(patString))  
        参数
        patString - 模式字符串
        结果
        连续的匹配结果流
        异常
        NullPointerException - 如果patString为null
        IllegalStateException - 如果此扫描仪已关闭
        PatternSyntaxException - 如果正则表达式的语法无效
        从以下版本开始:
        9
        另请参见:
        Pattern