wake-up-neo.com

Wie färben Sie die Ausgabe von System.out.println ein?

Wie kann ich Java-Ausgaben farbig gestalten? 

In C und anderen Sprachen kann ich beispielsweise ANSI-Escape wie \033[0m verwenden. Aber in Java funktioniert es nicht.

public static void main(String[] x) {
    System.out.println("\033[0m BLABLA \033[0m\n");
}
112
Davide Aversa

Nein, aber es gibt APIs von Drittanbietern, die damit umgehen können

http://www.javaworld.com/javaworld/javaqa/2002-12/02-qa-1220-console.html

Edit: Natürlich gibt es neuere Artikel als die, die ich gepostet habe, die Informationen sind jedoch immer noch machbar.

26
Jonas B

Hinweis

Möglicherweise können Sie den cmd Prompt von Window nicht einfärben, er sollte jedoch in vielen Unix-Terminals (oder unixähnlichen Terminals) funktionieren.

Beachten Sie auch, dass einige Terminals einige (falls vorhanden) ANSI-Escape-Sequenzen und insbesondere 24-Bit-Farben einfach nicht unterstützen.

Verwendungszweck

Die beste Lösung finden Sie im Abschnitt Flüche unten. Eine persönliche oder einfache Lösung (obwohl nicht als plattformübergreifende Lösung) finden Sie in Abschnitt ANSI-Escape-Sequenzen .


TL; DR

  • Java : System.out.println((char)27 + "[31m" + "ERROR MESSAGE IN RED");

  • Python : print(chr(27) + "[31m" + "ERROR MESSAGE IN RED")

  • bash oder zsh : printf '\x1b[31mERROR MESSAGE IN RED'
    • dies kann auch für Os X funktionieren: printf '\e[31mERROR MESSAGE IN RED'
  • sh : printf 'CTRL+V,CTRL+[[31mERROR MESSAGE IN RED'
    • dh, drücke STRG + V und dann STRG + [, um ein "raw" zu erhalten ESC Zeichen, wenn keine Escape-Interpretation verfügbar ist
    • Bei korrekter Ausführung sollte ein ^[ angezeigt werden. Obwohl es wie zwei Charaktere aussieht, ist es wirklich nur eines, das ESC Charakter.
    • Sie können auch drücken CTRL+V,CTRL+[ in vim in einer der Programmier- oder Skriptsprachen, da hierfür ein Literal verwendet wird ESC Charakter
    • Auch können Sie ersetzen Ctrl+[ mit ESC ... können Sie zB verwenden CTRL+V,ESC, aber ich finde erstere einfacher, da ich schon drücke CTRL und seit [ ist weniger aus dem Weg.

ANSI-Escape-Sequenzen

Hintergrund zu Escape-Sequenzen

Dies ist zwar nicht die beste Methode, aber die einfachste Methode in einer Programmier- oder Skriptsprache ist die Verwendung von Escape-Sequenzen. Von diesem Link:

Eine Escape-Sequenz besteht aus einer Reihe von Zeichen, mit denen der Status von Computern und den angeschlossenen Peripheriegeräten geändert wird. Diese werden auch als Steuersequenzen bezeichnet und spiegeln deren Verwendung bei der Gerätesteuerung wider.

Hintergrundinformationen zu ANSI-Escape-Sequenzen

In Videotextterminals wird es jedoch noch einfacher, da diese Terminals ANSI-Escape-Sequenzen verwenden. Von diesem Link:

ANSI-Escape-Sequenzen sind ein Standard für In-Band-Signale zur Steuerung von Cursorposition, Farbe und anderen Optionen auf Videotext-Terminals. Bestimmte Bytefolgen, die meist mit Esc und '[' beginnen, sind in den Text eingebettet, den das Terminal sucht und als Befehle und nicht als Zeichencodes interpretiert.

Verwendung von ANSI-Escape-Sequenzen

Allgemein

  • Escape-Sequenzen beginnen mit einem Escape-Zeichen. Bei ANSI-Escape-Sequenzen beginnt die Sequenz immer mit ESC (ASCII: 27/hex: 0x1B).
  • Eine Liste der möglichen Aktionen finden Sie in ANSI-Escape-Sequenzliste auf Wikipedia

In Programmiersprachen

Einige Programmiersprachen (wie Java) interpretieren \e oder \x1b nicht als ESC Charakter. Wir wissen jedoch, dass das Zeichen ASCII 27 das Zeichen ist ESC Wir können also einfach 27 in char tippen und damit die Escape-Sequenz beginnen.

Hier sind einige Möglichkeiten, dies in gängigen Programmiersprachen zu tun:

  • Java

    • System.out.println((char)27 + "[33mYELLOW");
  • Python 3

    • print(chr(27) + "[34mBLUE");
    • print("\x1b[35mMAGENTA");
      • Beachten Sie, dass \x1b in Python korrekt interpretiert wird
  • Knoten JS

    • Im Folgenden wird NICHT in JavaScript in der Webkonsole farbig ausgegeben
    • console.log(String.fromCharCode(27) + "[36mCYAN");
    • console.log("\x1b[30;47mBLACK_ON_WHITE");
      • Beachten Sie, dass \x1b auch im Knoten funktioniert

In Shell Prompt OR Skripten

Wenn Sie mit bash oder zsh arbeiten, ist es recht einfach, die Ausgabe einzufärben (in den meisten Terminals). Unter Linux, Os X und in einigen Windows-Terminals können Sie überprüfen, ob Ihr Terminal Farbe unterstützt, indem Sie beide der folgenden Schritte ausführen:

  • printf '\e[31mRED'
  • printf '\x1b[31mRED'

Wenn Sie für beide Farben sehen, ist das großartig! Wenn Sie nur für eine Farbe sehen, verwenden Sie diese Sequenz. Wenn Sie für keine der beiden Farben eine Anzeige sehen, überprüfen Sie noch einmal, ob Sie alles richtig eingegeben haben und ob Sie in bash oder zsh sind. Wenn Sie immer noch keine Farbe sehen, unterstützt Ihr Terminal möglicherweise keine ANSI-Escape-Sequenzen.

Wenn ich mich richtig erinnere, unterstützen Linux-Terminals in der Regel sowohl \e- als auch \x1b-Escape-Sequenzen, während os x-Terminals nur \e unterstützen, aber ich kann mich irren. Dennoch, wenn Sie so etwas wie das folgende Bild sehen, dann sind Sie fertig! (Beachten Sie, dass ich die Shell zsh verwende und sie meine Eingabeaufforderungszeichenfolge einfärbt. Außerdem verwende ich urxvt als mein terminal unter linux.)

ANSI Escape Sequences Coloring Text Red

"Wie funktioniert das?" könnten Sie fragen. Grundsätzlich interpretiert printf die folgende Zeichenfolge (alles innerhalb der einfachen Anführungszeichen ). Wenn printf auf \e oder \x1b trifft, werden diese Zeichen in die konvertiert ESC Zeichen (ASCII: 27). Genau das wollen wir. Jetzt sendet printf ESC31m, und da gibt es eine ESC gefolgt von einer gültigen ANSI-Escape-Sequenz sollten wir eine farbige Ausgabe erhalten (sofern dies vom Terminal unterstützt wird).

Sie können zum Beispiel auch echo -e '\e[32mGREEN' verwenden, um die Ausgabe einzufärben. Beachten Sie, dass das -e-Flag für echo "[ermöglicht] die Interpretation von Backslash-Escapes" und verwendet werden muss, wenn echo die Escape-Sequenz entsprechend interpretieren soll.


Weitere Informationen zu ANSI-Escape-Sequenzen

ANSI-Escape-Sequenzen können mehr als nur die Farbausgabe. Beginnen wir damit und sehen, wie Farben genau funktionieren. dann werden wir sehen, wie man den Cursor manipuliert; Zum Schluss schauen wir uns an, wie man 8-Bit-Farben und auch 24-Bit-Farben verwendet (obwohl es nur eine schwache Unterstützung gibt).

Am Wikipedia verweisen sie auf ESC[ als CSI werde ich das gleiche tun.

Farbe

Verwenden Sie Folgendes, um die Ausgabe mit ANSI-Escape-Zeichen zu färben:

  • CSInm
    • CSI: Escape-Zeichen —^[[ oder ESC[
    • n: eine Nummer - eine der folgenden:
      • 30-37, 39: Vordergrund
      • 40-47, 49: Hintergrund
    • m: Ein Literal ASCII m - beendet die Escape-Sequenz

Ich werde bash oder zsh verwenden, um alle möglichen Farbkombinationen zu demonstrieren. Plop Folgendes in bash oder zsh, um es selbst zu sehen (Sie müssen möglicherweise \e durch \x1b ersetzen):

  • for fg in {30..37} 39; do for bg in {40..47} 49; do printf "\e[${fg};${bg}m~TEST~"; done; printf "\n"; done;

Ergebnis:

various foreground/background colors using ANSI escapes

Kurzanleitung (Farbe)

+~~~~~~+~~~~~~+~~~~~~~~~~~+
|  fg  |  bg  |  color    |
+~~~~~~+~~~~~~+~~~~~~~~~~~+
|  30  |  40  |  black    |
|  31  |  41  |  red      |
|  32  |  42  |  green    |
|  33  |  43  |  yellow   |
|  34  |  44  |  blue     |
|  35  |  45  |  Magenta  |
|  36  |  46  |  cyan     |
|  37  |  47  |  white    |
|  39  |  49  |  default  |
+~~~~~~+~~~~~~+~~~~~~~~~~~+

Grafikwiedergabe auswählen (SGR)

Mit SGR können Sie nur den Text ändern. Viele davon funktionieren nicht in bestimmten Terminals. Verwenden Sie sie daher sparsam in Projekten auf Produktionsebene. Sie können jedoch hilfreich sein, um die Programmausgabe besser lesbar zu machen oder um zwischen verschiedenen Arten von Ausgaben zu unterscheiden.

Die Farbe fällt tatsächlich unter SGR, daher ist die Syntax dieselbe:

  • CSInm
    • CSI: Escape-Zeichen —^[[ oder ESC[
    • n: eine Nummer - eine der folgenden:
      • 0: Zurücksetzen
      • 1-9: Aktiviert verschiedene Texteffekte
      • 21-29: Deaktiviert verschiedene Texteffekte (weniger unterstützt als 1-9)
      • 30-37, 39: Vordergrundfarbe
      • 40-47, 49: Hintergrundfarbe
      • 38: 8- oder 24-Bit-Vordergrundfarbe (siehe 8/24-Bit-Farbe unten)
      • 48: 8- oder 24-Bit-Hintergrundfarbe (siehe 8/24-Bit-Farbe unten)
    • m: Ein Literal ASCII m - beendet die Escape-Sequenz

Obwohl es nur eine schwache Unterstützung für schwache (2), kursive (3), unterstrichene (4), blinkende (5,6), invertierte (7), verdeckte (8) und durchgestrichene (9) gibt (aber einige) selten arbeiten alle auf linux- und os x-terminals.

Es ist auch erwähnenswert, dass Sie jedes der oben genannten Attribute mit einem Semikolon trennen können. Zum Beispiel zeigt printf '\e[34;47;1;3mCRAZY TEXT\n'CRAZY TEXT mit einem blue foreground auf einem white background an und ist bold und italic.

Z.B:

string attributes together example screenshot

Ploppe das Folgende in deine Bash- oder Zsh-Shell, um alle Texteffekte zu sehen, die du machen kannst. (Möglicherweise müssen Sie \e durch \x1b ersetzen.)

  • for i in {1..9}; do printf "\e[${i}m~TEST~\e[0m "; done

Ergebnis:

SGR state 1SGR state 2

Sie können sehen, dass mein Terminal alle Texteffekte unterstützt, mit Ausnahme von für schwache (2), verbergen (8) und streichen (9).

Kurzreferenz (SGR-Attribute 0-9)

+~~~~~+~~~~~~~~~~~~~~~~~~+
|  n  |  effect          |
+~~~~~+~~~~~~~~~~~~~~~~~~+
|  0  |  reset           |
|  1  |  bold            |
|  2  |  faint*          |
|  3  |  italic**        |
|  4  |  underline       |
|  5  |  slow blink      |
|  6  |  rapid blink*    |
|  7  |  inverse         |
|  8  |  conceal*        |
|  9  |  strikethrough*  |
+~~~~~+~~~~~~~~~~~~~~~~~~+

* not widely supported
** not widely supported and sometimes treated as inverse

8-Bit-Farbe

Während die meisten Terminals dies unterstützen, wird dies weniger unterstützt als die Farben 0-7, 9.

Syntax:

  • CSI38;5;nm
    • CSI: Escape-Zeichen —^[[ oder ESC[
    • 38;5;: Literalzeichenfolge, die die Verwendung von 8-Bit-Farben für den Vordergrund angibt
    • n: eine Nummer - eine der folgenden:
      • 0-255

Wenn Sie eine Vorschau aller Farben in Ihrem Terminal in einer netten Art und Weise anzeigen möchten, habe ich ein nettes Skript auf Gist.github.com .

Es sieht aus wie das:

8-bit color example screenshot

Wenn Sie den Hintergrund mit 8-Bit-Farben ändern möchten, ersetzen Sie einfach den 38 durch einen 48:

  • CSI48;5;nm
    • CSI: Escape-Zeichen —^[[ oder ESC[
    • 48;5;: Literalzeichenfolge, die die Verwendung von 8-Bit-Farben für den Hintergrund angibt
    • n: eine Nummer - eine der folgenden:
      • 0-255

24-Bit-Farbe

Die 24-Bit-Farbe, auch True Color genannt, bietet einige wirklich coole Funktionen. Die Unterstützung dafür wächst definitiv (soweit ich weiß, funktioniert es in den meisten modernen Terminals, mit Ausnahme von urxvt , meinem Terminal [wütendes Emoji einfügen]).

24-Bit-Farben werden in vim tatsächlich unterstützt (siehe vim wiki , um zu sehen, wie 24-Bit-Farben aktiviert werden). Es ist wirklich ordentlich, weil es aus dem für gvim definierten Farbschema stammt. ZB verwendet es das fg/bg von highlight guibg=#______ guifg=#______ für die 24-Bit-Farben! Neato, was?

So funktioniert 24-Bit-Farbe:

  • CSI38;2;r;g;bm
    • CSI: Escape-Zeichen —^[[ oder ESC[
    • 38;2;: Literalzeichenfolge, die die Verwendung von 24-Bit-Farben für den Vordergrund angibt
    • r, g, b: Zahlen - jede sollte 0-255 sein

Um nur einige der vielen Farben zu testen, die Sie haben können ((2^8)^3 oder 2^24 oder 16777216 Möglichkeiten, denke ich), können Sie dies in bash oder zsh verwenden:

  • for r in 0 127 255; do for g in 0 127 255; do for b in 0 127 255; do printf "\e[38;2;${r};${g};${b}m($r,$g,$b)\e[0m "; done; printf "\n"; done; done;

Ergebnis (dies ist in gnome-terminal , da urxvt 24-Bit-Farbe NICHT UNTERSTÜTZT ... fasse es zusammen, urxvt Betreuer ... für echt):

24-bit color example screenshot

Wenn Sie 24-Bit-Farben für den Hintergrund möchten, haben Sie es erraten! Sie ersetzen einfach 38 durch 48:

  • CSI48;2;r;g;bm
    • CSI: Escape-Zeichen —^[[ oder ESC[
    • 48;2;: Literalzeichenfolge, die die Verwendung von 24-Bit-Farben für den Hintergrund angibt
    • r, g, b: Zahlen - jede sollte 0-255 sein

Einfügen von Raw-Escape-Sequenzen

Manchmal funktionieren \e und \x1b nicht. Zum Beispiel funktioniert in der sh Shell manchmal keines (obwohl es auf meinem System jetzt funktioniert , Ich glaube nicht, dass es früher so war.

Um dies zu umgehen, können Sie verwenden CTRL+V,CTRL+[ oder CTRLV,ESC

Dies wird ein "raw" einfügen ESC Zeichen (ASCII: 27). Es wird so aussehen ^[, aber nicht ärgern; Es ist nur ein Zeichen - nicht zwei.

Z.B:

sh raw escape char example screenshot


Flüche

Eine vollständige Referenz zu Flüchen finden Sie auf der Seite Curses (Programming Library) . Es sollte beachtet werden, dass Curses nur unter Unix und Unix-ähnlichen Betriebssystemen funktioniert.

Mit Flüchen loslegen

Ich werde nicht zu sehr ins Detail gehen, denn Suchmaschinen können Links zu Websites anzeigen, die dies viel besser erklären als ich, aber ich werde es hier kurz diskutieren und ein Beispiel geben.

Warum Flüche über ANSI-Escapes verwenden?

Wenn Sie den obigen Text lesen, können Sie sich daran erinnern, dass \e oder \x1b manchmal mit printf funktionieren. Nun, manchmal funktionieren \e und \x1b überhaupt nicht (dies ist kein Standard und ich habe noch nie mit einem Terminal wie diesem gearbeitet, aber es ist möglich). Noch wichtiger sind komplexere Escape - Sequenzen (think Home und andere Tasten mit mehreren Zeichen) sind für jedes Terminal nur schwer zu unterstützen (es sei denn, Sie sind bereit, viel Zeit und Mühe mit dem Parsen von terminfo und termcap zu verbringen und herauszufinden, wie mit jedem Terminal umzugehen ist).

Flüche lösen dieses Problem. Grundsätzlich ist es möglich zu verstehen, über welche Funktionen ein Terminal verfügt, wenn folgende Methoden verwendet werden (wie im oben verlinkten Wikipedia-Artikel beschrieben):

Die meisten Implementierungen von Curses verwenden eine Datenbank, die die Funktionen Tausender verschiedener Terminals beschreiben kann. Es gibt einige Implementierungen, wie z. B. PDCurses, die spezialisierte Gerätetreiber anstelle einer Terminaldatenbank verwenden. Die meisten Implementierungen verwenden terminfo. Einige verwenden termcap. Curses bietet den Vorteil der Back-Portabilität für Character-Cell-Terminals und der Einfachheit. Für eine Anwendung, für die keine Bitmap-Grafiken oder mehrere Schriftarten erforderlich sind, ist eine Schnittstellenimplementierung mit Flüchen in der Regel viel einfacher und schneller als eine mit einem X-Toolkit.

In den meisten Fällen rufen Curses terminfo ab und können dann die Cursor- und Textattribute bearbeiten. Anschließend verwenden Sie als Programmierer die von curses bereitgestellte API, um den Cursor zu manipulieren oder die Textfarbe oder andere Attribute zu ändern, wenn die gewünschte Funktionalität gewünscht wird.

Beispiel mit Python

Ich finde, Python ist wirklich einfach zu bedienen, aber wenn Sie Flüche in einer anderen Programmiersprache verwenden möchten, suchen Sie es einfach auf duckduckgo oder einer anderen Suchmaschine. :) Hier ist ein kurzes Beispiel in Python 3:

import curses

def main(stdscr):
    # allow curses to use default foreground/background (39/49)
    curses.use_default_colors()

    # Clear screen
    stdscr.clear()

    curses.init_pair(1, curses.COLOR_RED, -1)
    curses.init_pair(2, curses.COLOR_GREEN, -1)
    stdscr.addstr("ERROR: I like tacos, but I don't have any.\n", curses.color_pair(1))
    stdscr.addstr("SUCCESS: I found some tacos.\n", curses.color_pair(2))

    stdscr.refresh() # make sure screen is refreshed
    stdscr.getkey()  # wait for user to press key

if __== '__main__':
    curses.wrapper(main)

ergebnis:

enter image description here

Sie mögen sich denken, dass dies eine viel rundere Art ist, Dinge zu tun, aber es ist wirklich viel plattformübergreifender (wirklich terminalübergreifend… zumindest in der Welt der Unix- und Unix-ähnlichen Plattformen). Für Farben ist es nicht ganz so wichtig , aber wenn es darum geht, andere Escape-Sequenzen mit mehreren Sequenzen zu unterstützen (z. B. HomeEndPage UpPage Down, etc), dann werden Flüche umso wichtiger.

Beispiel mit Tput

  • tput ist ein Befehlszeilenprogramm zum Bearbeiten von Cursor und Text
  • tput wird mit dem Paket curses geliefert. Wenn Sie terminalübergreifende (ish) Anwendungen im Terminal verwenden möchten, sollten Sie tput verwenden, da es terminfo oder was auch immer analysiert und eine Reihe standardisierter Befehle (wie curses) verwendet und die richtige Escape-Sequenz zurückgibt.
  • beispiel:
echo "$(tput setaf 1)$(tput bold)ERROR:$(tput sgr0)$(tput setaf 1) My tacos have gone missing"
echo "$(tput setaf 2)$(tput bold)SUCCESS:$(tput sgr0)$(tput setaf 2) Oh good\! I found my tacos\!"

Ergebnis:

example with tput

Weitere Informationen zu Tput

104
dylnmc

Das hat für mich funktioniert:

System.out.println((char)27 + "[31mThis text would show up red" + (char)27 + "[0m");

Sie benötigen die Endung "[37m", um die Farbe auf Weiß zurückzusetzen (oder was auch immer Sie verwendet haben). Wenn Sie dies nicht tun, kann alles, was folgt, "rot" sein.

31
DanP

Sie können die Bibliothek JANSI verwenden, um ANSI-Escape-Sequenzen in Windows zu rendern. 

11
MrDrews

Ja, es ist 100% möglich 

set classpath =% classpath%; d:\jansi-1.4.jar;

Probieren Sie den folgenden Code aus:

import org.fusesource.jansi.AnsiConsole;
import static org.fusesource.jansi.Ansi.*;
import static org.fusesource.jansi.Ansi.Color.*;

public class Sample

{

  public static void main(String[] args)
  {
    AnsiConsole.systemInstall();

    System.out.println(ansi().fg(RED).a("Hello World").reset());
    System.out.println("My Name is Raman");

    AnsiConsole.systemUninstall();
  }
}
10
Raman

Hier ist eine Lösung für die Win32-Konsole.

1) Holen Sie sich JavaNativeAccess-Bibliotheken hier: https://github.com/twall/jna/

2) Diese beiden Java-Klassen werden den Trick ausführen.

Genießen.

package com.stackoverflow.util;

import com.Sun.jna.Library;
import com.Sun.jna.Native;
import com.Sun.jna.Platform;
import com.Sun.jna.Structure;

public class Win32 {
    public static final int STD_INPUT_HANDLE = -10;
    public static final int STD_OUTPUT_HANDLE = -11;
    public static final int STD_ERROR_HANDLE = -12;

    public static final short CONSOLE_FOREGROUND_COLOR_BLACK        = 0x00;
    public static final short CONSOLE_FOREGROUND_COLOR_BLUE         = 0x01;
    public static final short CONSOLE_FOREGROUND_COLOR_GREEN        = 0x02;
    public static final short CONSOLE_FOREGROUND_COLOR_AQUA         = 0x03;
    public static final short CONSOLE_FOREGROUND_COLOR_RED          = 0x04;
    public static final short CONSOLE_FOREGROUND_COLOR_PURPLE       = 0x05;
    public static final short CONSOLE_FOREGROUND_COLOR_YELLOW       = 0x06;
    public static final short CONSOLE_FOREGROUND_COLOR_WHITE        = 0x07;
    public static final short CONSOLE_FOREGROUND_COLOR_GRAY         = 0x08;
    public static final short CONSOLE_FOREGROUND_COLOR_LIGHT_BLUE   = 0x09;
    public static final short CONSOLE_FOREGROUND_COLOR_LIGHT_GREEN  = 0x0A;
    public static final short CONSOLE_FOREGROUND_COLOR_LIGHT_AQUA   = 0x0B;
    public static final short CONSOLE_FOREGROUND_COLOR_LIGHT_RED    = 0x0C;
    public static final short CONSOLE_FOREGROUND_COLOR_LIGHT_PURPLE = 0x0D;
    public static final short CONSOLE_FOREGROUND_COLOR_LIGHT_YELLOW = 0x0E;
    public static final short CONSOLE_FOREGROUND_COLOR_BRIGHT_WHITE = 0x0F;

    public static final short CONSOLE_BACKGROUND_COLOR_BLACK        = 0x00;
    public static final short CONSOLE_BACKGROUND_COLOR_BLUE         = 0x10;
    public static final short CONSOLE_BACKGROUND_COLOR_GREEN        = 0x20;
    public static final short CONSOLE_BACKGROUND_COLOR_AQUA         = 0x30;
    public static final short CONSOLE_BACKGROUND_COLOR_RED          = 0x40;
    public static final short CONSOLE_BACKGROUND_COLOR_PURPLE       = 0x50;
    public static final short CONSOLE_BACKGROUND_COLOR_YELLOW       = 0x60;
    public static final short CONSOLE_BACKGROUND_COLOR_WHITE        = 0x70;
    public static final short CONSOLE_BACKGROUND_COLOR_GRAY         = 0x80;
    public static final short CONSOLE_BACKGROUND_COLOR_LIGHT_BLUE   = 0x90;
    public static final short CONSOLE_BACKGROUND_COLOR_LIGHT_GREEN  = 0xA0;
    public static final short CONSOLE_BACKGROUND_COLOR_LIGHT_AQUA   = 0xB0;
    public static final short CONSOLE_BACKGROUND_COLOR_LIGHT_RED    = 0xC0;
    public static final short CONSOLE_BACKGROUND_COLOR_LIGHT_PURPLE = 0xD0;
    public static final short CONSOLE_BACKGROUND_COLOR_LIGHT_YELLOW = 0xE0;
    public static final short CONSOLE_BACKGROUND_COLOR_BRIGHT_WHITE = 0xF0;

    // typedef struct _COORD {
    //    SHORT X;
    //    SHORT Y;
    //  } COORD, *PCOORD;
    public static class COORD extends Structure {
        public short X;
        public short Y;
    }

    // typedef struct _SMALL_RECT {
    //    SHORT Left;
    //    SHORT Top;
    //    SHORT Right;
    //    SHORT Bottom;
    //  } SMALL_RECT;
    public static class SMALL_RECT extends Structure {
        public short Left;
        public short Top;
        public short Right;
        public short Bottom;
    }

    // typedef struct _CONSOLE_SCREEN_BUFFER_INFO {
    //    COORD      dwSize;
    //    COORD      dwCursorPosition;
    //    Word       wAttributes;
    //    SMALL_RECT srWindow;
    //    COORD      dwMaximumWindowSize;
    //  } CONSOLE_SCREEN_BUFFER_INFO;
    public static class CONSOLE_SCREEN_BUFFER_INFO extends Structure {
        public COORD dwSize;
        public COORD dwCursorPosition;
        public short wAttributes;
        public SMALL_RECT srWindow;
        public COORD dwMaximumWindowSize;
    }

    // Source: https://github.com/twall/jna/nonav/javadoc/index.html
    public interface Kernel32 extends Library {
        Kernel32 DLL = (Kernel32) Native.loadLibrary("kernel32", Kernel32.class);

        // HANDLE WINAPI GetStdHandle(
        //        __in  DWORD nStdHandle
        //      );
        public int GetStdHandle(
                int nStdHandle);

        // BOOL WINAPI SetConsoleTextAttribute(
        //        __in  HANDLE hConsoleOutput,
        //        __in  Word wAttributes
        //      );
        public boolean SetConsoleTextAttribute(
                int in_hConsoleOutput, 
                short in_wAttributes);

        // BOOL WINAPI GetConsoleScreenBufferInfo(
        //        __in   HANDLE hConsoleOutput,
        //        __out  PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
        //      );
        public boolean GetConsoleScreenBufferInfo(
                int in_hConsoleOutput,
                CONSOLE_SCREEN_BUFFER_INFO out_lpConsoleScreenBufferInfo);

        // DWORD WINAPI GetLastError(void);
        public int GetLastError();
    }
}
package com.stackoverflow.util;

import Java.io.PrintStream;

import com.stackoverflow.util.Win32.Kernel32;

public class ConsoleUtil {
    public static void main(String[] args)
    throws Exception {
        System.out.print("abc");
        static_color_print(
                System.out, 
                "def", 
                Win32.CONSOLE_BACKGROUND_COLOR_RED, 
                Win32.CONSOLE_FOREGROUND_COLOR_BRIGHT_WHITE);
        System.out.print("def");
        System.out.println();
    }

    private static Win32.CONSOLE_SCREEN_BUFFER_INFO _static_console_screen_buffer_info = null; 

    public static void static_save_settings() {
        if (null == _static_console_screen_buffer_info) {
            _static_console_screen_buffer_info = new Win32.CONSOLE_SCREEN_BUFFER_INFO();
        }
        int stdout_handle = Kernel32.DLL.GetStdHandle(Win32.STD_OUTPUT_HANDLE);
        Kernel32.DLL.GetConsoleScreenBufferInfo(stdout_handle, _static_console_screen_buffer_info);
    }

    public static void static_restore_color()
    throws Exception {
        if (null == _static_console_screen_buffer_info) {
            throw new Exception("Internal error: Must save settings before restore");
        }
        int stdout_handle = Kernel32.DLL.GetStdHandle(Win32.STD_OUTPUT_HANDLE);
        Kernel32.DLL.SetConsoleTextAttribute(
                stdout_handle, 
                _static_console_screen_buffer_info.wAttributes);
    }

    public static void static_set_color(Short background_color, Short foreground_color) {
        int stdout_handle = Kernel32.DLL.GetStdHandle(Win32.STD_OUTPUT_HANDLE);
        if (null == background_color || null == foreground_color) {
            Win32.CONSOLE_SCREEN_BUFFER_INFO console_screen_buffer_info = 
                new Win32.CONSOLE_SCREEN_BUFFER_INFO();
            Kernel32.DLL.GetConsoleScreenBufferInfo(stdout_handle, console_screen_buffer_info);
            short current_bg_and_fg_color = console_screen_buffer_info.wAttributes;
            if (null == background_color) {
                short current_bg_color = (short) (current_bg_and_fg_color / 0x10);
                background_color = new Short(current_bg_color);
            }
            if (null == foreground_color) {
                short current_fg_color = (short) (current_bg_and_fg_color % 0x10);
                foreground_color = new Short(current_fg_color);
            }
        }
        short bg_and_fg_color = 
            (short) (background_color.shortValue() | foreground_color.shortValue());
        Kernel32.DLL.SetConsoleTextAttribute(stdout_handle, bg_and_fg_color);
    }

    public static<T> void static_color_print(
            PrintStream ostream, 
            T value, 
            Short background_color, 
            Short foreground_color)
    throws Exception {
        static_save_settings();
        try {
            static_set_color(background_color, foreground_color);
            ostream.print(value);
        }
        finally {
            static_restore_color();
        }
    }

    public static<T> void static_color_println(
            PrintStream ostream, 
            T value, 
            Short background_color, 
            Short foreground_color)
    throws Exception {
        static_save_settings();
        try {
            static_set_color(background_color, foreground_color);
            ostream.println(value);
        }
        finally {
            static_restore_color();
        }
    }
}
5
kevinarpe

Ich habe eine jar-Bibliothek mit dem Namen JCDP (Java Colored Debug Printer) erstellt.

Für Linux werden die ANSI-Escape-Codes verwendet, die WhiteFang erwähnt hat. Sie werden jedoch mithilfe von Wörtern anstelle von Codes abstrahiert.

Für Windows enthält es zwar die JAnsi-Bibliothek, erstellt jedoch eine Abstraktionsebene und behält die intuitive und einfache Benutzeroberfläche bei, die für Linux erstellt wurde.

Diese Bibliothek ist unter der MIT Lizenz lizenziert. Sie können sie also gerne verwenden.

Schauen Sie sich das Github-Repository von JCDP an.

4
dialex

Die einfachste Methode besteht darin, Ihr Programm (unverändert) in der Cygwin-Konsole auszuführen.

Die zweite einfachste Methode ist, Ihr Programm (auch unverändert) in der gewöhnlichen Windows-Konsole auszuführen und die Ausgabe über tee.exe (von Cygwin oder Git-Distribution) zu pipeln. Tee.exe erkennt die Escape-Codes und ruft entsprechende WinAPI-Funktionen auf.

So etwas wie:

Java MyClass | tee.exe log.txt
Java MyClass | tee.exe /dev/null
3
user222202

Escape-Sequenzen müssen von SOMETHING interpretiert werden, um in Farbe umgewandelt zu werden. Die Standard-Datei CMD.EXE, die von Java verwendet wird, wenn sie von der Befehlszeile aus gestartet wird, unterstützt dies nicht und daher auch Java nicht.

Check This Out: Ich habe ANSI-Werte mit Escape-Code verwendet und es funktioniert wahrscheinlich nicht in Windows-Eingabeaufforderung, sondern in IDEs und Unix-Shell. Sie können auch die 'Jansi'-Bibliothek hier für Windows-Unterstützung prüfen.

System.out.println("\u001B[35m" + "This text is PURPLE!" + "\u001B[0m");
1

System.err.println ("Errorrrrrr") druckt Text in roter Farbe auf der Konsole.

0
Kamran

Ich habe eine Bibliothek namens AnsiScape geschrieben, mit der Sie farbige Ausgaben strukturierter schreiben können:

Beispiel:

AnsiScape ansiScape = new AnsiScape();
String colors = ansiScape.format("{red {blueBg Red text with blue background}} {b Bold text}");
System.out.println(colors);

In der Bibliothek können Sie auch eigene "Escape-Klassen" definieren, die den CSS-Klassen ähneln.

Beispiel:

AnsiScapeContext context = new AnsiScapeContext();

// Defines a "class" for text
AnsiClass text = AnsiClass.withName("text").add(RED);
// Defines a "class" for the title used
AnsiClass title = AnsiClass.withName("title").add(BOLD, BLUE_BG, YELLOW);
// Defines a "class" to render urls
AnsiClass url = AnsiClass.withName("url").add(BLUE, UNDERLINE);

// Registering the classes to the context
context.add(text).add(title).add(url);

// Creating an AnsiScape instance with the custom context
AnsiScape ansiScape = new AnsiScape(context);

String fmt = "{title Chapter 1}\n" +
              "{text So it begins:}\n" +
              "- {text Option 1}\n" +
              "- {text Url: {url www.someurl.xyz}}";

System.out.println(ansiScape.format(fmt));
0
Andrei Ciobanu