Integer.parseInt(scan.next()) 还是 scan.nextInt()？

发布于 2024-12-14 07:27:16 字数 317 浏览 1 评论 0原文

我在使用

import java.util.Scanner;
.
.
.
Scanner scan = new Scanner(System.in);
.
.
. 
Integer.parseInt(scan.next());

或

import java.util.Scanner;
.
.
.    
Scanner scan = new Scanner(System.in);
.
.
.
scan.nextInt();

哪个更有用或更准确的问题上摇摆不定；哪个跑得更快？

原文

I oscillate with using

import java.util.Scanner;
.
.
.
Scanner scan = new Scanner(System.in);
.
.
. 
Integer.parseInt(scan.next());

import java.util.Scanner;
.
.
.    
Scanner scan = new Scanner(System.in);
.
.
.
scan.nextInt();

Which one is more useful, or more precisely; which would be running faster?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

腹黑女流氓 2024-12-21 07:27:16

现在当然，这只是 Sun 实现，但下面是 nextInt(int radix) 实现。

请注意，它使用特殊模式 (integerPattern())。这意味着如果您使用 next() 您将使用默认模式。现在，如果您刚刚创建了一个 new Scanner()，您将使用典型的空白模式。但如果您使用不同的模式，您就无法确定您是否能识别出某个单词。您可能正在接电话或其他什么。

在一般情况下，我强烈推荐 nextInt()，因为它为您提供了一个抽象，为您提供了更少可能出错的信息，并在出现问题时提供更多信息。

闲暇时阅读以下内容：

public int nextInt(int radix) {
    // Check cached result
    if ((typeCache != null) && (typeCache instanceof Integer)
    && this.radix == radix) {
        int val = ((Integer)typeCache).intValue();
        useTypeCache();
        return val;
    }
    setRadix(radix);
    clearCaches();
    // Search for next int
    try {
        String s = next(integerPattern());
        if (matcher.group(SIMPLE_GROUP_INDEX) == null)
            s = processIntegerToken(s);
        return Integer.parseInt(s, radix);
    } catch (NumberFormatException nfe) {
        position = matcher.start(); // don't skip bad token
        throw new InputMismatchException(nfe.getMessage());
    }
}

Now granted, this is just the Sun implementation, but below is the nextInt(int radix) implementation.

Note that it uses a special pattern (integerPattern()). This means if you use next() you'll be using your default pattern. Now if you just made a new Scanner() you'll be using a typical whitespace pattern. But if you used a different pattern, you can't be certain you'll be picking up a word. You might be picking up a line or something.

In the general case I would highly recommend nextInt(), since it provides you with an abstraction, giving you less that's likely to go wrong, and more information when something does.

Read this at your leisure:

public int nextInt(int radix) {
    // Check cached result
    if ((typeCache != null) && (typeCache instanceof Integer)
    && this.radix == radix) {
        int val = ((Integer)typeCache).intValue();
        useTypeCache();
        return val;
    }
    setRadix(radix);
    clearCaches();
    // Search for next int
    try {
        String s = next(integerPattern());
        if (matcher.group(SIMPLE_GROUP_INDEX) == null)
            s = processIntegerToken(s);
        return Integer.parseInt(s, radix);
    } catch (NumberFormatException nfe) {
        position = matcher.start(); // don't skip bad token
        throw new InputMismatchException(nfe.getMessage());
    }
}

回复收藏 0 原文