用Java从System.in中读取的最快方法是什么？

67

我正在阅读使用标准中一堆用空格或换行符分隔的整数Scanner(System.in)。

用Java有没有更快的方法呢？

java  optimization  inputstream  stdin 
— 可悲的
source
— Crozin 2011年
您需要每秒读入几百万个整数？如果您的资产少于几百万，我将不必担心太多。
— 彼得·劳瑞
我在编程比赛中遇到了这个问题。您会得到成千上万的问题实例，每个实例都有成千上万的数字，这是很正常的（以确保您不会因复杂性差的解决方案而逃脱）。
— aioobe
1
是的，这是针对编程比赛的，我正在阅读数千行，而且我注意到C ++中的cin比Java中的Scanner快得多，并且想知道是否存在替代方案。
— pathikrit 2011年
未来的搜索者也应该关注此主题：stackoverflow.com/questions/691184/…– 2014
— 乔恩

Answers:

94

用Java有没有更快的方法呢？

是。扫描仪相当慢（至少根据我的经验）。

如果您不需要验证输入，建议您将流包装在BufferedInputStream中，并使用类似String.split/的东西Integer.parseInt。

比较一下：

使用此代码读取17兆字节（4233600个数字）

Scanner scanner = new Scanner(System.in);
while (scanner.hasNext())
    sum += scanner.nextInt();

我的机器花了3.3秒。而这个片段

BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
String line;
while ((line = bi.readLine()) != null)
    for (String numStr: line.split("\\s"))
        sum += Integer.parseInt(numStr);

花了0.7秒。

通过进一步弄乱代码（line使用String.indexOf/反复进行String.substring），您可以很容易地将其降低到约0.1秒，但是我想我已经回答了您的问题，并且我不想将其变成一些代码。

— Aioobe
source
但是，您最好有充分的理由将此类混乱情况添加到您的代码中。
— 瑞安·斯图尔特
21
String.split不如StringTokenizer快。要获得最有效的代码，请使用StringTokenizer
— kullalok 2013年
3

我创建了一个小的InputReader类，其工作方式与Java的Scanner相似，但在速度上却比其大很多，实际上，它也比BufferedReader还要好。这是一个条形图，显示了我创建的InputReader类的性能，该类已从标准输入读取不同类型的数据：

在此处输入图片说明

这是使用InputReader类查找System.in中所有数字之和的两种不同方法：

int sum = 0;
InputReader in = new InputReader(System.in);

// Approach #1
try {

    // Read all strings and then parse them to integers (this is much slower than the next method).
    String strNum = null;
    while( (strNum = in.nextString()) != null )
        sum += Integer.parseInt(strNum);

} catch (IOException e) { }

// Approach #2
try {

    // Read all the integers in the stream and stop once an IOException is thrown
    while( true ) sum += in.nextInt();

} catch (IOException e) { }
— 意志
source
不幸的InputReader.readLine()是，使用OpenJKD8的速度并没有明显快BufferedReader.readLine()。缓冲区大小为2048，流长度为2.5 MB。但更糟糕的是：代码中断（UTF-8）字符编码。
— try-catch-finally
3

如果您从竞争性编程的角度询问，如果提交速度不够快，它将是TLE。
然后，您可以检查以下方法从System.in中检索String。我摘自Java（竞争网站）最好的编码器之一

