Question

我正在做这样的事情：

for (int i = 0; i < 100000; i++) {
   System.out.println( i );
}

基本上，我计算一个整数并输出一个大约10K-100K次的字符串，然后需要将结果写入system.out，每个结果用换行符分隔。

实现这一目标的最快方法是什么？

Answer 1

感谢您的建议。我创建了一个测试程序来比较它们：

import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.lang.StringBuilder;

public class systemouttest {

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

        long starttime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
           System.out.println( i );
        }
        long printlntime = System.currentTimeMillis();

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            sb.append( i + "\n" );
        }
        System.out.print(sb.toString());
        long stringbuildertime = System.currentTimeMillis();

        OutputStream out = new BufferedOutputStream ( System.out );
        for (int i = 0; i < 100000; i++) {
            out.write((i + "\n").getBytes());
        }
        out.flush();
        long bufferedoutputtime = System.currentTimeMillis();

        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
        for (int i = 0; i < 100000; i++) {
            log.write(i + "\n");
        }
        log.flush();
        long bufferedwritertime = System.currentTimeMillis();

        System.out.println( "System.out.println: " + (printlntime - starttime) );
        System.out.println( "StringBuilder: " + (stringbuildertime - printlntime) );
        System.out.println( "BufferedoutputStream: " + (bufferedoutputtime - stringbuildertime) );
        System.out.println( "BufferedWriter: " + (bufferedwritertime - bufferedoutputtime) );
    }

}

结果：

环境1
System.out.println：482
StringBuilder：210
BufferedoutputStream：86
BufferedWriter：202

环境2
System.out.println：1763
StringBuilder：45
BufferedoutputStream：76
BufferedWriter：34

所有建议都比System.out.println更好。 BufferedOutputStream似乎是最安全的选择，因为它在两个测试环境中都表现良好。 BufferedWriter可能会更快。

如果有人有任何想法，请发表进一步的建议。我相信有人可以让它变得更快：）

Answer 2

对于大量数据，System.out.println可能效率低下，但事实并非如此做很好的缓冲。在这种情况下，您可以使用BufferedOutputStream或BufferedWriter。

Answer 3

请记住，与内存处理（例如，解析Integer）相比，I / O操作非常慢。所以，我建议你“提前”创建整个字符串，然后只打印一次（当然，如果可能的话）：

StringBuilder sb = new StringBuilder();

for(int i = 0 ; i < 100000; i++) { sb.append(i).append("\n");}
String printMe = sb.toString(); 
System.out.println(printMe);

有各种技术可以缓冲您正在使用的输出流级别，但我认为您更喜欢使用最基本的System.out.println

希望这有帮助

Answer 4

这也包括快速输入和输出方法

import java.io.*;
public class templa{
    static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 

        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 

        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 

        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 

        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 

        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 

        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    } 

    public static void main(String...args) throws Exception {
        OutputStream outputStream =System.out;
        PrintWriter out =new PrintWriter(outputStream);
        FastReader in =new FastReader();
        int testcase = in.nextInt();
        while(testcase-- >0){
            //in object works same as Scanner Object but much faster
            //out.println() works faster than System.out.println()
            //Write your code here
        }
        out.close();
      }
}

Answer 5

写入System.out的最慢部分是显示您正在编写的内容所花费的时间。即，对于您编写的每一行，计算机必须使用字体将信息转换为像素并滚动整行。这比你在显示文本时可能做的任何工作要多得多。

您可以通过

加快写入控制台的速度

少写（通常是最好的主意）
改为写入文件（这可以快5-10倍）

将字符串输出到系统的最快方法是什么？

5 个答案: