How to print color in console using System.out.println?

Question

How can I print color in console? I want to show data in colors when the processor sends data and in different colors when it receives data.

If the console support (e.g. Eclipse Java console) customizing color of stdout/stderr, then you can use System.out.println for one color and System.err.println for another color. — jw_, Sep 16 '19 at 01:36

score 791 · Answer 1 · edited Nov 03 '17 at 13:43

791

If your terminal supports it, you can use ANSI escape codes to use color in your output. It generally works for Unix shell prompts; however, it doesn't work for Windows Command Prompt (Although, it does work for Cygwin). For example, you could define constants like these for the colors:

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

Then, you could reference those as necessary.

For example, using the above constants, you could make the following red text output on supported terminals:

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

Update: You might want to check out the Jansi library. It provides an API and has support for Windows using JNI. I haven't tried it yet; however, it looks promising.

Update 2: Also, if you wish to change the background color of the text to a different color, you could try the following as well:

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

For instance:

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

edited Nov 03 '17 at 13:43

SergeyB

9,478
4
33
47

answered Apr 23 '11 at 05:56

WhiteFang34

70,765
18
106
111

1

@WhiteFang34 Can you please explain what is the use of RESET if its color is BLACK, at least in my console? Is it like a default or sth.? – Boro Apr 23 '11 at 08:31
9

@Boro: the reset code turns off all ANSI attributes set so far, which should return the console to its defaults. It's useful if you don't know the default color or are also using some of the other attributes like background color, font styles, etc. – WhiteFang34 Apr 23 '11 at 08:38
2

jansi is really great! for those who develop in eclipse, i can reccomend this plugin: http://mihai-nita.net/2013/06/03/eclipse-plugin-ansi-in-console/ and nice piece of code to enable color if the code isn't being executed in console: `if (System.console() == null) System.setProperty("jansi.passthrough", "true");` – Danny Lo Apr 13 '14 at 19:51
@WhiteFang34 i am using windows and for some reason it is not working – Pankaj Nimgade Feb 05 '15 at 10:32
2

