如何在控制台使用System.out.println打印颜色?

我如何在控制台打印颜色?当处理器发送数据时，我想用不同的颜色显示数据，当处理器接收数据时，我想用不同的颜色显示数据。

558217 次浏览
小开

如果你的终端支持它，你可以使用ANSI转义码在输出中使用颜色。它通常适用于Unix shell提示符;然而，它并不适用于Windows命令提示符(尽管，它适用于Cygwin)。例如，你可以为颜色定义这样的常量:

public static final String ANSI_RESET = "\u001B[0m";
public static final String ANSI_BLACK = "\u001B[30m";
public static final String ANSI_RED = "\u001B[31m";
public static final String ANSI_GREEN = "\u001B[32m";
public static final String ANSI_YELLOW = "\u001B[33m";
public static final String ANSI_BLUE = "\u001B[34m";
public static final String ANSI_PURPLE = "\u001B[35m";
public static final String ANSI_CYAN = "\u001B[36m";
public static final String ANSI_WHITE = "\u001B[37m";

然后，您可以在必要时引用它们。

例如，使用上述常量，你可以在受支持的终端上输出如下红色文本:

System.out.println(ANSI_RED + "This text is red!" + ANSI_RESET);

你可能想要检查Jansi库。它提供了一个API，并支持使用JNI的Windows。我还没试过;然而，它看起来很有希望。

同样，如果你想改变文本的背景颜色为不同的颜色，你也可以尝试以下方法:

public static final String ANSI_BLACK_BACKGROUND = "\u001B[40m";
public static final String ANSI_RED_BACKGROUND = "\u001B[41m";
public static final String ANSI_GREEN_BACKGROUND = "\u001B[42m";
public static final String ANSI_YELLOW_BACKGROUND = "\u001B[43m";
public static final String ANSI_BLUE_BACKGROUND = "\u001B[44m";
public static final String ANSI_PURPLE_BACKGROUND = "\u001B[45m";
public static final String ANSI_CYAN_BACKGROUND = "\u001B[46m";
public static final String ANSI_WHITE_BACKGROUND = "\u001B[47m";

例如:

System.out.println(ANSI_GREEN_BACKGROUND + "This text has a green background but default text!" + ANSI_RESET);
System.out.println(ANSI_RED + "This text has red text but a default background!" + ANSI_RESET);
System.out.println(ANSI_GREEN_BACKGROUND + ANSI_RED + "This text has a green background and red text!" + ANSI_RESET);
小开

一种相当可移植的方法是使用原始转义序列。看到http://en.wikipedia.org/wiki/ANSI_escape_code

[编辑为user9999999 on 2017-02-20]

Java不“处理代码”，这是真的，但是Java输出你让它输出的东西。Windows控制台将ESC (chr(27))视为另一个符号(←)，这不是Java的错。

you made me boot into Windows.

小开

我创建了一个名为JColor的库，可以在Linux、macOS和Windows 10上运行。

它使用WhiteFang提到的ANSI代码，但使用用文字代替代码抽象它们，这更直观。最近我增加了对8位和24位颜色的支持🌈

选择你的格式，colorize它，并打印它:

System.out.println(colorize("Green text on blue", GREEN_TEXT(), BLUE_BACK()));

你也可以定义一个格式，然后重复使用几次:

AnsiFormat fWarning = new AnsiFormat(RED_TEXT(), YELLOW_BACK(), BOLD());
System.out.println(colorize("Something bad happened!", fWarning));

前往JColor github仓库获取一些示例。

小开

您可以使用ANSI转义序列来实现这一点。实际上，我已经在Java中为任何想要简单解决这个问题的人组合了这个类。它允许的不仅仅是颜色代码。

https://gist.github.com/nathan-fiscaletti/9dc252d30b51df7d710a

特性

  • 完整的源代码文档
  • 4位颜色支持(16种颜色)
  • 8位颜色支持(255种颜色)
  • 24位颜色支持(1670万种颜色)
    • 支持十六进制和8位RGB值
  • 支持通用格式
    • 隐藏文本，反转颜色，闪烁，下划线，删除，暗淡，粗体，斜体
  • 能够从包含ANSI转义序列的字符串中剥离ANSI。

示例使用

System.out.println(


new AnsiStringBuilder()
// All formatting functions support at least three different
// overloads, each intended for a different use case.


// Use case 1: Manual Reset
.italic()
.append("This is italicized and reset manually.")
// You can optionaly supply an additional append string
// to any of the reset functions that will be appended
// after the formating reset has been applied.
.resetItalic(System.lineSeparator())


// Use case 2: Automatic Reset
.dim("This is dimmed and reset automatically.")
.append(System.lineSeparator())


// Use case 3: Function Consumer
.underline(
sb -> {
// The string builder passed to this function consumer
// will automatically wrap all content appended to it
// with the underline formatting.
sb.color24(
"#00ff00",
"This is both underlined and green"
);
}
)
.append(System.lineSeparator())


);
小开

下面是一个带有public static字段的Java类中的颜色列表

使用

System.out.println(ConsoleColors.RED + "RED COLORED" +
ConsoleColors.RESET + " NORMAL");
< p > < br > 请注意 不要忘记在打印后使用RESET，因为如果它没有被清除，效果将保持

< br >

public class ConsoleColors {
// Reset
public static final String RESET = "\033[0m";  // Text Reset


// Regular Colors
public static final String BLACK = "\033[0;30m";   // BLACK
public static final String RED = "\033[0;31m";     // RED
public static final String GREEN = "\033[0;32m";   // GREEN
public static final String YELLOW = "\033[0;33m";  // YELLOW
public static final String BLUE = "\033[0;34m";    // BLUE
public static final String PURPLE = "\033[0;35m";  // PURPLE
public static final String CYAN = "\033[0;36m";    // CYAN
public static final String WHITE = "\033[0;37m";   // WHITE


// Bold
public static final String BLACK_BOLD = "\033[1;30m";  // BLACK
public static final String RED_BOLD = "\033[1;31m";    // RED
public static final String GREEN_BOLD = "\033[1;32m";  // GREEN
public static final String YELLOW_BOLD = "\033[1;33m"; // YELLOW
public static final String BLUE_BOLD = "\033[1;34m";   // BLUE
public static final String PURPLE_BOLD = "\033[1;35m"; // PURPLE
public static final String CYAN_BOLD = "\033[1;36m";   // CYAN
public static final String WHITE_BOLD = "\033[1;37m";  // WHITE


// Underline
public static final String BLACK_UNDERLINED = "\033[4;30m";  // BLACK
public static final String RED_UNDERLINED = "\033[4;31m";    // RED
public static final String GREEN_UNDERLINED = "\033[4;32m";  // GREEN
public static final String YELLOW_UNDERLINED = "\033[4;33m"; // YELLOW
public static final String BLUE_UNDERLINED = "\033[4;34m";   // BLUE
public static final String PURPLE_UNDERLINED = "\033[4;35m"; // PURPLE
public static final String CYAN_UNDERLINED = "\033[4;36m";   // CYAN
public static final String WHITE_UNDERLINED = "\033[4;37m";  // WHITE


// Background
public static final String BLACK_BACKGROUND = "\033[40m";  // BLACK
public static final String RED_BACKGROUND = "\033[41m";    // RED
public static final String GREEN_BACKGROUND = "\033[42m";  // GREEN
public static final String YELLOW_BACKGROUND = "\033[43m"; // YELLOW
public static final String BLUE_BACKGROUND = "\033[44m";   // BLUE
public static final String PURPLE_BACKGROUND = "\033[45m"; // PURPLE
public static final String CYAN_BACKGROUND = "\033[46m";   // CYAN
public static final String WHITE_BACKGROUND = "\033[47m";  // WHITE


// High Intensity
public static final String BLACK_BRIGHT = "\033[0;90m";  // BLACK
public static final String RED_BRIGHT = "\033[0;91m";    // RED
public static final String GREEN_BRIGHT = "\033[0;92m";  // GREEN
public static final String YELLOW_BRIGHT = "\033[0;93m"; // YELLOW
public static final String BLUE_BRIGHT = "\033[0;94m";   // BLUE
public static final String PURPLE_BRIGHT = "\033[0;95m"; // PURPLE
public static final String CYAN_BRIGHT = "\033[0;96m";   // CYAN
public static final String WHITE_BRIGHT = "\033[0;97m";  // WHITE


// Bold High Intensity
public static final String BLACK_BOLD_BRIGHT = "\033[1;90m"; // BLACK
public static final String RED_BOLD_BRIGHT = "\033[1;91m";   // RED
public static final String GREEN_BOLD_BRIGHT = "\033[1;92m"; // GREEN
public static final String YELLOW_BOLD_BRIGHT = "\033[1;93m";// YELLOW
public static final String BLUE_BOLD_BRIGHT = "\033[1;94m";  // BLUE
public static final String PURPLE_BOLD_BRIGHT = "\033[1;95m";// PURPLE
public static final String CYAN_BOLD_BRIGHT = "\033[1;96m";  // CYAN
public static final String WHITE_BOLD_BRIGHT = "\033[1;97m"; // WHITE


// High Intensity backgrounds
public static final String BLACK_BACKGROUND_BRIGHT = "\033[0;100m";// BLACK
public static final String RED_BACKGROUND_BRIGHT = "\033[0;101m";// RED
public static final String GREEN_BACKGROUND_BRIGHT = "\033[0;102m";// GREEN
public static final String YELLOW_BACKGROUND_BRIGHT = "\033[0;103m";// YELLOW
public static final String BLUE_BACKGROUND_BRIGHT = "\033[0;104m";// BLUE
public static final String PURPLE_BACKGROUND_BRIGHT = "\033[0;105m"; // PURPLE
public static final String CYAN_BACKGROUND_BRIGHT = "\033[0;106m";  // CYAN
public static final String WHITE_BACKGROUND_BRIGHT = "\033[0;107m";   // WHITE
}
小开

