सिस्टम को स्ट्रिंग आउटपुट करने का सबसे तेज़ तरीका क्या है?

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)); 
    } 

} 

परिणाम::

Environment1
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

ध्यान रखें कि 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 3

में मदद करता है डेटा की बड़ी राशि के लिए, System.out.println अक्षम हो सकता है क्योंकि यह बहुत अच्छा बफरिंग नहीं करता है। उस स्थिति में, आप BufferedOutputStream या BufferedWriter का उपयोग कर सकते हैं।

Answer 4

System.out पर लिखने का सबसे धीमा हिस्सा वह समय है जो आप लिख रहे हैं उसे प्रदर्शित करने के लिए लिया गया है। यानी आप जिस लाइन को लिखते हैं, उसके लिए कंप्यूटर को फ़ॉन्ट का उपयोग करके पिक्सेल में बदलना होगा और पूरी लाइन स्क्रॉल करना होगा। पाठ को प्रदर्शित करने के लिए आप जो भी कर रहे हैं उससे कहीं अधिक काम है।

आप

• कम (आमतौर पर सबसे अच्छा विचार) बजाय एक फ़ाइल के लिए लिख
• लिख कर सांत्वना के लिए लिख तेजी लाने के कर सकते हैं (यह 5-10x तेजी से किया जा सकता है)