Java 我可以让下面的代码更快吗

我希望在不改变标准控制台的读/写操作的情况下，加快以下代码的速度。第一行包含输入的数量，随后的行包含一组

Integer

s

import java.util.StringTokenizer；
公共班机{
公共静态void main（字符串[]args）引发java.lang.Exception{
试一试{
java.io.BufferedReader r=new java.io.BufferedReader（new java.io.InputStreamReader（System.in））；
inta=Integer.parseInt（r.readLine（））；
for（int i=0；i

如果将

first

和

second

定义为primitive

int

s，而不是

java.lang.Integer

包装类，则可以在那里执行大量冗余的自动装箱和外装箱。但是，我怀疑，对于任何合理大小的输入，您都不会注意到差异。

您正在执行大量冗余的自动装箱和外装箱，如果您将

第一个
和
第二个
定义为基元
int
而不是
java.lang.Integer
包装类，则可以保存这些内容。然而，我怀疑，对于任何合理大小的输入，您是否会注意到差异。
这里有一些建议，我不确定这些建议会有多大帮助

1） 这个,

您没有第二次检查hasMoreTokens（）

4） 使用
split（）
而不是
StringTokenizer
。关于这方面的更多信息。
这里有一些建议，我不确定这些建议会有多大帮助

1） 这个,

您没有第二次检查hasMoreTokens（）

4） 使用
split（）
而不是
StringTokenizer
。关于这一点，
 下面可以考虑使用<代码> BufferedReader <代码>的构造函数：

public BufferedReader(Reader in, int sz)

为
sz
参数指定一个合理的高值，可以避免过于频繁地重新填充缓冲区


作为旁注，虽然
readLine（）
retuns
null
如果已到达流的末尾，最好在调用
new-StringTokenizer（r.readLine（））
和
Integer.parseInt（r.readLine（））
之前检查其返回值
编辑的类如下：

public class Main {

    public static void main(String[] args) {
        BufferedReader r;
        String line;
        StringTokenizer st;
        int a, first, second;

        r = new BufferedReader(new InputStreamReader(System.in), 4096);
        try {
            line = r.readLine();
            if (line != null) {
                a = Integer.parseInt(line);
                for (int i = 0; i < a; ++i) {
                    line = r.readLine();
                    if (line == null)
                        break;
                    st = new StringTokenizer(line);
                    while (st.hasMoreTokens()) {
                        first = Integer.parseInt(st.nextToken());
                        second = Integer.parseInt(st.nextToken());
                        if (first < second)
                            System.out.println("<");
                        else if (first > second)
                            System.out.println(">");
                        else
                            System.out.println("=");
                    }
                }
            }
            r.close();
        } catch (Exception e) {
            System.err.print(e.getMessage());
        }
    }
}

公共类主{
公共静态void main（字符串[]args）{
缓冲读取器r；
弦线；
StringTokenizer st；
int a，第一，第二；
r=新的BufferedReader（新的InputStreamReader（System.in）），4096；
试一试{
line=r.readLine（）；
如果（行！=null）{
a=整数.parseInt（行）；
对于（int i=0；i > p>下面可以考虑使用<代码> BufferedReader <代码>的构造函数：

public BufferedReader(Reader in, int sz)

为
sz
参数指定一个合理的高值，可以避免过于频繁地重新填充缓冲区


作为旁注，虽然
readLine（）
retuns
null
如果已到达流的末尾，最好在调用
new-StringTokenizer（r.readLine（））
和
Integer.parseInt（r.readLine（））
之前检查其返回值
编辑的类如下：

public class Main {

    public static void main(String[] args) {
        BufferedReader r;
        String line;
        StringTokenizer st;
        int a, first, second;

        r = new BufferedReader(new InputStreamReader(System.in), 4096);
        try {
            line = r.readLine();
            if (line != null) {
                a = Integer.parseInt(line);
                for (int i = 0; i < a; ++i) {
                    line = r.readLine();
                    if (line == null)
                        break;
                    st = new StringTokenizer(line);
                    while (st.hasMoreTokens()) {
                        first = Integer.parseInt(st.nextToken());
                        second = Integer.parseInt(st.nextToken());
                        if (first < second)
                            System.out.println("<");
                        else if (first > second)
                            System.out.println(">");
                        else
                            System.out.println("=");
                    }
                }
            }
            r.close();
        } catch (Exception e) {
            System.err.print(e.getMessage());
        }
    }
}

公共类主{
公共静态void main（字符串[]args）{
缓冲读取器r；
弦线；
StringTokenizer st；
int a，第一，第二；
r=新的BufferedReader（新的InputStreamReader（System.in）），4096；
试一试{
line=r.readLine（）；
如果（行！=null）{
a=整数.parseInt（行）；
对于（int i=0；i
您可以尝试使用a，但我不确定它是否会更快。首先：编写好代码。之后，调查效率。不要使用StringTokenizer。它已被几个版本的Java弃用，取而代之的是String的split方法。引用StringTokenizer api:StringTokenizer是一个遗留类，出于兼容性原因保留了它，尽管在新的c语言中不鼓励使用它
public class Main {

    public static void main(String[] args) {
        BufferedReader r;
        String line;
        StringTokenizer st;
        int a, first, second;

        r = new BufferedReader(new InputStreamReader(System.in), 4096);
        try {
            line = r.readLine();
            if (line != null) {
                a = Integer.parseInt(line);
                for (int i = 0; i < a; ++i) {
                    line = r.readLine();
                    if (line == null)
                        break;
                    st = new StringTokenizer(line);
                    while (st.hasMoreTokens()) {
                        first = Integer.parseInt(st.nextToken());
                        second = Integer.parseInt(st.nextToken());
                        if (first < second)
                            System.out.println("<");
                        else if (first > second)
                            System.out.println(">");
                        else
                            System.out.println("=");
                    }
                }
            }
            r.close();
        } catch (Exception e) {
            System.err.print(e.getMessage());
        }
    }
}