如果有人正在寻找一个快速的解决方案，请随意使用以下helper类:)

public class Log {


public static final String ANSI_RESET = "\u001B[0m";
public static final String ANSI_BLACK = "\u001B[30m";
public static final String ANSI_RED = "\u001B[31m";
public static final String ANSI_GREEN = "\u001B[32m";
public static final String ANSI_YELLOW = "\u001B[33m";
public static final String ANSI_BLUE = "\u001B[34m";
public static final String ANSI_PURPLE = "\u001B[35m";
public static final String ANSI_CYAN = "\u001B[36m";
public static final String ANSI_WHITE = "\u001B[37m";


//info
public static void i(String className, String message) {
System.out.println(ANSI_GREEN + className + " : " + message + ANSI_RESET);
}


//error
public static void e(String className, String message) {
System.out.println(ANSI_RED + className + " : " + message + ANSI_RESET);
}


//debug
public static void d(String className, String message) {
System.out.println(ANSI_BLUE + className + " : " + message + ANSI_RESET);
}


//warning
public static void w(String className, String message) {
System.out.println(ANSI_YELLOW + className + " : " + message + ANSI_RESET);
}


}

用法:

Log.i(TAG,"This is an info message");


Log.e(TAG,"This is an error message");


Log.w(TAG,"This is a warning message");


Log.d(TAG,"This is a debug message");

感谢@whiteFang34提供的ANSI代码。

小开

尝试以下枚举:

