String Java

Tutoriais

Java

A classe Java String é uma das classes mais amplamente utilizadas. A classe Java String é definida no pacote java.lang.

Java String

Basicamente, uma string é uma sequência de caracteres, mas não é um tipo primitivo.
Ao criar uma string em Java, na verdade, é criado um objeto do tipo String.
String é um objeto imutável, o que significa que não pode ser alterado depois de ser criado.
String é a única classe onde a sobrecarga de operadores é suportada em Java. Podemos concatenar duas strings usando o operador +. Por exemplo, "a" + "b" = "ab".
O Java fornece duas classes úteis para manipulação de strings – StringBuffer e StringBuilder.

Vamos continuar e aprender mais sobre a classe Java String.

Diferentes Maneiras de Criar uma String

Existem muitas maneiras de criar um objeto string em Java, algumas das mais populares são apresentadas abaixo.

Usando literal de string

Esta é a forma mais comum de criar uma string. Neste caso, um literal de string é envolto por aspas duplas.
```
String str = "abc";
```
Ao criarmos uma String usando aspas duplas, a JVM procura no pool de Strings para verificar se alguma outra String está armazenada com o mesmo valor. Se encontrada, ela simplesmente retorna a referência para esse objeto String; caso contrário, cria um novo objeto String com o valor fornecido e o armazena no pool de Strings.
Usando a nova palavra-chave

Podemos criar um objeto String usando o operador new, assim como qualquer classe Java normal. Existem vários construtores disponíveis na classe String para obter uma String a partir de um array de caracteres, array de bytes, StringBuffer e StringBuilder.
```
String str  =  new String("abc");
char[] a = {'a', 'b', 'c'};
String str2  =  new String(a);
```

A classe String fornece os métodos equals() e equalsIgnoreCase() para comparar duas strings. Esses métodos comparam o valor da string para verificar se duas strings são iguais ou não. Eles retornam true se as duas strings forem iguais e false caso contrário.

package com.journaldev.string.examples;

/**
 * Java String Example
 * 
 * @author pankaj
 *
 */
public class StringEqualExample {

	public static void main(String[] args) {
		//criando dois objetos de string
		String s1 = "abc";
		String s2 = "abc";
		String s3 = "def";
		String s4 = "ABC";
		
		System.out.println(s1.equals(s2));//true
		System.out.println(s2.equals(s3));//false
		
		System.out.println(s1.equals(s4));//false;
		System.out.println(s1.equalsIgnoreCase(s4));//true
	}

}

A saída do programa acima é:

true
false
false
true

A classe String implementa a interface Comparable, que fornece os métodos compareTo() e compareToIgnoreCase() e compara duas strings lexicograficamente. Ambas as strings são convertidas em valores Unicode para comparação e retornam um valor inteiro que pode ser maior, menor ou igual a zero. Se as strings forem iguais, retorna zero; caso contrário, retorna um valor maior ou menor que zero.

package com.journaldev.examples;

/**
 * Java String compareTo Example
 * 
 * @author pankaj
 *
 */
public class StringCompareToExample {

	public static void main(String[] args) {
		
		String a1 = "abc";
		String a2 = "abc";
		String a3 = "def";
		String a4 = "ABC";
		
		System.out.println(a1.compareTo(a2));//0
		System.out.println(a2.compareTo(a3));//less than 0
		System.out.println(a1.compareTo(a4));//greater than 0
		System.out.println(a1.compareToIgnoreCase(a4));//0
	}

}

A saída do programa acima é:

Por favor, leia mais detalhes em Exemplo de compareTo da classe String.

Métodos da Classe String em Java

Vamos dar uma olhada em alguns dos métodos populares da classe String com um programa de exemplo.

split()

O método split() do String em Java é usado para dividir a string usando a expressão fornecida. Existem duas variantes do método split().

split(String regex): Este método divide a string usando a expressão regex fornecida e retorna um array de strings.
split(String regex, int limit): Este método divide a string usando a expressão regex fornecida e retorna um array de strings, mas o elemento do array é limitado pelo limite especificado. Se o limite especificado for 2, então o método retorna um array de tamanho 2.

package com.journaldev.examples;

/**
 * Exemplo de divisão de String em Java
 * 
 * @author pankaj
 *
 */
public class StringSplitExample {

	public static void main(String[] args) {
		
		String s = "a/b/c/d";
		String[] a1 = s.split("/");
		System.out.println("dividir a string usando apenas regex:");
		for (String string : a1) {
			System.out.println(string);
		}
		System.out.println("dividir a string usando regex com limite:");
		String[] a2 = s.split("/", 2);
		for (String string : a2) {
			System.out.println(string);
		}
	}

}

A saída do programa acima é:

dividir a string usando apenas regex:
a
b
c
d
dividir a string usando regex com limite:
a
b/c/d

contains(CharSequence s)

Os métodos contains() de String em Java verificam se a string contém a sequência especificada de caracteres ou não. Este método retorna true se a string contém a sequência especificada de caracteres, caso contrário, retorna false.

package com.journaldev.examples;

/**
 * Exemplo de contains() de String em Java
 * 
 * @author pankaj
 *
 */
