Risposte:
Dato che ci sono diverse risposte che mostrano codice non funzionante per Windows, ecco un chiarimento:
Runtime.getRuntime().exec("cls");
Questo comando non funziona, per due motivi:
Non esiste un file eseguibile denominato cls.exe
o cls.com
in un'installazione standard di Windows che possa essere richiamato tramite Runtime.exec
, poiché il noto comando cls
è incorporato nell'interprete della riga di comando di Windows.
Quando si avvia un nuovo processo tramite Runtime.exec
, l'output standard viene reindirizzato a una pipe che può essere letta dal processo Java di avvio. Ma quando l'output del cls
comando viene reindirizzato, non cancella la console.
Per risolvere questo problema, dobbiamo invocare l'interprete della riga di comando ( cmd
) e dirgli di eseguire un comando ( /c cls
) che consente di richiamare i comandi integrati. Inoltre, dobbiamo collegare direttamente il suo canale di output al canale di output del processo Java, che funziona a partire da Java 7, usando inheritIO()
:
import java.io.IOException;
public class CLS {
public static void main(String... arg) throws IOException, InterruptedException {
new ProcessBuilder("cmd", "/c", "cls").inheritIO().start().waitFor();
}
}
Ora quando il processo Java è collegato a una console, ovvero è stato avviato da una riga di comando senza reindirizzamento dell'output, cancellerà la console.
È possibile utilizzare il seguente codice per cancellare la console della riga di comando:
public static void clearScreen() {
System.out.print("\033[H\033[2J");
System.out.flush();
}
Per ulteriori riferimenti visitare: http://techno-terminal.blogspot.in/2014/12/clear-command-line-console-and-bold.html
Ecco come lo gestirò. Questo metodo funzionerà per il caso del sistema operativo Windows e il caso del sistema operativo Linux / Unix (il che significa che funziona anche per Mac OS X).
public final static void clearConsole()
{
try
{
final String os = System.getProperty("os.name");
if (os.contains("Windows"))
{
Runtime.getRuntime().exec("cls");
}
else
{
Runtime.getRuntime().exec("clear");
}
}
catch (final Exception e)
{
// Handle any exceptions.
}
}
Si noti che questo metodo generalmente non cancella la console se si esegue all'interno di un IDE.
java.io.IOException: Cannot run program "cls": CreateProcess error=2, The system cannot find the file specified
cls
eseguibile in Windows. È un comando interno di cmd.exe
.
Un modo per ottenere ciò può essere la stampa di più righe ("\ n") e simulare lo schermo chiaro. Alla fine cancella, al massimo nella shell unix, non rimuove il contenuto precedente, lo sposta solo verso l'alto e se fai scorrere verso il basso puoi vedere il contenuto precedente.
Ecco un codice di esempio:
for (int i = 0; i < 50; ++i) System.out.println();
\r\n
con una singola println
, poiché si verifica un notevole ritardo tra le println
chiamate.
clear
è che in quest'ultimo, il nuovo output sarà nella parte superiore dello schermo e non nella parte inferiore.
System.out.println(new String(new char[50]).replace("\0", "\r\n"));
farà il lavoro più velocemente e meglio.
System.out.println(System.lineSeparator().repeat(50));
Se si vuole un sistema modo più indipendente di fare questo, è possibile utilizzare la JLine biblioteca e ConsoleReader.clearScreen () . Vale la pena fare anche un controllo prudente sul fatto che JLine e ANSI siano supportati nell'ambiente attuale.
Qualcosa come il seguente codice ha funzionato per me:
import jline.console.ConsoleReader;
public class JLineTest
{
public static void main(String... args)
throws Exception
{
ConsoleReader r = new ConsoleReader();
while (true)
{
r.println("Good morning");
r.flush();
String input = r.readLine("prompt>");
if ("clear".equals(input))
r.clearScreen();
else if ("exit".equals(input))
return;
else
System.out.println("You typed '" + input + "'.");
}
}
}
Durante l'esecuzione, se si digita 'cancella' al prompt si cancella lo schermo. Assicurati di eseguirlo da un terminale / console adeguato e non in Eclipse.
Crea un metodo nella tua classe come questo: [come ha detto @Holger qui .]
public static void clrscr(){
//Clears Screen in java
try {
if (System.getProperty("os.name").contains("Windows"))
new ProcessBuilder("cmd", "/c", "cls").inheritIO().start().waitFor();
else
Runtime.getRuntime().exec("clear");
} catch (IOException | InterruptedException ex) {}
}
Questo funziona almeno per Windows, non ho ancora verificato Linux. Se qualcuno lo controlla per Linux, per favore fatemi sapere se funziona (o no).
Come metodo alternativo è scrivere questo codice in clrscr()
:
for(int i = 0; i < 80*300; i++) // Default Height of cmd is 300 and Default width is 80
System.out.print("\b"); // Prints a backspace
Non ti consiglierò di usare questo metodo.
Runtime.getRuntime (). Exec (cls) NON ha funzionato sul mio laptop XP. Questo ha fatto -
for(int clear = 0; clear < 1000; clear++)
{
System.out.println("\b") ;
}
Spero sia utile
Prova quanto segue:
System.out.print("\033\143");
Funzionerà perfettamente in ambiente Linux
Questo funzionerà se lo stai facendo in Bluej o altri software simili.
System.out.print('\u000C');
È necessario utilizzare i caratteri di controllo come barra rovesciata (\ b) e ritorno a capo (\ r). Viene disabilitato per impostazione predefinita, ma la vista Console può interpretare questi controlli.
Windows> Preferenze ed Esegui / Debug> Console e selezionare Interpreta caratteri di controllo ASCII per abilitarlo
Dopo queste configurazioni, puoi gestire la tua console con caratteri di controllo come:
\ t - tab.
\ b - backspace (un passo indietro nel testo o la cancellazione di un singolo carattere).
\ n - nuova riga.
\ r - ritorno a capo. ()
\ f - feed modulo.
Maggiori informazioni su: https://www.eclipse.org/eclipse/news/4.14/platform.php
Devi usare JNI.
Prima di tutto usa creare un .dll usando Visual Studio, che chiama system ("cls"). Successivamente utilizzare JNI per utilizzare questo DDL.
Ho trovato questo articolo bello:
http://www.planet-source-code.com/vb/scripts/ShowCode.asp?txtCodeId=5170&lngWId=2