enum Color {
//Color end string, color reset
RESET("\033[0m"),


// Regular Colors. Normal color, no bold, background color etc.
BLACK("\033[0;30m"),    // BLACK
RED("\033[0;31m"),      // RED
GREEN("\033[0;32m"),    // GREEN
YELLOW("\033[0;33m"),   // YELLOW
BLUE("\033[0;34m"),     // BLUE
MAGENTA("\033[0;35m"),  // MAGENTA
CYAN("\033[0;36m"),     // CYAN
WHITE("\033[0;37m"),    // WHITE


// Bold
BLACK_BOLD("\033[1;30m"),   // BLACK
RED_BOLD("\033[1;31m"),     // RED
GREEN_BOLD("\033[1;32m"),   // GREEN
YELLOW_BOLD("\033[1;33m"),  // YELLOW
BLUE_BOLD("\033[1;34m"),    // BLUE
MAGENTA_BOLD("\033[1;35m"), // MAGENTA
CYAN_BOLD("\033[1;36m"),    // CYAN
WHITE_BOLD("\033[1;37m"),   // WHITE


// Underline
BLACK_UNDERLINED("\033[4;30m"),     // BLACK
RED_UNDERLINED("\033[4;31m"),       // RED
GREEN_UNDERLINED("\033[4;32m"),     // GREEN
YELLOW_UNDERLINED("\033[4;33m"),    // YELLOW
BLUE_UNDERLINED("\033[4;34m"),      // BLUE
MAGENTA_UNDERLINED("\033[4;35m"),   // MAGENTA
CYAN_UNDERLINED("\033[4;36m"),      // CYAN
WHITE_UNDERLINED("\033[4;37m"),     // WHITE


// Background
BLACK_BACKGROUND("\033[40m"),   // BLACK
RED_BACKGROUND("\033[41m"),     // RED
GREEN_BACKGROUND("\033[42m"),   // GREEN
YELLOW_BACKGROUND("\033[43m"),  // YELLOW
BLUE_BACKGROUND("\033[44m"),    // BLUE
MAGENTA_BACKGROUND("\033[45m"), // MAGENTA
CYAN_BACKGROUND("\033[46m"),    // CYAN
WHITE_BACKGROUND("\033[47m"),   // WHITE


// High Intensity
BLACK_BRIGHT("\033[0;90m"),     // BLACK
RED_BRIGHT("\033[0;91m"),       // RED
GREEN_BRIGHT("\033[0;92m"),     // GREEN
YELLOW_BRIGHT("\033[0;93m"),    // YELLOW
BLUE_BRIGHT("\033[0;94m"),      // BLUE
MAGENTA_BRIGHT("\033[0;95m"),   // MAGENTA
CYAN_BRIGHT("\033[0;96m"),      // CYAN
WHITE_BRIGHT("\033[0;97m"),     // WHITE


// Bold High Intensity
BLACK_BOLD_BRIGHT("\033[1;90m"),    // BLACK
RED_BOLD_BRIGHT("\033[1;91m"),      // RED
GREEN_BOLD_BRIGHT("\033[1;92m"),    // GREEN
YELLOW_BOLD_BRIGHT("\033[1;93m"),   // YELLOW
BLUE_BOLD_BRIGHT("\033[1;94m"),     // BLUE
MAGENTA_BOLD_BRIGHT("\033[1;95m"),  // MAGENTA
CYAN_BOLD_BRIGHT("\033[1;96m"),     // CYAN
WHITE_BOLD_BRIGHT("\033[1;97m"),    // WHITE


// High Intensity backgrounds
BLACK_BACKGROUND_BRIGHT("\033[0;100m"),     // BLACK
RED_BACKGROUND_BRIGHT("\033[0;101m"),       // RED
GREEN_BACKGROUND_BRIGHT("\033[0;102m"),     // GREEN
YELLOW_BACKGROUND_BRIGHT("\033[0;103m"),    // YELLOW
BLUE_BACKGROUND_BRIGHT("\033[0;104m"),      // BLUE
MAGENTA_BACKGROUND_BRIGHT("\033[0;105m"),   // MAGENTA
CYAN_BACKGROUND_BRIGHT("\033[0;106m"),      // CYAN
WHITE_BACKGROUND_BRIGHT("\033[0;107m");     // WHITE


private final String code;


Color(String code) {
this.code = code;
}


@Override
public String toString() {
return code;
}
}

现在我们来举个小例子:

class RunApp {
public static void main(String[] args) {


System.out.print(Color.BLACK_BOLD);
System.out.println("Black_Bold");
System.out.print(Color.RESET);


System.out.print(Color.YELLOW);
System.out.print(Color.BLUE_BACKGROUND);
System.out.println("YELLOW & BLUE");
System.out.print(Color.RESET);


System.out.print(Color.YELLOW);
System.out.println("YELLOW");
System.out.print(Color.RESET);
}
}
小开