private String ns()
{
    int b = skip();
    StringBuilder sb = new StringBuilder();
    while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
        sb.appendCodePoint(b);
        b = readByte();
    }
    return sb.toString();
}`
— 洛克希·阿格劳瓦尔（Lokesh Agrawal）
source
1

您可以System.in逐位阅读。看看这个答案：https : //stackoverflow.com/a/2698772/3307066。

我将代码复制到此处（几乎未修改）。基本上，它读取整数，并用非数字分隔。（版权归原始作者所有。）

private static int readInt() throws IOException {
    int ret = 0;
    boolean dig = false;
    for (int c = 0; (c = System.in.read()) != -1; ) {
        if (c >= '0' && c <= '9') {
            dig = true;
            ret = ret * 10 + c - '0';
        } else if (dig) break;
    }
    return ret;
}

在我的问题中，这段代码是大约。比使用速度快2倍，而使用StringTokenizer速度已经快2倍String.split(" ")。（该问题涉及读取1百万个整数，每个整数最多1百万个。）

— 贾巴拉梅达
source
1

StringTokenizer 是一种读取由令牌分隔的字符串输入的更快方法。

检查下面的示例以读取由空格分隔的整数字符串并将其存储在arraylist中，

String str = input.readLine(); //read string of integers using BufferedReader e.g. "1 2 3 4"
List<Integer> list = new ArrayList<>();
StringTokenizer st = new StringTokenizer(str, " ");
while (st.hasMoreTokens()) {
    list.add(Integer.parseInt(st.nextToken()));
}
— 希特·拉赫
source
0

从编程的角度来看，此自定义的Scan and Print类比Java内置的Scanner和BufferedReader类要好得多。

import java.io.InputStream;
import java.util.InputMismatchException;
import java.io.IOException;

public class Scan
{

private byte[] buf = new byte[1024];

private int total;
private int index;
private InputStream in;

public Scan()
{
    in = System.in;
}

public int scan() throws IOException
{

    if(total < 0)
        throw new InputMismatchException();

    if(index >= total)
    {
        index = 0;
        total = in.read(buf);
        if(total <= 0)
            return -1;
    }

    return buf[index++];
}


public int scanInt() throws IOException
{

    int integer = 0;

    int n = scan();

    while(isWhiteSpace(n))   /*  remove starting white spaces   */
        n = scan();

    int neg = 1;
    if(n == '-')
    {
        neg = -1;
        n = scan();
    }

    while(!isWhiteSpace(n))
    {

        if(n >= '0' && n <= '9')
        {
            integer *= 10;
            integer += n-'0';
            n = scan();
        }
        else
            throw new InputMismatchException();
    }

    return neg*integer;
}


public String scanString()throws IOException
{
    StringBuilder sb = new StringBuilder();

    int n = scan();

    while(isWhiteSpace(n))
        n = scan();

    while(!isWhiteSpace(n))
    {
        sb.append((char)n);
        n = scan();
    }

    return sb.toString();
}


public double scanDouble()throws IOException
{
    double doub=0;
    int n=scan();
    while(isWhiteSpace(n))
    n=scan();
    int neg=1;
    if(n=='-')
    {
        neg=-1;
        n=scan();
    }
    while(!isWhiteSpace(n)&& n != '.')
    {
        if(n>='0'&&n<='9')
        {
            doub*=10;
            doub+=n-'0';
            n=scan();
        }
        else throw new InputMismatchException();
    }
    if(n=='.')
    {
        n=scan();
        double temp=1;
        while(!isWhiteSpace(n))
        {
            if(n>='0'&&n<='9')
            {
                temp/=10;
                doub+=(n-'0')*temp;
                n=scan();
            }
            else throw new InputMismatchException();
        }
    }
    return doub*neg;
}

public boolean isWhiteSpace(int n)
{
    if(n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1)
        return true;

    return false;
}

public void close()throws IOException
{
    in.close();
}
}

定制的Print类可以如下

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Print
{
private BufferedWriter bw;

public Print()
{
    this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
}


public void print(Object object)throws IOException
{
    bw.append("" + object);
}

public void println(Object object)throws IOException
{
    print(object);
    bw.append("\n");
}


public void close()throws IOException
{
    bw.close();
}

}
— 保罗92
source
0

您可以使用BufferedReader读取数据

BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));
  int t = Integer.parseInt(inp.readLine());
  while(t-->0){
    int n = Integer.parseInt(inp.readLine());
    int[] arr = new int[n];
    String line = inp.readLine();
    String[] str = line.trim().split("\\s+");
    for(int i=0;i<n;i++){
      arr[i] = Integer.parseInt(str[i]);
    }

并用于打印使用StringBuffer

    StringBuffer sb = new StringBuffer();
    for(int i=0;i<n;i++){
              sb.append(arr[i]+" "); 
            }
    System.out.println(sb);
— 狂行者
source
0

这是完整版本的快速读写器。我还使用了缓冲。

import java.io.*;
import java.util.*;


public class FastReader {
    private static StringTokenizer st;
    private static BufferedReader in;
    private static PrintWriter pw;


    public static void main(String[] args) throws IOException {

        in = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        st = new StringTokenizer("");

        pw.close();
    }

    private static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }
    private static long nextLong() throws IOException {
        return Long.parseLong(next());
    }
    private static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
    private static String next() throws IOException {
        while(!st.hasMoreElements() || st == null){
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }
}
— 萨纳特贝克先生
source
0

一次又一次地从磁盘读取，会使扫描仪变慢。我喜欢结合使用BufferedReader和Scanner来兼顾两者。即BufferredReader的速度和扫描仪丰富而便捷的API。

Scanner scanner = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
— 海森堡
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.