Java: limpe o console

Alguém pode me dizer qual código é usado para limpar a tela em Java? Por exemplo em C ++

system("CLS");

Qual código é usado em Java para tela limpa?

Obrigado!

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:

1. Não há executável nomeado cls.exeou cls.comem 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.

2. 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 clscomando é 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.

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

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ê pode usar uma emulação de clscom for (int i = 0; i < 50; ++i) System.out.println();

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