Introdução
Concatenação é o processo de combinar duas ou mais strings em uma única string. Em Java, existem várias maneiras de concatenar strings. Cada método tem suas vantagens e desvantagens dependendo dos requisitos. Este laboratório (lab) cobrirá as várias maneiras pelas quais podemos concatenar strings em Java.
Concatenar Strings usando o Operador +
O método mais simples de combinar strings em Java é usando o operador +. O operador + é sobrecarregado (overloaded) para trabalhar com strings. Siga o bloco de código abaixo para ver como concatenar strings usando o operador +.
public class ConcatenateStrings {
public static void main(String[] args) {
String a = "Hello";
String b = "World";
String combination = a + " " + b; // Using + operator to concatenate strings
System.out.println(combination); // Output: Hello World
}
}
Concatenar Strings usando a Classe StringBuilder
Outra maneira de concatenar strings em Java é usando a classe StringBuilder. A classe StringBuilder fornece o método append() para combinar duas ou mais strings. StringBuilder é mais rápido que a classe String ao concatenar strings. Siga o bloco de código abaixo sobre como concatenar strings usando a classe StringBuilder.
public class ConcatenateStrings {
public static void main(String[] args) {
String a = "Hello";
String b = "World";
StringBuilder builder = new StringBuilder();
builder.append(a).append(" ").append(b); // Using StringBuilder class to concatenate strings
String combination = builder.toString();
System.out.println(combination); // Output: Hello World
}
}
Concatenar Strings usando a Classe StringBuffer
Semelhante ao StringBuilder, StringBuffer também é uma sequência mutável de caracteres e fornece o método append() para anexar as strings. StringBuffer é sincronizado, o que significa que múltiplos threads não podem acessá-lo simultaneamente.
public class ConcatenateStrings {
public static void main(String[] args) {
String a = "Hello";
String b = "World";
StringBuffer buffer = new StringBuffer();
buffer.append(a).append(" ").append(b); // Using StringBuffer class to concatenate strings
String combination = buffer.toString();
System.out.println(combination); // Output: Hello World
}
}
Concatenar Strings usando o Método String.concat()
O método concat() pode ser usado para concatenar duas strings. Este método internamente usa a classe StringBuilder para realizar a concatenação. Siga o bloco de código abaixo sobre como usar o método concat() para concatenar strings.
public class ConcatenateStrings {
public static void main(String[] args) {
String a = "Hello";
String b = "World";
String combination = a.concat(" ").concat(b); // Using String.concat() method to concatenate strings
System.out.println(combination); // Output: Hello World
}
}
Concatenar Strings usando o Método String.join()
O método String.join() é usado para concatenar múltiplas strings com um delimitador. O primeiro parâmetro de String.join() é o delimitador que precisa ser adicionado entre as strings. Este método funciona a partir do Java 8. Siga o bloco de código abaixo para ver como concatenar strings usando o método String.join().
public class ConcatenateStrings {
public static void main(String[] args) {
String a = "Hello";
String b = "World";
String c = "Java";
String combination = String.join(" ", a, b, c); // Using String.join() method to concatenate strings
System.out.println(combination); // Output: Hello World Java
}
}
Concatenar Strings usando o Método String.format()
O método String.format() retorna uma string formatada. Ele recebe a string de formato como o primeiro parâmetro ao qual as variáveis string precisam ser concatenadas. Ele funciona de forma semelhante à função printf em C. Siga o bloco de código abaixo sobre como usar o método String.format() para concatenar strings.
public class ConcatenateStrings {
public static void main(String[] args) {
String a = "Hello";
String b = "World";
String c = "Java";
String combination = String.format("%s %s %s", a, b, c); // Using String.format() method to concatenate strings
System.out.println(combination); // Output: Hello World Java
}
}
Concatenar Strings usando o Método Arrays.toString()
O método Arrays.toString() é usado para retornar uma string que representa o conteúdo do array. Siga o bloco de código abaixo para ver como usar o método Arrays.toString() para concatenar um array de strings.
import java.util.Arrays;
public class ConcatenateStrings {
public static void main(String[] args) {
String[] strings = {"Hello", "World", "Java"};
String combination = Arrays.toString(strings); // Using Arrays.toString() method to concatenate an array of strings
System.out.println(combination); // Output: [Hello, World, Java]
}
}
Concatenar Strings usando a Classe StringJoiner
A classe StringJoiner é usada para juntar strings com um delimitador. A classe StringJoiner está disponível a partir do Java 8. No exemplo a seguir, vamos usar a classe StringJoiner para concatenar três strings com um delimitador. Siga o bloco de código abaixo sobre como usar a classe StringJoiner para concatenar strings.
import java.util.StringJoiner;
public class ConcatenateStrings {
public static void main(String[] args) {
StringJoiner joiner = new StringJoiner(" ");
joiner.add("Hello"); // Using StringJoiner class to concatenate strings
joiner.add("World");
joiner.add("Java");
String combination = joiner.toString();
System.out.println(combination); // Output: Hello World Java
}
}
Concatenar Strings usando o Método Collection.join()
Também podemos usar o método join() da classe Collections para concatenar uma lista de strings. Siga o bloco de código abaixo para ver como usar o método Collections.join() para concatenar uma lista de strings.
import java.util.Arrays;
import java.util.List;
import java.util.Collections;
public class ConcatenateStrings {
public static void main(String[] args) {
List<String> strings = Arrays.asList("Hello", "World", "Java");
String separator = " ";
String combination = String.join(separator, strings); // Using Collections.join() method to concatenate a list of strings
System.out.println(combination); // Output: Hello World Java
}
}
Concatenar Strings usando o Método Files.lines()
Também podemos usar o método Files.lines() introduzido no Java 8 para concatenar strings. Siga o bloco de código abaixo para ver como usar o método Files.lines() para concatenar strings.
import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;
public class ConcatenateStrings {
public static void main(String[] args) {
try {
String combination = Files.lines(Paths.get("file1.txt"))
.reduce("", (line1, line2) -> line1 + line2);
System.out.println(combination);
} catch (IOException exception) {
System.out.println("Exception Occurred: " + exception);
}
}
}
Nota: O bloco de código acima lê o conteúdo de um arquivo chamado file1.txt e concatena o conteúdo em uma única string.
Resumo
Em resumo, existem muitas maneiras de concatenar strings em Java. Neste laboratório, cobrimos vários métodos, como o operador +, a classe StringBuilder, a classe StringBuffer, o método String.concat(), o método String.join(), o método String.format(), o método Arrays.toString(), a classe StringJoiner, o método Collections.join() e o método Files.lines(). É necessário entender as nuances de cada método e usá-lo de forma apropriada para obter o resultado desejado.