如果你使用Kotlin(它与Java无缝工作)，你可以创建这样一个枚举:

enum class AnsiColor(private val colorNumber: Byte) {
BLACK(0), RED(1), GREEN(2), YELLOW(3), BLUE(4), MAGENTA(5), CYAN(6), WHITE(7);


companion object {
private const val prefix = "\u001B"
const val RESET = "$prefix[0m"
private val isCompatible = "win" !in System.getProperty("os.name").toLowerCase()
}


val regular get() = if (isCompatible) "$prefix[0;3${colorNumber}m" else ""
val bold get() = if (isCompatible) "$prefix[1;3${colorNumber}m" else ""
val underline get() = if (isCompatible) "$prefix[4;3${colorNumber}m" else ""
val background get() = if (isCompatible) "$prefix[4${colorNumber}m" else ""
val highIntensity get() = if (isCompatible) "$prefix[0;9${colorNumber}m" else ""
val boldHighIntensity get() = if (isCompatible) "$prefix[1;9${colorNumber}m" else ""
val backgroundHighIntensity get() = if (isCompatible) "$prefix[0;10${colorNumber}m" else ""
}

然后像这样使用is:(下面的代码展示了所有颜色的不同样式)

val sampleText = "This is a sample text"
enumValues<AnsiColor>().forEach { ansiColor ->
println("${ansiColor.regular}$sampleText${AnsiColor.RESET}")
println("${ansiColor.bold}$sampleText${AnsiColor.RESET}")
println("${ansiColor.underline}$sampleText${AnsiColor.RESET}")
println("${ansiColor.background}$sampleText${AnsiColor.RESET}")
println("${ansiColor.highIntensity}$sampleText${AnsiColor.RESET}")
println("${ansiColor.boldHighIntensity}$sampleText${AnsiColor.RESET}")
println("${ansiColor.backgroundHighIntensity}$sampleText${AnsiColor.RESET}")
}

如果运行在不支持这些ANSI代码的Windows上，isCompatible检查通过将代码替换为空字符串来避免问题。

小开

为控制台文本上色的最好方法是使用ANSI转义码。除了文本颜色，ANSI转义码还允许背景色、装饰色等。

Unix

如果使用springboot，文本着色有一个特定的enum: org.springframework.boot.ansi.AnsiColor

Jansi库更高级一点(可以使用所有的ANSI转义码函数)，提供了一个API，并有一个使用JNA的对Windows的支持。

否则，您可以手动定义自己的颜色，如其他响应所示。

Windows 10

Windows 10(自build 10.0.10586 - 2015年11月)支持ANSI转义码(MSDN文档) 但，默认情况下不启用。启用它:

  • 对于SetConsoleMode API，使用ENABLE_VIRTUAL_TERMINAL_PROCESSING (0x0400)标志。Jansi使用这个选项。
    • 如果没有使用SetConsoleMode API，可以通过创建一个dword来更改全局注册表键HKEY_CURRENT_USER\Console\VirtualTerminalLevel，并将其设置为0或1用于ANSI处理: 李"VirtualTerminalLevel"=dword:00000001 < / >

Windows 10之前

Windows控制台不支持ANSI颜色。但也可以使用控制台。

小开

在Java中用红色打印任何文本的最佳解决方案是:

System.err.print("Hello World");
小开

使用颜色功能打印带有颜色的文本

代码:

enum Color {


RED("\033[0;31m"),      // RED
GREEN("\033[0;32m"),    // GREEN
YELLOW("\033[0;33m"),   // YELLOW
BLUE("\033[0;34m"),     // BLUE
MAGENTA("\033[0;35m"),  // MAGENTA
CYAN("\033[0;36m"),     // CYAN


private final String code


Color(String code) {
this.code = code;
}


@Override
String toString() {
return code
}
}


def color = { color, txt ->
def RESET_COLOR = "\033[0m"
return "${color}${txt}${RESET_COLOR}"
}

用法:


test {
println color(Color.CYAN, 'testing')
}
小开

