java - 如何为 System.out.println 输出着色？

Question

如何为 Java 输出着色？

例如，在 C 和其他语言中，我可以使用 ANSI-escape\033[0m来执行此操作。但是在Java中它不起作用。

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

Answer 1

笔记

您可能无法为 Window 着色cmd prompt，但它应该可以在许多 unix（或类 unix）终端中使用。

另外，请注意，某些终端根本不支持某些（如果有的话）ANSI 转义序列，尤其是 24 位颜色。

用法

请参阅底部的诅咒部分以获得最佳解决方案。对于个人或简单的解决方案（尽管不是跨平台的解决方案），请参阅ANSI Escape Sequences部分。

---

TL;博士

• 爪哇：System.out.println((char)27 + "[31m" + "ERROR MESSAGE IN RED");

• 蟒蛇：print(chr(27) + "[31m" + "ERROR MESSAGE IN RED")

• bash或zsh：printf '\x1b[31mERROR MESSAGE IN RED'
  • 这也可能适用于 Os X：printf '\e[31mERROR MESSAGE IN RED'
• 嘘：printf 'CTRL+ V，CTRL+[[31mERROR MESSAGE IN RED'
  • 即，当转义解释不可用时，按CTRL+V然后按 CTRL +[以获得“原始”字符ESC
  • 如果操作正确，您应该会看到一个^[. 虽然看起来像两个字符，但实际上只是一个ESC字符。
  • 您也可以在vim中的任何编程或 sripting 语言中按CTRL+ V、CTRL+ ，因为它使用文字字符[ESC
  • 此外，您可以将Ctrl+[替换为ESC... 例如，您可以使用CTRL+ V, ESC，但我发现前者更容易，因为我已经按下CTRL并且[不太碍事。

---

ANSI 转义序列

转义序列的背景

虽然这不是最好的方法，但在编程或脚本语言中最简单的方法是使用转义序列。从那个链接：

转义序列是一系列字符，用于更改计算机及其连接的外围设备的状态。这些也称为控制序列，反映了它们在设备控制中的用途。

ANSI 转义序列的背景

但是，它比视频文本终端更容易，因为这些终端使用ANSI 转义序列。从那个链接：

ANSI 转义序列是带内信令的标准，用于控制视频文本终端上的光标位置、颜色和其他选项。某些字节序列，大多数以 Esc 和 '[' 开头，嵌入到文本中，终端查找并解释为命令，而不是字符代码。

如何使用 ANSI 转义序列

一般来说

• 转义序列以转义字符开头；对于 ANSI 转义序列，序列始终以ESC(ASCII: 27/ hex: 0x1B) 开头。
• 有关您可以执行的操作的列表，请参阅Wikipedia 上的 ANSI Escape Sequence List

在编程语言中

一些编程语言（如 Java）不会将\e或解释\x1b为ESC字符。但是，我们知道 ASCII 字符27 就是字符，所以ESC我们可以简单地类型转换27为 achar并使用它来开始转义序列。

以下是一些常用编程语言的方法：

• 爪哇

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

• 蟒蛇 3

  • print(chr(27) + "[34mBLUE");
  • print("\x1b[35mMAGENTA");
    • 请注意，\x1b在 python 中正确解释

• 节点JS

  • 以下内容不会在 Web 控制台中的 JavaScript 中着色输出
  • console.log(String.fromCharCode(27) + "[36mCYAN");
  • console.log("\x1b[30;47mBLACK_ON_WHITE");
    • 请注意，\x1b也适用于节点

在 Shell 提示或脚本中

如果您正在使用bash或zsh，则很容易为输出着色（在大多数终端中）。在 Linux、Os X 和某些 Window 终端中，您可以通过执行以下两个操作来检查您的终端是否支持颜色：

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

如果您看到两者的颜色，那就太好了！如果您只看到一个颜色，请使用该序列。如果您没有看到其中任何一个的颜色，请仔细检查以确保您输入的所有内容都正确并且您使用的是 bash 或 zsh；如果您仍然看不到任何颜色，那么您的终端可能不支持 ANSI 转义序列。

如果我没记错的话，linux终端倾向于同时支持\e和\x1b转义序列，而os x终端只倾向于支持\e，但我可能错了。尽管如此，如果您看到类似下图的内容，那么您已经准备就绪！（请注意，我使用的是 shell，zsh，它正在为我的提示字符串着色；另外，我在 linux 中使用urxvt作为我的终端。）

“这是如何运作的？” 你可能会问。基本上，printf是解释后面的字符序列（单引号内的所有内容）。当printf遇到\eor\x1b时，会将这些字符转换为ESC字符（ASCII：27）。这正是我们想要的。现在，printf发送ESC31m，并且由于ESC后面有一个有效的 ANSI 转义序列，我们应该得到彩色输出（只要终端支持它）。

您还可以使用echo -e '\e[32mGREEN'（例如）颜色输出。请注意，“[启用] 反斜杠转义解释”-e标志，如果您想正确解释转义序列，则必须使用该标志。echo echo

---

更多关于 ANSI 转义序列

ANSI 转义序列可以做的不仅仅是颜色输出，但让我们从它开始，看看颜色是如何工作的；然后，我们将看到如何操作光标；最后，我们将看看如何使用 8 位颜色和 24 位颜色（虽然它只有微弱的支持）。

在Wikipedia上，他们指的ESC[是CSI，所以我也会这样做。

颜色

要使用 ANSI 转义进行颜色输出，请使用以下命令：

• CSI n m
  • CSI: 转义字符—<code>^[[ 或ESC[
  • n: 一个数字——以下之一：
    • 30- 37, 39: 前景
    • 40- 47, 49: 背景
  • m: 文字 ASCII —m终止转义序列

我将使用 bash 或 zsh 来演示所有可能的颜色组合。将以下内容放入 bash 或 zsh 以亲自查看（您可能需要替换\e为\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;

结果：

快速参考（颜色）

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

选择图形再现 (SGR)

SGR 只允许您更改文本。其中许多在某些终端中不起作用，因此在生产级项目中谨慎使用它们。但是，它们对于使程序输出更具可读性或帮助您区分不同类型的输出很有用。

颜色实际上属于 SGR，所以语法是一样的：

• CSI n m
  • CSI: 转义字符—<code>^[[ 或ESC[
  • n: 一个数字——以下之一：
    • 0： 重置
    • 1- 9：开启各种文字效果
    • 21- 29：关闭各种文字效果（支持比1-少9）
    • 30- 37, 39: 前景色
    • 40- 47, 49: 背景颜色
    • 38：8 位或 24 位前景色（请参阅下面的 8/24 位颜色）
    • 48：8 位或 24 位背景颜色（请参阅下面的 8/24 位颜色）
  • m: 文字 ASCII —m终止转义序列

虽然只有微弱的 (2)、斜体 (3)、下划线 (4)、闪烁 (5,6)、反向视频 (7)、隐藏 (8) 和划掉 (9)，但一些（但很少）倾向于在 linux 和 os x 终端上工作。

还值得注意的是，您可以用分号分隔上述任何属性。例如printf '\e[34;47;1;3mCRAZY TEXT\n'将CRAZY TEXT在 ablue foreground上显示 a white background，它将是boldand italic。

例如：

在您的 bash 或 zsh shell 中添加以下内容以查看您可以执行的所有文本效果。（您可能需要用 替换\e。\x1b）

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

结果：

你可以看到我的终端支持除了微弱（2）、隐藏（8）和划掉（9）之外的所有文本效果。

快速参考（SGR 属性 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 位彩色

虽然大多数终端都支持这一点，但它的支持不如0-7,9颜色。

句法：

• CSI 38;5; n m
  • CSI: 转义字符—<code>^[[ 或ESC[
  • 38;5;: 表示使用 8 位颜色作为前景的文字字符串
  • n: 一个数字——以下之一：
    • 0-255

如果您想以一种不错的方式预览终端中的所有颜色，我在 gist.github.com 上有一个不错的脚本。

它看起来像这样：

如果要使用 8 位颜色更改背景，只需将 替换38为48：

• CSI 48;5; n m
  • CSI: 转义字符—<code>^[[ 或ESC[
  • 48;5;: 表示使用 8 位颜色作为背景的文字字符串
  • n: 一个数字——以下之一：
    • 0-255

24 位彩色

也称为真彩色，24 位彩色提供了一些非常酷的功能。对此的支持肯定在增长（据我所知，它适用于大多数现代终端，​​除了urxvt，我的终端 [插入愤怒的表情符号]）。

vim 实际上支持 24 位颜色（请参阅vim wiki了解如何启用 24 位颜色）。它真的很整洁，因为它来自为 gvim 定义的颜色方案；highlight guibg=#______ guifg=#______例如，它使用来自24 位颜色的 fg/bg ！尼托，嗯？

以下是 24 位颜色的工作原理：

• CSI 38;2; r ; g ; b m
  • CSI: 转义字符—<code>^[[ 或ESC[
  • 38;2;: 表示使用 24 位颜色作为前景的文字字符串
  • r, g, b: 数字——每个都应该是0——255

要测试您可以拥有的多种颜色中的几种(2^8)^3（或2^24或16777216可能，我认为），您可以在 bash 或 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;

结果（这是在gnome-terminal中，因为urxvt不支持 24 位颜色……把它放在一起，urxvt 维护者……真的）：

如果你想要 24 位颜色的背景......你猜对了！您只需替换38为48：

• CSI 48;2; r ; g ; b m
  • CSI: 转义字符—<code>^[[ 或ESC[
  • 48;2;: 表示使用 24 位颜色作为背景的文字字符串
  • r, g, b: 数字——每个都应该是0——255

插入原始转义序列

有时\e并\x1b不会工作。例如，在sh shell 中，有时两者都不起作用（虽然它现在在我的系统上起作用，但我不认为它曾经如此）。

为了避免这种情况，您可以使用CTRL+ V、CTRL+[或CTRLV,ESC

这将插入一个“原始”ESC字符（ASCII：27）。它看起来像这样^[，但不要担心；它只有一个字符——不是两个。

例如：

---

诅咒

有关 curses 的完整参考，请参阅Curses（编程库）页面。需要注意的是，curses 仅适用于 unix 和类 unix 操作系统。

与诅咒一起运行

我不会详细介绍，因为搜索引擎可以显示指向网站的链接，这些链接可以比我更好地解释这一点，但我将在这里简要讨论并举一个例子。

为什么在 ANSI 转义上使用诅咒？

如果您阅读了上面的文字，您可能会记得\e或\x1b有时会使用printf. 好吧，有时\e根本\x1b不起作用（这不是标准的，我从未使用过这样的终端，但这是可能的）。更重要Home的是，每个终端都难以支持更复杂的转义序列（think 和其他多字符键）（除非您愿意花费大量时间和精力来解析 terminfo 和 termcap 并弄清楚如何处理每个终端） .

诅咒解决了这个问题。基本上，使用这些方法（如上面链接的维基百科文章所述），它能够了解终端具有哪些功能：

curses 的大多数实现使用可以描述数千个不同终端功能的数据库。有一些实现，例如 PDCurses，它们使用专门的设备驱动程序而不是终端数据库。大多数实现使用 terminfo；一些使用termcap。Curses 具有向后可移植到字符单元终端和简单性的优点。对于不需要位图图形或多种字体的应用程序，使用 curses 的接口实现通常比使用 X 工具包的更简单和更快。

大多数时候，curses 会轮询 terminfo，然后就能理解如何操作光标和文本属性。然后，您，程序员，使用curses 提供的API 来操作光标或更改文本颜色或其他属性，如果您需要的功能是需要的。

Python 示例

我发现 python 真的很容易使用，但是如果你想在不同的编程语言中使用 curses，那么只需在 dadduckgo 或任何其他搜索引擎上搜索它。:) 这是 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)

结果：

你可能会想，这是一种更全面的做事方式，但它确实更跨平台（真正跨终端……至少在 unix 和类 unix 平台的世界中）。对于颜色，它并不那么重要，但是当涉及到支持其他多序列转义序列（例如Home, End, Page Up, Page Down, 等）时，curses 变得更加重要。

Tput 示例

• tput是用于操作光标和文本的命令行实用程序
• tput随curses包一起提供。如果您想在终端中使用跨终端（ish）应用程序，您应该使用 tput，因为它会解析 terminfo 或任何它需要的内容，并使用一组标准化命令（如 curses）并返回正确的转义序列。
• 例子：

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

结果：

有关 Tput 的更多信息

• 请参阅：http ://linuxcommand.org/lc3_adv_tput.php了解 tput 的工作原理
• 请参阅：http: //invisible-island.net/ncurses/man/terminfo.5.html以获取您可以使用的命令列表

Answer 2

这对我有用：

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

您需要结尾 "[37m" 将颜色恢复为白色（或您使用的任何颜色）。如果你不这样做，它可能会使后面的一切都变成“红色”。

Answer 3

不，但有第三方 API 可以处理它

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

编辑：当然有比我发布的文章更新的文章，但这些信息仍然是可行的。

上面的链接已失效，请改为查看此问题：如何使用 System.out.println 在控制台中打印颜色？

Answer 4

您可以使用JANSI库在 Windows 中呈现 ANSI 转义序列。

Answer 5

是的，这是 100% 可能的

设置类路径= %classpath%;d:\jansi-1.4.jar;

试试下面的代码：

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 6

这是 Win32 控制台的解决方案。

1) 在此处获取 JavaNativeAccess 库：https ://github.com/twall/jna/

2) 这两个 Java 类可以解决问题。

享受。

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

Answer 7

我创建了一个jar名为JCDP（Java Colored Debug Printer）的库。

对于 Linux，它使用 WhiteFang 提到的 ANSI 转义码，但使用单词而不是更直观的代码来抽象它们。

对于 Windows，它实际上包含 JAnsi 库，但在其上创建了一个抽象层，保持为 Linux 创建的直观和简单的界面。

这个库是在MIT 许可下获得许可的，所以请随意使用它。

查看JCDP 的 github 存储库。

Answer 8

最简单的方法是在 Cygwin 控制台中运行您的程序（未修改）。

第二种最简单的方法是在普通的 Windows 控制台中运行您的程序（也未修改），通过 tee.exe（来自 Cygwin 或 Git 发行版）管道输出。Tee.exe 将识别转义码并调用适当的 WinAPI 函数。

就像是：

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

Answer 9

转义序列必须由 SOMETHING 解释才能转换为颜色。从命令行启动时 java 使用的标准 CMD.EXE 不支持这一点，因此 Java 不支持。

Answer 10

检查一下：我使用带有转义码的 ANSI 值，它可能不适用于 Windows 命令提示符，但在 IDE 和 Unix shell 中。您还可以在此处查看“Jansi”库 以获取 Windows 支持。

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

Answer 11

I've written a library called AnsiScape that allows you to write coloured output in a more structured way:

Example:

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

The library it also allows you to define your own "escape classes" akin to css classes.

Example:

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 12

System.err.println("Errorrrrrr") 它将在控制台上以红色打印文本。

Answer 13

这在eclipse中起作用只是为了把它变成红色，不知道其他地方。

System.err.println(" BLABLA ");