public class StringContainsExample {

	public static void main(String[] args) {
		String s = "Olá Mundo";
		
		System.out.println(s.contains("M"));//true
		System.out.println(s.contains("X"));//false
	}

}

A saída do programa acima é:

true
false

length()

Método length() da classe String em Java retorna o comprimento da string.

package com.journaldev.examples;

/**
 * Comprimento da String em Java
 * 
 * @author pankaj
 *
 */
public class ExemploComprimentoString {

	public static void main(String[] args) {
		
		String s1 = "abc";
		String s2 = "abcdef";
		String s3 = "abcdefghi";
		
		System.out.println(s1.length());//3
		System.out.println(s2.length());//6
		System.out.println(s3.length());//9

	}

}

replace()

O método replace() em Java String é usado para substituir uma parte específica da string por outra string. Existem quatro variantes do método replace().

replace(char oldChar, char newChar): Este método substitui todas as ocorrências de oldChar por newChar na string.
replace(CharSequence target, CharSequence replacement): Este método substitui cada sequência de destino por uma sequência de substituição na string.
replaceAll(String regex, String replacement): Este método substitui todas as ocorrências de uma substring que corresponde ao regex especificado pela substituição especificada na string.
replaceFirst(String regex, String replacement): Este método substitui a primeira ocorrência de uma substring que corresponde ao regex especificado pela substituição especificada na string.

package com.journaldev.examples;

/**
 * Substituição de String em Java
 * 
 * @author pankaj
 *
 */
public class ExemploSubstituicaoString {

	public static void main(String[] args) {
		
		//replace(char oldChar,  char newChar)
		String s = "Olá Mundo";
		s = s.replace('l', 'm');
		System.out.println("Depois de Substituir l por m:");
		System.out.println(s);
		
		//replaceAll(String regex, String replacement)
		String s1 = "Olá journaldev, Olá pankaj";
		s1 = s1.replaceAll("Olá", "Oi");
		System.out.println("Depois de Substituir:");
		System.out.println(s1);
		
		//replaceFirst(String regex, String replacement) 
		String s2 = "Olá pessoal, Olá mundo";
		s2 = s2.replaceFirst("Olá", "Oi");
		System.out.println("Depois de Substituir:");
		System.out.println(s2);

	}

}

A saída do programa acima é:

Depois de Substituir l por m:
Hemmo Mundo
Depois de Substituir:
Oi journaldev, Oi pankaj
Depois de Substituir:
Oi pessoal, Olá mundo

format()

O método format() do Java String é usado para formatar a string. Existem duas variantes do método format() do Java String.

format(Locale l, String format, Object… args): Este método formata a string usando o local especificado, o formato da string e os argumentos.
format(String format, Object… args): Este método formata a string usando o formato de string e os argumentos especificados.

pacote com.journaldev.examples;

import java.util.Locale;

/**
 * Formatação de String do Java
 * 
 * @author pankaj
 *
 */
public class ExemploDeFormatoDeString {

	public static void main(String[] args) {
		
		String s = "journaldev.com";
		// %s é usado para anexar a string
		System.out.println(String.format("Este é %s", s));
		
		// usando o local como Locale.US
		System.out.println(String.format(Locale.US, "%f", 3.14));
	}
}

A saída do programa acima é:

Este é journaldev.com
3.140000

substring()

Este método retorna uma parte da string com base em índices especificados.

pacote com.journaldev.examples;

/**
 * Java String substring
 *
 */
public class StringSubStringExample {

	public static void main(String[] args) {
		
		String s = "Este é journaldev.com";
		s = s.substring(8,18);
		System.out.println(s);
	}
}

Concatenação de Strings

A concatenação de strings é uma operação muito básica em Java. As strings podem ser concatenadas usando o operador “+” ou usando o método concat().

package com.journaldev.examples;

/**
 * Java String concatenation
 * 
 * @author pankaj
 *
 */
public class StringConcatExample {

	public static void main(String[] args) {
		
		String s1 = "Hello";
		String s2 = "World";
		String s3 = s1 + s2;
		//usando o operador +
		System.out.println("Using + operator: ");
		System.out.println(s3);
		
		//usando o método concat
		System.out.println("Using concat method: ");
		System.out.println(s1.concat(s2));

	}

}

A saída do programa acima é:

Using + operator: 
HelloWorld
Using concat method: 
HelloWorld

Verifique este post para mais informações sobre Concatenação de Strings em Java.

Pool de Strings em Java

A gestão de memória é o aspecto mais importante de qualquer linguagem de programação. A gestão de memória no caso de strings em Java é um pouco diferente de qualquer outra classe. Para tornar o Java mais eficiente em termos de memória, a JVM introduziu uma área de memória especial para strings chamada de Pool de Constantes de String. Quando criamos uma string literal, ele verifica se já existe uma string idêntica no pool de strings ou não. Se estiver presente, ele retornará a referência da string existente no pool de strings. Vamos dar uma olhada no programa de exemplo abaixo.

package com.journaldev.examples;

/**
 * Java String Pool Example
 * 
 */