@PankajNimgade, read the answer again and you'll maybe notice this: `however it doesn't work for Windows command prompt` – Felix Edelmann Sep 02 '15 at 15:23
It doesn't work on Windows it you're using cmd or powershell. Instead, you can use another console emulator. For instance, it works successfully with Cmder (http://cmder.net/) – morbac May 04 '18 at 06:37
Someone shall notice that when copy pasting these colors into NetBeans will result with one extra slash added by NetBeans... So don't be super mad like me while trying this out :D – Martin Krajčírovič Jul 13 '18 at 11:29
Doesn't work on eclipse Java version: 2018-12 (4.10.0) console windows during debugging. Indeed I want to output red text, for this purpose you can use System.err.println – jw_ Sep 16 '19 at 01:31
1

@DannyLo Thank you so much for the link to the Eclipse plugin! – Captain Jack Sparrow Feb 05 '20 at 14:17
1

As far as I know, it should work with newer versions of windows 10 in conhost too as it supports ansi codes. – dan1st Mar 13 '20 at 19:18
If I have `public static final String ANSI_RED = "\u001B[31m";` , how can I later get the color used for this specific String ? something like `ANSI_RED.getColor();` ? which I would want to return to me `Color.RED` – M.A.S Jan 25 '21 at 12:48
@M.A.S You could just create an Enum with all the unicode ASNI values. – Avec Dec 02 '21 at 08:06
You can get colour in Windows cmd by running "color" – Enderbyte09 Apr 15 '22 at 00:36
For WINDOWS 10 users, you will need to ENABLE_VIRTUAL_TERMINAL_PROCESSING https://stackoverflow.com/questions/52767585/how-can-you-use-vt100-escape-codes-in-java-on-windows – Anshuman Chatterjee Apr 19 '22 at 05:44

score 181 · Answer 2 · answered Aug 01 '17 at 17:57

Here are a list of colors in a Java class with public static fields

Usage

System.out.println(ConsoleColors.RED + "RED COLORED" +
ConsoleColors.RESET + " NORMAL");

Note Don't forget to use the RESET after printing as the effect will remain if it's not cleared

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
}

This is a great answer. It would be nice if someone can edit it for *italics* too, if supported, for the sake of completeness. thanks! — user0221441, Sep 11 '22 at 07:55

dialex · Answer 3 · 2020-11-02T15:24:37.910

91

I created a library called JColor that works on Linux, macOS, and Windows 10.

It uses the ANSI codes mentioned by WhiteFang, but abstracts them using words instead of codes which is more intuitive. Recently I added support for 8 and 24 bit colors

Choose your format, colorize it, and print it:

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

You can also define a format once, and reuse it several times:

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

Head over to JColor github repository for some examples.

edited Nov 02 '20 at 15:24

answered Aug 05 '11 at 14:03

dialex

2,706
8
44
74

2

Nice. Works as expected. – Avec Dec 01 '21 at 07:09
2

So wonderful! I loved it! Thank you! :) – aymens Feb 19 '22 at 23:08
found it. implementation 'com.diogonunes:JColor:5.5.1' – Orubel Sep 24 '22 at 18:45
yup, all versions here https://mvnrepository.com/artifact/com.diogonunes/JColor – dialex Sep 30 '22 at 11:11

score 75 · Answer 4 · edited Mar 13 '20 at 19:15

Try the following enum :

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

And now we will make a small example:

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

This is a copy of answer https://stackoverflow.com/a/45444716/675577 — dialex, Dec 21 '19 at 18:58
@dialex That answer seems to be originally from [w3schools](https://www.w3schools.blog/ansi-colors-java) and this answer provides the constants as an enum, which in my opinion is cleaner, more modern code and a better practice for holding these constants. — Marvin, Jan 07 '23 at 00:51

jcomeau_ictx · Answer 5 · 2017-02-21T11:46:08.323

14

A fairly portable way of doing it is with the raw escape sequences. See http://en.wikipedia.org/wiki/ANSI_escape_code

[edited for user9999999 on 2017-02-20]

Java doesn't "handle the codes", that's true, but Java outputs what you told it to output. it's not Java's fault that the Windows console treats ESC (chr(27)) as just another glyph (←).

edited Feb 21 '17 at 11:46

answered Apr 23 '11 at 05:56

jcomeau_ictx

37,688
6
92
107

which doesn't work because the Java IO layer does not convert those to colors. System.out.println((char)27 + "[31;1mERROR" + (char)27 + "[0m" only yields "[31;1mERROR[0m" when run from a windows cmd.com as an executable .jar – simpleuser Feb 12 '17 at 06:03
the question wasn't tagged `windows`. the Windows console was never ANSI-compliant that I remember. – jcomeau_ictx Feb 12 '17 at 14:52
but the issue is that java isn't handling the codes, regardless of cmd.com's support – simpleuser Feb 20 '17 at 17:31
3

see edited answer. Java is doing exactly as it's told. the problem is the non-ANSI-compliant console. – jcomeau_ictx Feb 21 '17 at 06:32
1

I have same problem – Stéphane GRILLON Mar 15 '18 at 14:58
look at http://cmder.net/ ; this console works fine on Windows and allows colored text – morbac May 04 '18 at 06:41
Maven uses this library to have colour in the console on any Operating system http://fusesource.github.io/jansi/ – firephil Mar 16 '19 at 20:25

Nathan F. · Answer 6 · 2022-06-17T22:22:10.120

You could do this using ANSI escape sequences. I've actually put together this class in Java for anyone that would like a simple workaround for this. It allows for more than just color codes.

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

Features

Full source documentation
4-bit color support (16 colors)
8-bit color support (255 colors)
24-bit color support (16.7 million colors)
- Hexadecimal and 8-bit RGB values supported
Support for common formatting
- hidden text, invert colors, blink, underline, strike-through, dim, bold, italic
Ability to strip ANSI from strings containing ANSI escape sequences.

Example Use

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

);

score 11 · Answer 7 · answered Sep 23 '17 at 03:22

If anyone is looking for a quick solution, feel free to use the following helper class :)

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

}

USAGE:

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

Thanks @whiteFang34 for the ANSI codes.

Mojtaba Hosseini · Answer 8 · 2021-10-13T09:55:57.757

11

Emoji

You can use colors for text as others mentioned in their answers.

But you can use emojis instead! for example you can use You can use ⚠️ for warning messages and for error messages.

Or simply use these note books as a color:

: error message
: warning message
: ok status message
: action message
: canceled status message
: Or anything you like and want to recognize immediately by color

Bonus:

This method also helps you to quickly scan and find logs directly in the source code.

_{But Linux and Windows CMD default emoji fonts are not colorful by default and you may want to make them colorful, first.}

How to open emoji panel?

mac os: control + command + space

windows: win + .

linux: control + . or control + ;

edited Oct 13 '21 at 09:55

answered Aug 15 '20 at 18:25

Mojtaba Hosseini

95,414
31
268
278

2

this might need UTF or similar support. you are only providing the final results, not the things the coder needs to do for that. the answer might break the box of what the question spanned up. – Alexander Stohr Jan 15 '21 at 14:09
Downvoted, for the reasons mentioned by Alexander – dialex Oct 13 '21 at 09:45
Added instructions for how to use emojis in different operating systems. @dialex – Mojtaba Hosseini Oct 13 '21 at 09:56
@AlexanderStohr I have added some more instructions. please tell me if you find any issues or better than that if you find solutions to complete the answer for the community – Mojtaba Hosseini Oct 13 '21 at 09:58

score 7 · Answer 9 · answered Jan 21 '19 at 13:43

The best way to color console text is to use ANSI escape codes. In addition of text color, ANSI escape codes allows background color, decorations and more.

Unix

If you use springboot, there is a specific enum for text coloring: org.springframework.boot.ansi.AnsiColor

Jansi library is a bit more advanced (can use all the ANSI escape codes fonctions), provides an API and has a support for Windows using JNA.

Otherwise, you can manually define your own color, as shown is other responses.

Windows 10

Windows 10 (since build 10.0.10586 - nov. 2015) supports ANSI escape codes (MSDN documentation) but it's not enabled by default. To enable it:

With SetConsoleMode API, use ENABLE_VIRTUAL_TERMINAL_PROCESSING (0x0400) flag. Jansi uses this option.
If SetConsoleMode API is not used, it is possible to change the global registry key HKEY_CURRENT_USER\Console\VirtualTerminalLevel by creating a dword and set it to 0 or 1 for ANSI processing: "VirtualTerminalLevel"=dword:00000001

Before Windows 10

Windows console does not support ANSI colors. But it's possible to use console which does.

On Windows the Cygwin console does the job. Also when using piplines with e.g. "tee" then the ANSI color codes see interpretation and maybe effects as well. Byond color codes the ANSI escapes can also do e.g. cursor control. — Alexander Stohr, Jan 15 '21 at 14:06
No, the variable has to be in the key `HKEY_CURRENT_USER\Console` directly - do not create another key `VirtualTerminalLevel` in there. — AmigoJack, Apr 27 '21 at 09:36

Shadi Abu Hilal · Answer 10 · 2020-02-05T02:01:58.573

Using color function to print text with colors

Code:

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}"
}

Usage:


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

score 1 · Answer 11 · answered Jan 20 '19 at 00:53

If you use Kotlin (which works seamlessly with Java), you can make such an enum:

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 ""
}

And then use is as such: (code below showcases the different styles for all colors)

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}")
}

If running on Windows where these ANSI codes are not supported, the isCompatible check avoids issues by replacing the codes with empty string.

score 1 · Answer 12 · answered Apr 21 '20 at 11:46

To strikeout:

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

Islam Khaled · Answer 13 · 2022-02-11T17:04:38.800

This kotlin code worked for me


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")
}

and to use it

print("text without styling")
styleOutput(backgroundColor = BackgroundColor.Blue, textColor = TextColor.GreenBright, boldText = true) {
    print("text with styling")
}
print("text without styling")

score 0 · Answer 14 · answered Apr 05 '22 at 07:40

0

You can use JAnsi dependency to change color in both Linux and Windows. It's prints UTF-8 characters in the right way. https://github.com/fusesource/jansi

answered Apr 05 '22 at 07:40

Jorge Berjano

16
2

score -6 · Answer 15 · edited Nov 07 '19 at 13:36

-6

Best Solution to print any text in red color in Java is:

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

edited Nov 07 '19 at 13:36

David

2,602
1
18
32

answered Nov 07 '19 at 13:10

iamgul

83
9

3

The "downvote" isn't mine - but, there are other answers that provide the OP's question, and they were posted some time ago. When posting an answer [see: How do I write a good answer?](https://stackoverflow.com/help/how-to-answer), please make sure you add either a new solution, or a substantially better explanation, especially when answering older questions. – help-info.de Nov 07 '19 at 13:35
10

@iSahil this probably got downvoted because simply writing to standard error doesn't explicitly color anything. Many IDEs and consoles will interpret error messages and print them in red or similar, but that's not something you can rely on. – David Nov 07 '19 at 13:38
1

While this wasn't the direct answer to the question asked above, this was the answer I was looking for when searching for "java print in red console". Thus, I do feel like it has it's place on this page. – Maude Jan 07 '20 at 16:07
1

printing to a different output stream just for color will get you in a multitude of problems – meredrica Sep 06 '21 at 09:56

How to print color in console using System.out.println?

15 Answers15

Features

Example Use

Emoji

Bonus:

How to open emoji panel?

Linked

Related