java-multiline-string

Posted on: 2019-10-08 2019-11-19
Tags: Java String

Java Multi-line String

1. Overview

Due to the fact that there is no native multi-line string class in Java yet, it’s a little bit tricky to create and utilize multi-line strings.

In this tutorial, we walk through several methods to make and use multi-line strings in Java.

2. Getting the Line Separator

Each operating system can have its own way of defining and recognizing new lines. In Java, it’s very easy to get the operating system line separator:

String newLine = System.getProperty("line.separator");

We’re going to use this newLine in the following sections to create multi-line strings.

3. String Concatenation

String concatenation is an easy native method which can be used to create multi-line strings:

public String stringConcatenation() {
    return "Get busy living"
            .concat(newLine)
            .concat("or")
            .concat(newLine)
            .concat("get busy dying.")
            .concat(newLine)
            .concat("--Stephen King");
}

Using the + operator is another way of achieving the same thing. Java compilers translate concat() and the + operator in the same way:

public String stringConcatenation() {
    return "Get busy living"
            + newLine
            + "or"
            + newLine
            + "get busy dying."
            + newLine
            + "--Stephen King";
}

4. String Join

Java 8 introduced String#join, which takes a delimiter along with some strings as arguments. It returns a final string having all input strings joined together with the delimiter:

public String stringJoin() {
    return String.join(newLine,
                       "Get busy living",
                       "or",
                       "get busy dying.",
                       "--Stephen King");
}

5. String Builder

StringBuilder is a helper class to build Strings. StringBuilder was introduced in Java 1.5 as a replacement for StringBuffer. It’s a good choice for building huge strings in a loop:

public String stringBuilder() {
    return new StringBuilder()
            .append("Get busy living")
            .append(newLine)
            .append("or")
            .append(newLine)
            .append("get busy dying.")
            .append(newLine)
            .append("--Stephen King")
            .toString();
}

6. String Writer

StringWriter is another method that we can utilize to create a multi-line string. We don’t need newLine here, because we use PrintWriter. The println function automatically adds new lines:

public String stringWriter() {
    StringWriter stringWriter = new StringWriter();
    PrintWriter printWriter = new PrintWriter(stringWriter);
    printWriter.println("Get busy living");
    printWriter.println("or");
    printWriter.println("get busy dying.");
    printWriter.println("--Stephen King");
    return stringWriter.toString();
}

7. Guava Joiner

Using an external library just for a simple task like this doesn’t make much sense, however, if the project already uses the library for other purposes, we can utilize it. For example, Google’s Guava library is very popular. Guava has a Joiner class that is able to build multi-line strings:

public String guavaJoiner() {
    return Joiner.on(newLine).join(ImmutableList.of("Get busy living",
        "or",
        "get busy dying.",
        "--Stephen King"));
}

8. Loading from a File

Java reads files exactly as they are. This means that if we have a multi-line string in a text file, we’ll have the same string when we read the file. There are a lot of ways to read from a file in Java.

Actually, it’s a good practice to separate long strings from code:

public String loadFromFile() throws IOException {
    return new String(Files.readAllBytes(Paths.get("src/main/resources/stephenking.txt")));
}

9. Using IDE Features

Many modern IDEs support multi-line copy/paste. Eclipse and IntelliJ IDEA are examples of such IDEs. We can simply copy our multi-line string and paste in inside two double quotes in these IDEs.

Obviously, this method doesn’t work for string creation in run time, but it’s a quick and easy way to get a multi-line string.

10. Conclusion

In this tutorial, we learned several methods to build multi-line strings in Java.

The good news is Java 13 will have native support for multi-line strings via Text Blocks. Needless to say, all the methods above will still work in Java 13.

The code for all the methods in this article is available over on Github.

getdocs

3043