मैं एक ही पंक्ति में कैसे प्रिंट कर सकता हूं?

Question

मैं बहुत की तरह एक प्रगति बार प्रिंट करना चाहते हैं:

[#     ] 1% 
[##     ] 10% 
[##########   ] 50% 

लेकिन इन सभी टर्मिनल के बजाय एक नया एक में एक ही लाइन के लिए मुद्रित किया जाना चाहिए। मेरा मतलब यह है कि प्रत्येक नई लाइन को पिछले स्थान को प्रतिस्थापित करना चाहिए, यह println() के बजाय print() का उपयोग करने के बारे में नहीं है।

मैं जावा में यह कैसे कर सकता हूं?

Answer 1

स्वरूप:

[#     ] 1%\r 

नोट \r चरित्र। यह तथाकथित कैरिज रिटर्न है जो कर्सर को लाइन की शुरुआत में वापस ले जायेगा।

अंत में, आप

System.out.print() 

और नहीं

System.out.println() 

Answer 2

आप अद्यतन प्रगति पट्टी को मुद्रित करने से पहले लाइन को हटाने के लिए जितनी बार आवश्यक हो सके बैकस्पेस वर्ण 'बी' प्रिंट कर सकते हैं। इसलिए की तरह अपने स्ट्रिंग

Answer 3

लिनक्स में उपयोग सुनिश्चित करें, वहाँ नियंत्रण टर्मिनल के लिए अलग से बच दृश्यों है। उदाहरण के लिए, पूरी लाइन मिटाने के लिए विशेष भागने का अनुक्रम है: \33[2K और कर्सर को पिछली पंक्ति में ले जाने के लिए: \33[1A। इसलिए जब भी आपको लाइन रीफ्रेश करने की आवश्यकता होती है तो आपको इसे प्रिंट करना होगा।

System.out.println("Line 1 (first variant)"); 
System.out.print("\33[1A\33[2K"); 
System.out.println("Line 1 (second variant)"); 

कर्सर नेविगेशन के लिए कोड, स्क्रीन समाशोधन रहे हैं और इतने पर: यहाँ कोड है जो Line 1 (second variant) प्रिंट है।

मुझे लगता है कि कुछ पुस्तकालय हैं जो इसके साथ मदद करते हैं (ncurses?)।

Answer 4

सबसे पहले, मैं इस प्रश्न को वापस लाने के लिए क्षमा चाहता हूं, लेकिन मुझे लगा कि यह एक और जवाब का उपयोग कर सकता है।

डेरेक शल्ट्ज सही प्रकार का है। '\ B' चरित्र प्रिंटिंग कर्सर को एक वर्ण पीछे ले जाता है, जिससे आप उस प्रिंटर को ओवरराइट कर सकते हैं जो वहां मुद्रित था (यह पूरी लाइन या यहां तक ​​कि उस चरित्र को तब तक नहीं हटाता जब तक आप शीर्ष पर नई जानकारी प्रिंट नहीं करते)। निम्नलिखित जावा का उपयोग कर प्रगति पट्टी का एक उदाहरण है, हालांकि यह आपके प्रारूप का पालन नहीं करता है, यह दिखाता है कि ओवरराइटिंग वर्णों की मूल समस्या को कैसे हल किया जाए (यह केवल 32-बिट मशीन पर ओरेकल के जावा 7 के साथ उबंटू 12.04 में परीक्षण किया गया है, लेकिन यह सब जावा सिस्टम पर काम होना चाहिए):

public class BackSpaceCharacterTest 
{ 
    // the exception comes from the use of accessing the main thread 
    public static void main(String[] args) throws InterruptedException 
    { 
     /* 
      Notice the user of print as opposed to println: 
      the '\b' char cannot go over the new line char. 
     */ 
     System.out.print("Start[   ]"); 
     System.out.flush(); // the flush method prints it to the screen 

     // 11 '\b' chars: 1 for the ']', the rest are for the spaces 
     System.out.print("\b\b\b\b\b\b\b\b\b\b\b"); 
     System.out.flush(); 
     Thread.sleep(500); // just to make it easy to see the changes 

     for(int i = 0; i < 10; i++) 
     { 
      System.out.print("."); //overwrites a space 
      System.out.flush(); 
      Thread.sleep(100); 
     } 

     System.out.print("] Done\n"); //overwrites the ']' + adds chars 
     System.out.flush(); 
    } 
} 

Answer 5

package org.surthi.tutorial.concurrency; 

public class IncrementalPrintingSystem { 
    public static void main(String...args) { 
     new Thread(()-> { 
      int i = 0; 
      while(i++ < 100) { 
       System.out.print("["); 
       int j=0; 
       while(j++<i){ 
        System.out.print("#"); 
       } 
       while(j++<100){ 
        System.out.print(" "); 
       } 
       System.out.print("] : "+ i+"%"); 
       try { 
        Thread.sleep(1000l); 
       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 
       System.out.print("\r"); 
      } 
     }).start(); 
    } 
}