失败:

public static final String ANSI_STRIKEOUT_BLACK = "\u001B[30;9m";
public static final String ANSI_STRIKEOUT_RED = "\u001B[31;9m";
public static final String ANSI_STRIKEOUT_GREEN = "\u001B[32;9m";
public static final String ANSI_STRIKEOUT_YELLOW = "\u001B[33;9m";
public static final String ANSI_STRIKEOUT_BLUE = "\u001B[34;9m";
public static final String ANSI_STRIKEOUT_PURPLE = "\u001B[35;9m";
public static final String ANSI_STRIKEOUT_CYAN = "\u001B[36;9m";
public static final String ANSI_STRIKEOUT_WHITE = "\u001B[37;9m";
小开

Emoji

你可以像其他人在回答中提到的那样，在文本中使用颜色。

但是你可以用emojis代替!例如，你可以使用⚠️表示警告消息，使用🛑表示错误消息。

或者简单地用这些笔记本作为颜色:

📕: error message
📙: warning message
📗: ok status message
📘: action message
📓: canceled status message
📔: Or anything you like and want to recognize immediately by color

🎁奖金:

此方法还可以帮助您快速扫描和查找日志直接在源代码中。

但是Linux和Windows CMD默认的表情符号字体默认是不彩色的，你可能想让它们变得彩色。

如何打开表情包面板?

__abc0 __abc1 + __abc2 + __abc3

__abc0 __abc1 + __abc2

linux <强> < / >强: 控制 + ．或控制 + ；

小开

这个kotlin代码对我有用


import java.io.PrintStream


sealed class BackgroundColor(val value: Int) {
object Default : BackgroundColor(0)


// normal colors
object Black : BackgroundColor(40)
object Red : BackgroundColor(41)
object Green : BackgroundColor(42)
object Yellow : BackgroundColor(43)
object Blue : BackgroundColor(44)
object Magenta : BackgroundColor(45)
object Cyan : BackgroundColor(46)
object White : BackgroundColor(47)


// colors with high contrast
object BlackBright : BackgroundColor(100)
object RedBright : BackgroundColor(101)
object GreenBright : BackgroundColor(102)
object YellowBright : BackgroundColor(103)
object BlueBright : BackgroundColor(104)
object MagentaBright : BackgroundColor(105)
object CyanBright : BackgroundColor(106)
object WhiteBright : BackgroundColor(107)
}


sealed class TextColor(val value: Int) {
object Default : TextColor(0)


// normal colors
object Black : TextColor(30)
object Red : TextColor(31)
object Green : TextColor(32)
object Yellow : TextColor(33)
object Blue : TextColor(34)
object Magenta : TextColor(35)
object Cyan : TextColor(36)
object White : TextColor(37)


// colors with high contrast
object BlackBright : TextColor(90)
object RedBright : TextColor(91)
object GreenBright : TextColor(92)
object YellowBright : TextColor(93)
object BlueBright : TextColor(94)
object MagentaBright : TextColor(95)
object CyanBright : TextColor(96)
object WhiteBright : TextColor(97)
}


fun styleOutput(
backgroundColor: BackgroundColor = BackgroundColor.Default,
textColor: TextColor = TextColor.Default,
boldText : Boolean = false,
italicText : Boolean = false,
underLineText : Boolean = false,
action : PrintStream.() -> Unit
) {
val styleFormat = StringBuilder("${27.toChar()}[${backgroundColor.value};${textColor.value}")


if (boldText)
styleFormat.append(";1")


if (italicText)
styleFormat.append(";3")


if (underLineText)
styleFormat.append(";4")


styleFormat.append("m")


print(styleFormat)
System.out.action()
print("${27.toChar()}[0m")
}

然后使用它

print("text without styling")
styleOutput(backgroundColor = BackgroundColor.Blue, textColor = TextColor.GreenBright, boldText = true) {
print("text with styling")
}
print("text without styling")
小开
你可以使用JAnsi依赖项在Linux和Windows中更改颜色。 它以正确的方式打印UTF-8字符。 https://github.com/fusesource/jansi < / p >

提交答案