如何着色的System.out.println输出？ [重复](How to color Sys

2019-07-18 15:07发布

站内文章 / 移动开发

125 0

叛逆

女 | 书童

私信

这个问题已经在这里有一个答案：

如何使用System.out.println打印彩色的控制台？ 9个回答

我怎样才能颜色的Java输出？

例如，在C和其他语言，我可以使用ANSI转义像\033[0m做到这一点。但在Java中这是行不通的。

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

Answer 1:

没有，但也有第三方的API，可以处理它

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

编辑：当然也有比我一个较新发布的文章，信息仍然是可行的，但。

Answer 2:

Note

You may not be able to color Window's cmd prompt, but it should work in many unix (or unix-like) terminals.

Also, note that some terminals simply won't support some (if any) ANSI escape sequences and, especially, 24-bit colors.

Usage

Please refer to the section Curses at the bottom for the best solution. For a personal or easy solution (although not as cross-platform solution), refer to the ANSI Escape Sequences section.

TL;DR

java: System.out.println((char)27 + "[31m" + "ERROR MESSAGE IN RED");
python: print(chr(27) + "[31m" + "ERROR MESSAGE IN RED")
bash or zsh: printf '\x1b[31mERROR MESSAGE IN RED'
- this may also work for Os X: printf '\e[31mERROR MESSAGE IN RED'
sh: printf 'CTRL+V,CTRL+[[31mERROR MESSAGE IN RED'
- ie, press CTRL+V and then CTRL+[ in order to get a "raw" ESC character when escape interpretation is not available
- If done correctly, you should see a ^[. Although it looks like two characters, it is really just one, the ESC character.
- You can also press CTRL+V,CTRL+[ in vim in any of the programming or sripting langauges because that uses a literal ESC character
- Also, you can replace Ctrl+[ with ESC … eg, you can use CTRL+V,ESC, but I find the former easier, since I am already pressing CTRL and since [ is less out of the way.

ANSI Escape Sequences

Background on Escape Sequences

While it is not the best way to do it, the easiest way to do this in a programming or scripting language is to use escape sequences. From that link:

An escape sequence is a series of characters used to change the state of computers and their attached peripheral devices. These are also known as control sequences, reflecting their use in device control.

Backgound on ANSI Escape Sequences

However, it gets even easier than that in video text terminals, as these terminals use ANSI escape sequences. From that link:

ANSI escape sequences are a standard for in-band signaling to control the cursor location, color, and other options on video text terminals. Certain sequences of bytes, most starting with Esc and '[', are embedded into the text, which the terminal looks for and interprets as commands, not as character codes.

How to Use ANSI Escape Sequences

Generally

Escape sequences begin with an escape character; for ANSI escape sequences, the sequence always begins with ESC (ASCII: 27 / hex: 0x1B).
For a list of what you can do, refer to the ANSI Escape Sequence List on Wikipedia

In Programming Languages

Some programming langauges (like Java) will not interpret \e or \x1b as the ESC character. However, we know that the ASCII character 27 is the ESC character, so we can simply typecast 27 to a char and use that to begin the escape sequence.

Here are some ways to do it in common programming languages:

Java
- System.out.println((char)27 + "[33mYELLOW");
Python 3
- print(chr(27) + "[34mBLUE");
- print("\x1b[35mMAGENTA");
  - Note that \x1b is interpretted correctly in python
Node JS
- The following will NOT color output in JavaScript in the Web Console
- console.log(String.fromCharCode(27) + "[36mCYAN");
- console.log("\x1b[30;47mBLACK_ON_WHITE");
  - Note that \x1b also works in node

In Shell Prompt OR Scripts

If you are working with bash or zsh, it is quite easy to color the output (in most terminals). In Linux, Os X, and in some Window's terminals, you can check to see if your terminal supports color by doing both of the following:

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

如果你看到的颜色两种，那么这是伟大的！如果你看到的颜色只有一个，然后使用该序列。如果你没有看到任何一方的颜色，然后仔细检查，以确保正确键入的一切，你是在bash或zsh中; 如果你还没有看到任何颜色，然后你的终端可能不支持ANSI转义序列。

如果我没有记错，Linux的终端趋向于支持\e和\x1b转义序列，而OS X终端只是倾向于支持\e ，但我可能是错的。不过，如果你看到的东西像下面的图片，那么你所有的设置！（请注意，我使用的外壳，zsh的 ，它是着色我的提示字符串;另，我使用urxvt作为我在linux终端）

“这是如何运作的？” 你可能会问。 Bascially， printf是训释文字的后面（ 单引号内的所有内容）的序列。当printf遭遇\e或\x1b ，它会转换这些字符的ESC字符（ASCII：27）。这正是我们想要的。现在， printf发送ESC 31m ，由于有一个ESC后跟有效的ANSI转义序列，我们应该得到的彩色输出（只要它是由终端支持）。

还可以使用echo -e '\e[32mGREEN' （例如），对颜色输出。需要注意的是-e为标志echo “[启用]反斜线的解释转义”，如果你想必须使用echo适当地解释转义序列。

更多关于ANSI转义序列

ANSI转义序列可以做的不仅仅是彩色输出，但让我们先从这一点，看看到底怎么色彩的作品; 届时，我们将看到如何操纵光标; 最后，我们来看看，看看如何使用8位颜色，也24位色（虽然它只有稀薄的支持）。

在维基百科，他们指的ESC [如CSI ，所以我会做同样的。

颜色

颜色使用ANSI转义输出，使用以下命令：

CSI n m
- CSI ：逃避character- ^[[或ESC [
- n ：一个数字一如下：
  - 30 - 37 ， 39 ：前景
  - 40 - 47 ， 49 ：背景
- m ：一个文字的ASCII m -terminates转义序列

我将使用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 ：逃避character- ^[[或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 -terminates转义序列

虽然只对纤细支持微弱（2），斜体（3），下划线（4），闪烁（5,6），反向视频（7），隐藏（8），和划掉（9），一些（但很少全部）往往在Linux和OS X的终端工作。

这也是值得指出的是，你可以用分号隔开上述任何属性。例如printf '\e[34;47;1;3mCRAZY TEXT\n'将显示CRAZY TEXT具有blue foreground上的white background ，并且这将是bold和italic 。

例如：

扑通一声在bash或zsh的外壳下面看到所有的文字效果，你可以做。（您可能需要更换\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 ：逃避character- ^[[或ESC [
- 38;5; ：其表示用于前景使用8位颜色文字串
- n ：一个数字一如下：
  - 0 - 255

如果你想预览所有的颜色在一个很好的方式你的终端，我有上gist.github.com一个很好的剧本。

它看起来像这样：

如果你想改变使用8位色的背景下，只需更换38与48 ：

CSI 48;5; n m
- CSI ：逃避character- ^[[或ESC [
- 48;5; ：其表示用于背景使用的8位颜色文字串
- n ：一个数字一如下：
  - 0 - 255

24位彩色

也被称为真彩色，24位色提供了一些非常酷的功能。这肯定是越来越多的支持（据我知道它在最现代的终端除了urxvt，我的终端[插入怒的表情符号]）。

24位颜色在VIM实际支持（见VIM维基看如何启用24位色）。这真是整齐，因为它从GVIM定义的色彩方案拉动; 例如，它采用了FG / BG从highlight guibg=#______ guifg=#______为24位的色彩！ NEATO，是吧？

这是24位色的工作原理：

CSI 38;2; r ; g ; b m
- CSI ：逃避character- ^[[或ESC [
- 38;2; ：其表示用于前景使用的24位颜色文字串
- r g ， b ：数字-每个应该是0 - 255

为了测试短短的多种颜色的，你可以有（ (2^8)^3或2^24或16777216 possibilites，我认为），你可以在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终端 ，因为urxvt不支持24位色彩 ......振作起来，urxvt维护者......真正的）：

如果你想24位色彩为背景......你猜对了！您只需更换38与48 ：

CSI 48;2; r ; g ; b m
- CSI ：逃避character- ^[[或ESC [
- 48;2; ：其表示用于背景使用的24位颜色文字串
- r g ， b ：数字-每个应该是0 - 255

插入原始转义序列

有时\e和\x1b将无法正常工作。例如，在sh shell 中，有时没有作品（虽然现在我的系统上，我不认为它习惯了）。

为了规避这一点，你可以使用CTRL + V，Ctrl + [或CTRL V，ESC

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

例如：

赛跑

请参阅诅咒（编程库）页面上诅咒一个完整的参考。应当指出的是，诅咒仅限于Unix和类Unix操作系统。

启动和运行诅咒

我不会去太多的细节，对于搜索引擎可以显示相关网站的链接，可以解释这个比我好多了，但我会在这里简单地讨论，并给出一个例子。

为什么要使用诅咒在ANSI逃逸？

如果你看了上面的文字，你可能还记得， \e或\x1b有时会一起工作printf 。好了，有时\e和\x1b不会在所有的工作（这不是标准的，我从来没有像这样一个终端的工作，但它是可能的）。更重要的是，更复杂的转义序列（认为家庭和其他多字符键）难以为每一个终端支持（除非你愿意花大量的时间和精力分析的terminfo和termcap中和，并找出如何处理每一个终端）。

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

诅咒的大多数实现使用能够描述数千种不同终端的能力的数据库。有几个实施方式中，如PDCurses，其使用专门的设备驱动程序，而不是一个终端数据库。大多数的实现需要使用terminfo; 一些使用的termcap。诅咒具有背可移植性字符小区终端和简单的优点。对于不需要位映射图形或多种字体的应用程序，使用诅咒接口实现通常会简单得多，比一个用X工具箱更快。

大多数时候，诅咒将轮询的terminfo然后就能了解如何操纵光标和文本属性。然后，你，程序员，使用由诅咒提供的API来操纵光标或如果你寻求的功能需要改变文字颜色或其他属性。

实施例与Python

我发现蟒蛇是很容易使用，但如果你想在不同的编程语言使用诅咒，然后只需搜索它duckduckgo或其他任何搜索引擎。 :)这里是巨蟒-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平台的世界）。对于颜色，它是不是很重要，但是当涉及到支持其他多序列转义序列（如家庭 ，End，Page Up，Page Down键等），然后诅咒变得更加重要。

例如用TPUT

tput是用于操纵光标和文本的命令行实用程序
tput自带的curses包。如果你想在你的终端使用跨终端（ISH）应用程序，你应该使用tput的，因为它解析的terminfo或需要的地方，并使用一组标准化的命令（如诅咒），并返回正确的转义序列。
例：

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 3:

这为我工作：

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

你需要结束“[37米”的颜色恢复到白色（或任何你使用）。如果不这样做可能使后面的“红”的一切。

Answer 4:

您可以使用JANSI库来渲染ANSI转义序列在Windows中。

Answer 5:

是的，它是100％的可能

组类路径=％类路径％; 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的彩色打印机调试 ）。

对于Linux它使用WhiteFang提到的ANSI转义代码，但使用的话，而不是代码这是更为直观的抽象他们。

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

该库的许可之下MIT许可可以随意使用它。

看看JCDP的GitHub的仓库。

Answer 8:

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

第二个最简单的方法是在普通的Windows控制台运行您的程序（也未修改），通过流水线的tee.exe输出（从Cygwin的混帐或分布）。 Tee.exe将识别转义码，并调用相应的WinAPI的功能。

就像是：

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

Answer 9:

转义序列必须被什么东西被解释为被转换为颜色。在命令行启动时使用的Java标准CMD.EXE，不支持这个等于是Java则没有。

Answer 10:

检查了这一点：我用ANSI值与转义码，它可能无法正常工作在Windows命令提示符但在IDE和Unix外壳。你也可以检查“Jansi”库在这里支持Windows。

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

Answer 11:

通信System.err.println（“Errorrrrrr”），将在红色在控制台上打印文字。

Answer 12:

我写了一个叫库AnsiScape ，让你写的彩色输出更结构化的方式：

例：

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

该库还允许你定义自己的“逃生课”类似于CSS类。

例：

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 13:

这个工程在Eclipse只是把它的红色，不知道其他地方。

System.err.println(" BLABLA ");

文章来源: How to color System.out.println output? [duplicate]

标签： java colors system.out

叛逆