public class StringPoolExample {

	public static void main(String[] args) {
		
		String a = "abc";
		String b = "abc";
		String c = "def";
		
		//mesma referência
		if (a==b) {
			System.out.println("Both string refer to the same object");
		}
		
		//referência diferente
		if (a==c) {
			System.out.println("Both strings refer to the same object");
		}else {
			System.out.println("Both strings refer to the different object");
		}

	}

}

O resultado do programa acima é:

Both string refer to the same object
Both strings refer to the different object

Confira este post para mais informações sobre Java String Pool.

Método intern() de String

Ao criarmos uma string usando uma literal de string, ela será criada no pool de strings. Mas e se criarmos uma string usando a palavra-chave ‘new’ com o mesmo valor que já existe no pool de strings? Podemos mover a string da memória heap para o pool de strings? Para isso, o método intern() é usado e ele retorna uma representação canônica do objeto string. Quando chamamos o método intern() em um objeto string criado usando a palavra-chave ‘new’, ele verifica se já existe uma string com o mesmo valor no pool. Se sim, retorna a referência desse objeto string do pool. Se não, cria uma nova string com o mesmo conteúdo no pool e retorna a referência.

package com.journaldev.examples;

/**
 * Java String intern
 * 
 * @author pankaj
 *
 */
public class StringInternExample {

	public static void main(String[] args) {
		
		String s1 = "pankaj";
		String s2 = "pankaj";
		String s3 = new String("pankaj");
		
		System.out.println(s1==s2);//true
		System.out.println(s2==s3);//false
		
		String s4 = s3.intern();
		System.out.println(s1==s4);//true

	}

}

Confira esta postagem para aprender mais sobre o método intern de String em Java.

Benefícios da Imutabilidade de String

Alguns dos benefícios de String ser uma classe imutável são:

Pool de Constantes de String, o que economiza memória.
Segurança, pois não pode ser alterada.
Segura para threads.
Segurança no carregamento de classe.

Confira esta postagem para mais informações sobre Benefícios da Imutabilidade de String.

Método join() de String em Java 8

A new static method join() has been added in String class in Java 8. This method returns a new String composed of copies of the CharSequence elements joined together with a copy of the specified delimiter. Let’s look at an example to understand it easily.

List<String> words = Arrays.asList(new String[]{"Hello", "World", "2019"});
String msg = String.join(" ", words);
System.out.println(msg);

Saída: Hello World 2019

Novos Métodos de String em Java 9

Foram adicionados dois métodos na classe String na versão Java 9. Eles são – codePoints() e chars(). Ambos esses métodos retornam um objeto IntStream no qual podemos realizar algumas operações. Vamos dar uma rápida olhada nesses métodos.

String s = "abc";

s.codePoints().forEach(x -> System.out.println(x));

s.chars().forEach(x -> System.out.println(x));

Saída:

Novos Métodos da Classe String em Java 11

Há muitos novos métodos adicionados na classe String na versão Java 11.

isBlank() – retorna verdadeiro se a string estiver vazia ou contiver apenas espaços em branco, caso contrário, falso.
lines() – retorna um fluxo de linhas extraídas desta string, separadas por terminadores de linha.
strip(), stripLeading(), stripTrailing() – para remover espaços em branco no início e no final da string.
repeat() – retorna uma string cujo valor é a concatenação desta string repetida um determinado número de vezes.

Vamos ver um exemplo de programa para esses métodos.

package com.journaldev.strings;

import java.util.List;
import java.util.stream.Collectors;

/**
 * JDK 11 New Functions in String class
 * 
 * @author pankaj
 *
 */
public class JDK11StringFunctions {

	public static void main(String[] args) {
		// isBlank()
		String s = "abc";
		System.out.println(s.isBlank());
		s = "";
		System.out.println(s.isBlank());

		// lines()
		String s1 = "Hi\nHello\rHowdy";
		System.out.println(s1);
		List lines = s1.lines().collect(Collectors.toList());
		System.out.println(lines);

		// strip(), stripLeading(), stripTrailing()
		String s2 = "  Java,  \tPython\t ";
		System.out.println("#" + s2 + "#");
		System.out.println("#" + s2.strip() + "#");
		System.out.println("#" + s2.stripLeading() + "#");
		System.out.println("#" + s2.stripTrailing() + "#");

		// repeat()
		String s3 = "Hello\n";
		System.out.println(s3.repeat(3));
		s3 = "Co";
		System.out.println(s3.repeat(2));

	}

}

Saída:

false
true
Hi
Hello
Howdy
[Hi, Hello, Howdy]
#  Java,  	Python	 #
#Java,  	Python#
#Java,  	Python	 #
#  Java,  	Python#
Hello
Hello
Hello

CoCo

Isso é tudo sobre a classe String em Java, seus métodos e exemplos de manipulação de String.

Você pode conferir mais exemplos de String em nosso Repositório no GitHub.

Referência: Documentação da API

Source:
https://www.digitalocean.com/community/tutorials/java-string

Usando literal de string

Usando a nova palavra-chave

split()

contains(CharSequence s)

length()

replace()

format()

substring()