TOC

Sequência de várias linhas Java

Sequência de várias linhas Java

1. Visão geral

Devido ao fato de que ainda não há uma classe de string multi-linha nativa em Java, é um pouco complicado criar e utilizar strings multi-linha.

Neste tutorial, percorremos vários métodos paramake and use multi-line strings in Java.

2. Obtendo o separador de linha

Cada sistema operacional pode ter sua própria maneira de definir e reconhecer novas linhas. Em Java, é muito fácil obter o separador de linha do sistema operacional: 

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

Vamos usar essenewLine nas seções a seguir para criar strings de várias linhas.

3. Concatenação de String

A concatenação de strings é um método nativo fácil que pode ser usado para criar strings de várias linhas: 

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

Usar o operador + é outra maneira de conseguir a mesma coisa. Os compiladores Java traduzemconcat()e o operador + da mesma maneira: 

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

4. String Join

Java 8 introduziuString#join, que leva um delimitador junto com algumas strings como argumentos. Retorna uma string final com todas as strings de entrada unidas ao delimitador: 

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

5. String Builder

StringBuilder é uma classe auxiliar para construirStrings. StringBuilder foi introduzido no Java 1.5 como uma substituição paraStringBuffer. É uma boa escolha para construir cordas enormes em um 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. Escritor de string

StringWriter é outro método que podemos utilizar para criar uma string multilinhas. Não precisamos denewLine aqui, porque usamosPrintWriter. A funçãoprintln adiciona automaticamente novas linhas: 

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. Marceneiro de goiaba

Usar uma biblioteca externa apenas para uma tarefa simples como essa não faz muito sentido, no entanto, se o projeto já usa a biblioteca para outros fins, podemos utilizá-la. Por exemplo, a biblioteca Guava do Google é muito popular. Guava has a Joiner class que é capaz de construir strings multilinhas: 

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

8. Carregando de um arquivo

Java lê os arquivos exatamente como são. Isso significa que se tivermos uma string de várias linhas em um arquivo de texto, teremos a mesma string quando lermos o arquivo. Existem várias maneiras deread from a file in Java.

Na verdade, é uma boa prática separar strings longas do código: 

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

9. Usando recursos IDE

Muitos IDEs modernos suportam copiar / colar em várias linhas. Eclipse e IntelliJ IDEA são exemplos desses IDEs. Podemos simplesmente copiar nossa string de várias linhas e colar dentro de duas aspas duplas nesses IDEs.

Obviamente, este método não funciona para a criação de strings em tempo de execução, mas é uma maneira rápida e fácil de obter strings multilinhas.

10. Conclusão

Neste tutorial, aprendemos vários métodos para construir cadeias de linhas múltiplas em Java.

A boa notícia é que o Java 13 terá suporte nativo para strings de várias linhas viaText Blocks. Desnecessário dizer que todos os métodos acima ainda funcionarão em Java 13.

O código para todos os métodos neste artigo está disponívelover on Github.

Related