java - Cómo colorear salida System.out.println?

colors

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo imprimir el color en la consola usando System.out.println? 6 respuestas

¿Cómo puedo colorear la salida de Java?

Por ejemplo, en C y en otros idiomas, puedo usar ANSI-escape como /033[0m para hacer esto. Pero en Java no funciona.

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

Answer 1

Nota

Es posible que no pueda colorear el cmd prompt de Windows, pero debería funcionar en muchos terminales Unix (o unix).

Además, tenga en cuenta que algunos terminales simplemente no admiten algunas (si las hay) secuencias de escape ANSI y, especialmente, colores de 24 bits.

Uso

Consulte la sección Maldiciones en la parte inferior para obtener la mejor solución. Para una solución personal o sencilla (aunque no como una solución multiplataforma), consulte la sección Secuencias de escape de ANSI .

TL; DR

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

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

• bash o zsh : printf ''/x1b[31mERROR MESSAGE IN RED''
  • esto también puede funcionar para Os X: printf ''/e[31mERROR MESSAGE IN RED''
• sh : printf '' CTRL + V , CTRL + [ [31mERROR MESSAGE IN RED''
  • es decir, presione CTRL + V y luego CTRL + [ para obtener un carácter ESC "crudo" cuando la interpretación de escape no está disponible
  • Si se hace correctamente, debería ver un ^[ . Aunque parece dos personajes, en realidad es solo uno, el personaje ESC .
  • También puede presionar CTRL + V , CTRL + [ in vim en cualquiera de los lenguajes de programación o de generación porque utiliza un carácter ESC literal
  • Además, puede reemplazar Ctrl + [ con ESC ... ej., Puede usar CTRL + V , ESC , pero encuentro que el primero es más fácil, ya que estoy presionando CTRL y ya que [ está menos alejado del camino.

Secuencias de escape de ANSI

Antecedentes de las secuencias de escape

Si bien no es la mejor manera de hacerlo, la forma más fácil de hacerlo en un lenguaje de programación o scripting es usar secuencias de escape . Desde ese enlace:

Una secuencia de escape es una serie de caracteres utilizados para cambiar el estado de las computadoras y sus dispositivos periféricos conectados. También se conocen como secuencias de control, que reflejan su uso en el control del dispositivo.

Backgound en secuencias de escape de ANSI

Sin embargo, es aún más fácil que eso en los terminales de texto de video, ya que estos terminales usan secuencias de escape ANSI . Desde ese enlace:

Las secuencias de escape ANSI son un estándar para la señalización en banda para controlar la ubicación del cursor, el color y otras opciones en los terminales de texto de video. Ciertas secuencias de bytes, la mayoría de las cuales comienzan con Esc y ''['', están incrustadas en el texto, que el terminal busca e interpreta como comandos, no como códigos de caracteres.

Cómo usar las secuencias de escape de ANSI

En general

• Las secuencias de escape comienzan con un personaje de escape; para secuencias de escape ANSI, la secuencia siempre comienza con ESC (ASCII: 27 / hex: 0x1B ).
• Para obtener una lista de lo que puede hacer, consulte la Lista de secuencias de escape de ANSI en Wikipedia

En lenguajes de programación

Algunos lenguajes de programación (como Java) no interpretarán /e o /x1b como el carácter ESC . Sin embargo, sabemos que el carácter ASCII 27 es el carácter ESC , por lo que podemos simplemente encasillar 27 a un char y usarlo para comenzar la secuencia de escape.

Aquí hay algunas maneras de hacerlo en lenguajes de programación comunes:

• Java

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

• Python 3

  • print(chr(27) + "[34mBLUE");
  • print("/x1b[35mMAGENTA");
    • Tenga en cuenta que /x1b se interpreta correctamente en python

• Nodo JS

  • Lo siguiente NO imprimirá color en JavaScript en la consola web
  • console.log(String.fromCharCode(27) + "[36mCYAN");
  • console.log("/x1b[30;47mBLACK_ON_WHITE");
    • Tenga en cuenta que /x1b también funciona en el nodo

En Shell Prompt O Scripts

Si está trabajando con bash o zsh , es bastante fácil colorear la salida (en la mayoría de los terminales). En Linux, Os X y en algunos terminales de Windows, puede verificar si su terminal admite color haciendo lo siguiente:

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

Si ves color para ambos, ¡eso es genial! Si ve el color de solo uno, entonces use esa secuencia. Si no ve el color para ninguno de ellos, vuelva a verificar para asegurarse de que escribió todo correctamente y que está en bash o zsh; si aún no ve ningún color, entonces su terminal probablemente no es compatible con las secuencias de escape de ANSI.

Si recuerdo correctamente, los terminales de Linux tienden a admitir secuencias de escape /e y /x1b , mientras que los terminales os x solo tienden a ser compatibles con /e , pero puedo estar equivocado. Sin embargo, si ves algo como la siguiente imagen, entonces ¡estás listo! (Tenga en cuenta que estoy usando el intérprete de comandos, zsh , y está coloreando la cadena de mi prompt, también estoy usando urxvt como mi terminal en Linux.)

"¿Como funciona esto?" puedes preguntar Básicamente, printf está interpretando la secuencia de caracteres que sigue (todo dentro de las comillas simples ). Cuando printf encuentra /e o /x1b , convertirá estos caracteres al carácter ESC (ASCII: 27). Eso es justo lo que queremos. Ahora, printf envía ESC 31m , y dado que hay un ESC seguido de una secuencia de escape válida de ANSI, deberíamos obtener una salida de color (siempre que sea compatible con el terminal).

También puede usar echo -e ''/e[32mGREEN'' (por ejemplo), para dar salida a color. Tenga en cuenta que el -e para el echo "[habilita] la interpretación de la barra invertida se escapa" y se debe usar si desea que echo interprete apropiadamente la secuencia de escape.

Más sobre las Secuencias de Escape de ANSI

Las secuencias de escape de ANSI pueden hacer más que solo salida de color, pero comencemos con eso, y veamos exactamente cómo funciona el color; entonces, veremos cómo manipular el cursor; finalmente, echaremos un vistazo y veremos cómo usar el color de 8 bits y también el color de 24 bits (aunque solo tiene un soporte tenue).

En Wikipedia , se refieren a ESC [ como CSI , así que haré lo mismo.

Color

Para dar color a la salida utilizando escapes ANSI, use lo siguiente:

• CSI n m
  • CSI : carácter de ^[[ o ESC [
  • n : número uno de los siguientes:
    • 30 - 37 , 39 : primer plano
    • 40 - 47 , 49 : fondo
  • m : un ASCII literal m -termina la secuencia de escape

Usaré bash o zsh para demostrar todas las posibles combinaciones de colores. /x1b en lo siguiente en bash o zsh para verlo usted mismo (puede que tenga que reemplazar /e con /x1b ):

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

Resultado:

Referencia rápida (Color)

+~~~~~~+~~~~~~+~~~~~~~~~~~+
| 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 |
+~~~~~~+~~~~~~+~~~~~~~~~~~+

Seleccionar representación gráfica (SGR)

SGR solo te permite cambiar el texto. Muchos de estos no funcionan en ciertas terminales, por lo tanto, utilícelos con moderación en proyectos de nivel de producción. Sin embargo, pueden ser útiles para hacer que la salida del programa sea más legible o para ayudarlo a distinguir entre diferentes tipos de salida.

El color en realidad cae bajo SGR, por lo que la sintaxis es la misma:

• CSI n m
  • CSI : carácter de ^[[ o ESC [
  • n : número uno de los siguientes:
    • 0 : reinicio
    • 1 - 9 : activa varios efectos de texto
    • 21 - 29 : desactiva varios efectos de texto (menos compatible que 1 - 9 )
    • 30 - 37 , 39 : color de primer plano
    • 40 - 47 , 49 : color de fondo
    • Color en primer plano de 38 : 8 o 24 bits (ver Color de 8/24 bits a continuación)
    • Color de fondo de 48 : 8 o 24 bits (consulte Color de 8/24 bits a continuación)
  • m : un ASCII literal m -termina la secuencia de escape

Aunque solo hay soporte tenue para desmayo (2), cursiva (3), subrayado (4), parpadeo (5,6), video inverso (7), ocultamiento (8) y tachado (9), algunos (pero raramente todos) tienden a trabajar en terminales linux y os x.

También vale la pena observar que puede separar cualquiera de los atributos anteriores con un punto y coma. Por ejemplo printf ''/e[34;47;1;3mCRAZY TEXT/n'' mostrará CRAZY TEXT con un blue foreground sobre un white background , y estará en bold y italic .

P.ej:

Haga clic en lo siguiente en su shell bash o zsh para ver todos los efectos de texto que puede hacer. (Es posible que deba reemplazar /e con /x1b ).

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

Resultado:

Puede ver que mi terminal admite todos los efectos de texto excepto débil (2), ocultación (8) y tachado (9).

Referencia rápida (Atributos 0-9 de SGR)

+~~~~~+~~~~~~~~~~~~~~~~~~+
| 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

Color de 8 bits

Si bien la mayoría de los terminales admiten esto, es menos compatible con 0-7 , 9 colores.

Sintaxis:

• CSI 38;5; n m
  • CSI : carácter de ^[[ o ESC [
  • 38;5; : cadena literal que denota uso de colores de 8 bits para primer plano
  • n : número uno de los siguientes:
    • 0 - 255

Si desea una vista previa de todos los colores en su terminal de una manera agradable, tengo un buen script en gist.github.com .

Se parece a esto:

Si desea cambiar el fondo con colores de 8 bits, simplemente reemplace el 38 con un 48 :

• CSI 48;5; n m
  • CSI : carácter de ^[[ o ESC [
  • 48;5; : cadena literal que denota el uso de colores de 8 bits para el fondo
  • n : número uno de los siguientes:
    • 0 - 255

Color de 24 bits

También conocido como color verdadero, el color de 24 bits proporciona una funcionalidad realmente genial. El soporte para esto definitivamente está creciendo (hasta donde sé, funciona en la mayoría de las terminales modernas, excepto urxvt , mi terminal [inserta emoji enojado]).

El color de 24 bits se admite en realidad en vim (consulte la wiki de vim para ver cómo habilitar colores de 24 bits). Es realmente ordenado porque se extrae del esquema de color definido para gvim; por ejemplo, usa fg / bg de highlight guibg=#______ guifg=#______ para los colores de 24 bits! Neato, ¿eh?

Así es como funciona el color de 24 bits:

• CSI 38;2; r ; g ; b m
  • CSI : carácter de ^[[ o ESC [
  • 38;2; : cadena literal que denota uso de colores de 24 bits para primer plano
  • r , g , b : números: cada uno debe ser 0 - 255

Para probar solo algunos de los muchos colores que puedes tener ( (2^8)^3 o 2^24 o 16777216 posibilidades, creo), puedes usar esto en bash o zsh:

• 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;

Resultado (esto es en gnome-terminal dado que urxvt NO APOYA el color de 24 bits ... compruébelo, mantenedor de urxvt ... de verdad):

Si quieres colores de 24 bits para el fondo ... ¡lo adivinaste! Usted simplemente reemplaza 38 con 48 :

• CSI 48;2; r ; g ; b m
  • CSI : carácter de ^[[ o ESC [
  • 48;2; : cadena literal que denota el uso de colores de 24 bits para el fondo
  • r , g , b : números: cada uno debe ser 0 - 255

Insertar secuencias de escape crudas

A veces /e y /x1b no funcionarán. Por ejemplo, en el sh shell, a veces ninguno funciona (aunque lo hace en mi sistema ahora , no creo que solía hacerlo).

Para evitar esto, puede usar CTRL + V , CTRL + [ o CTRL V , ESC

Esto insertará un carácter ESC "en bruto" (ASCII: 27). Se verá así ^[ , pero no te preocupes; es solo un personaje, no dos.

P.ej:

Maldiciones

Consulte la página de Maldiciones (Biblioteca de programación) para obtener una referencia completa de las maldiciones. Se debe tener en cuenta que las maldiciones solo funcionan en sistemas operativos Unix y Unix.

Arriba y corriendo con maldiciones

No entraré en demasiados detalles, ya que los motores de búsqueda pueden revelar enlaces a sitios web que pueden explicar esto mucho mejor que yo, pero lo discutiré brevemente aquí y daré un ejemplo.

¿Por qué utilizar las maldiciones sobre ANSI Escapes?

Si lee el texto anterior, puede recordar que /e o /x1b algunas veces funcionará con printf . Bueno, a veces /e y /x1b no funcionarán en absoluto (esto no es estándar y nunca he trabajado con un terminal como este, pero es posible). Más importante aún, las secuencias de escape más complejas (piense en el hogar y otras teclas de múltiples caracteres) son difíciles de admitir para cada terminal (a menos que esté dispuesto a pasar mucho tiempo y esfuerzo analizando terminfo y termcap y descubriendo cómo manejar cada terminal )

Curses resuelve este problema. Básicamente, es capaz de entender qué capacidades tiene un terminal, utilizando estos métodos (como se describe en el artículo de wikipedia vinculado anteriormente):

La mayoría de las implementaciones de maldiciones usan una base de datos que puede describir las capacidades de miles de terminales diferentes. Hay algunas implementaciones, como PDCurses, que usan controladores de dispositivo especializados en lugar de una base de datos de terminal. La mayoría de las implementaciones usan terminfo; algunos usan termcap. Curses tiene la ventaja de la portabilidad posterior a los terminales de celda de caracteres y la simplicidad. Para una aplicación que no requiere gráficos mapeados en bits o fuentes múltiples, una implementación de interfaz que use maldiciones generalmente será mucho más simple y más rápida que una utilizando un conjunto de herramientas X.

La mayoría de las veces, las maldiciones sondearán terminfo y luego podrán entender cómo manipular los atributos de cursor y texto. Luego, usted, el programador, usa la API provista por las maldiciones para manipular el cursor o cambiar el color del texto u otros atributos si desea la funcionalidad que busca.

Ejemplo con Python

Encuentro que Python es realmente fácil de usar, pero si quieres usar curses en un lenguaje de programación diferente, simplemente búscalo en duckduckgo o en cualquier otro motor de búsqueda. :) Aquí hay un ejemplo rápido en 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 __name__ == ''__main__'':
curses.wrapper(main)

resultado:

Podrías pensar que esta es una forma mucho más redonda de hacer las cosas, pero en realidad es mucho más multiplataforma (realmente cruzada-terminal ... al menos en el mundo de la plataforma Unix y Unix). Para los colores, no es tan importante, pero cuando se trata de soportar otras secuencias de escape de múltiples secuencias (como Home , End , Page Up , Page Down , etc.), las maldiciones cobran aún más importancia.

Ejemplo con Tput

• tput es una utilidad de línea de comandos para manipular cursor y texto
• tput viene con el paquete de curses . Si desea utilizar aplicaciones de terminal cruzado (ish) en el terminal, debe usar tput, ya que analiza terminfo o lo que necesita y utiliza un conjunto de comandos estandarizados (como maldiciones) y devuelve la secuencia de escape correcta.
• ejemplo:

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/!"

Resultado:

Más información sobre Tput

• ver: http://linuxcommand.org/lc3_adv_tput.php para ver cómo funciona
• consulte: http://invisible-island.net/ncurses/man/terminfo.5.html para obtener una lista de comandos que puede usar

Answer 2

Aquí hay una solución para Win32 Console.

1) Obtenga las bibliotecas de JavaNativeAccess aquí: https://github.com/twall/jna/

2) Estas dos clases de Java harán el truco.

Disfrutar.

package com..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..util;
import java.io.PrintStream;
import com..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();
}
}
}

Answer 3

El método más simple es ejecutar su programa (sin modificar) en la consola de Cygwin.

El segundo método más simple es ejecutar su programa (también sin modificar) en la consola ordinaria de Windows, canalizando su salida a través de tee.exe (de la distribución de Cygwin o Git). Tee.exe reconocerá los códigos de escape y llamará a las funciones apropiadas de WinAPI.

Algo como:

java MyClass | tee.exe log.txt
java MyClass | tee.exe /dev/null

Answer 4

Esto funciona en eclipse solo para volverlo rojo, no sé sobre otros lugares.

System.err.println(" BLABLA ");

Answer 5

Esto me ha funcionado:

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

Necesitas la terminación "[37m" para devolver el color a blanco (o lo que sea que estés usando). Si no lo hace, puede hacer que todo lo que sigue sea "rojo".

Answer 6

He escrito una biblioteca llamada AnsiScape que te permite escribir resultados coloreados de una manera más estructurada:

Ejemplo:

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

La biblioteca también le permite definir sus propias "clases de escape" similares a las clases de CSS.

Ejemplo:

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

Answer 7

Las secuencias de escape deben ser interpretadas por ALGO para ser convertidas a color. El estándar CMD.EXE utilizado por Java cuando se inició desde la línea de comandos, no es compatible con esto por lo que Java no lo hace.

Answer 8

No, pero hay API de terceros que pueden manejarlo

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

Editar: por supuesto, hay artículos más nuevos que el que publiqué, pero la información aún es viable.

Answer 9

Puede usar la biblioteca JANSI para representar secuencias de escape ANSI en Windows.

Answer 10

Sí, es 100% posible

establecer classpath =% classpath%; d: / jansi-1.4.jar;

Pruebe este código a continuación:

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

Answer 11

System.err.println ("Errorrrrrr") imprimirá texto en color rojo en la consola.

Answer 12

Verifique esto: utilicé valores ANSI con código de escape y probablemente no funcione en el símbolo del sistema de Windows, sino en IDEs y shell de Unix. también puede verificar la biblioteca ''Jansi'' here para obtener soporte para Windows.

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

Answer 13

JCDP una biblioteca jar llamada JCDP ( Java Color Debug Printer ).

Para Linux usa los códigos de escape ANSI que WhiteFang mencionó, pero los abstrae usando palabras en lugar de códigos, lo cual es mucho más intuitivo.

Para Windows, realmente incluye la biblioteca JAnsi pero crea una capa de abstracción sobre ella, manteniendo la interfaz intuitiva y simple creada para Linux.

Esta biblioteca está autorizada bajo la Licencia MIT, así que siéntete libre de usarla.

Eche un vistazo al repositorio github de JCDP .