Respostas:
Como existem várias respostas aqui mostrando o código que não funciona para Windows, aqui está um esclarecimento:
Runtime.getRuntime().exec("cls");
Este comando não funciona, por dois motivos:
Não há executável nomeado cls.exe
ou cls.com
em uma instalação padrão do Windows que possa ser chamada Runtime.exec
, pois o comando conhecido cls
é incorporado ao interpretador de linha de comando do Windows.
Ao iniciar um novo processo Runtime.exec
, a saída padrão é redirecionada para um canal que o processo Java inicial pode ler. Mas quando a saída do cls
comando é redirecionada, ela não limpa o console.
Para resolver esse problema, precisamos chamar o interpretador de linha de comando ( cmd
) e solicitar que ele execute um comando ( /c cls
) que permita chamar comandos internos. Além disso, temos que conectar diretamente seu canal de saída ao canal de saída do processo Java, que funciona a partir do 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();
}
}
Agora, quando o processo Java estiver conectado a um console, ou seja, foi iniciado a partir de uma linha de comandos sem redirecionamento de saída, ele limpará o console.
Você pode usar o seguinte código para limpar o console da linha de comandos:
public static void clearScreen() {
System.out.print("\033[H\033[2J");
System.out.flush();
}
Para mais referências, visite: http://techno-terminal.blogspot.in/2014/12/clear-command-line-console-and-bold.html
É assim que eu lidaria com isso. Esse método funcionará para os casos do sistema operacional Windows e Linux / Unix OS (o que significa que também funciona para o 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.
}
}
Observe que esse método geralmente não limpará o console se você estiver executando dentro de um IDE.
java.io.IOException: Cannot run program "cls": CreateProcess error=2, The system cannot find the file specified
cls
executável no Windows. É um comando interno de cmd.exe
.
Uma maneira de obter isso pode ser imprimir várias final de linhas ("\ n") e simular a tela limpa. No final, claro, no máximo no shell unix, não remove o conteúdo anterior, apenas o move para cima e, se você rolar para baixo, poderá ver o conteúdo anterior.
Aqui está um código de exemplo:
for (int i = 0; i < 50; ++i) System.out.println();
\r\n
com uma única println
, pois há um atraso perceptível entre as println
chamadas.
clear
é que, no último, a nova saída estará na parte superior da tela e não na parte inferior.
System.out.println(new String(new char[50]).replace("\0", "\r\n"));
fará o trabalho mais rápido e melhor.
System.out.println(System.lineSeparator().repeat(50));
Se você quiser uma maneira independente sistema mais de fazer isso, você pode usar o JLine biblioteca e ConsoleReader.clearScreen () . Provavelmente, também vale a pena verificar se JLine e ANSI são suportados no ambiente atual.
Algo como o seguinte código funcionou para mim:
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 + "'.");
}
}
}
Ao executar isso, se você digitar 'clear' no prompt, a tela será limpa. Certifique-se de executá-lo a partir de um terminal / console adequado e não no Eclipse.
Crie um método em sua classe como este: [como @Holger disse aqui .]
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) {}
}
Isso funciona para o Windows, pelo menos, eu não verifiquei o Linux até agora. Se alguém verificar o Linux, informe-me se funciona (ou não).
Como método alternativo é escrever este código em 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
Não vou recomendar que você use esse método.
Runtime.getRuntime (). Exec (cls) NÃO funcionou no meu laptop XP. Isso fez -
for(int clear = 0; clear < 1000; clear++)
{
System.out.println("\b") ;
}
Espero que isso seja útil
Tente o seguinte:
System.out.print("\033\143");
Isso funcionará bem no ambiente Linux
Isso funcionará se você estiver fazendo isso no Bluej ou em qualquer outro software similar.
System.out.print('\u000C');
Você precisa usar caracteres de controle como barra invertida (\ b) e retorno de carro (\ r). Ele é desativado por padrão, mas a exibição do console pode interpretar esses controles.
Windows> Preferências e Executar / Depurar> Console e selecione Interpretar caracteres de controle ASCII para ativá-lo
Após essas configurações, você pode gerenciar seu console com caracteres de controle como:
guia \ t.
\ b - backspace (um passo atrás no texto ou exclusão de um único caractere).
\ n - nova linha.
retorno de carro. ()
\ f - forma o feed.
Mais informações em: https://www.eclipse.org/eclipse/news/4.14/platform.php
Você precisa usar o JNI.
Primeiro de tudo, crie um .dll usando o visual studio, esse sistema de chamada ("cls"). Depois disso, use JNI para usar este DDL.
Eu encontrei este artigo que é bom:
http://www.planet-source-code.com/vb/scripts/ShowCode.asp?txtCodeId=5170&lngWId=2