Java String

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, está-se criando um objeto do tipo String.
String é um objeto imutável, o que significa que não pode ser alterado após 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

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

Usando literal de string

Esta é a maneira mais comum de criar uma string. Neste caso, um literal de string é cercado 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 com o mesmo valor está armazenada. Se encontrada, ela simplesmente retorna a referência a 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 se não forem.

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(), os quais comparam 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() em String 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 split em String 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 uma 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()

O método length() da String Java retorna o comprimento da string.

package com.journaldev.examples;

/**
 * Comprimento da String 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() de String em Java é 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 literal alvo pelos literais de substituição na string.
replaceAll(String regex, String replacement): Este método substitui todas as ocorrências de substrings que correspondem ao regex especificado pelo replacement especificado na string.
replaceFirst(String regex, String replacement): Este método substitui a primeira ocorrência de uma substring que corresponde ao regex especificado pelo replacement especificado 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);

	}

}

O output 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, formato de string e argumentos.
format(String format, Object… args): Este método formata a string usando o formato de string e argumentos especificados.

package com.journaldev.examples;

import java.util.Locale;

/**
 * Java String format
 * 
 * @author pankaj
 *
 */
public class StringFormatExample {

    public static void main(String[] args) {
        
        String s = "journaldev.com";
        // %s is used to append the string
        System.out.println(String.format("This is %s", s));
        
        // usando o local como Locale.US
        System.out.println(String.format(Locale.US, "%f", 3.14));
    }
}

A saída do programa acima é:

This is journaldev.com
3.140000

substring()

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

package com.journaldev.examples;

/**
 * Exemplo de Substring em Java
 *
 */
public class ExemploSubstring {

    public static void main(String[] args) {
        
        String s = "Isso é 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

Confira este post para obter 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 a string chamada Pool de Constantes de String. Quando criamos uma string literal, verifica-se se já existe uma string idêntica na pool de strings ou não. Se estiver lá, ele retornará a referência da string existente na 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 o Pool de Strings do Java. .

Método intern() de String

Quando criamos uma string usando uma string literal, ela será criada na pool de strings, mas e se criarmos uma string usando a nova palavra-chave com o mesmo valor que existe na pool de strings? Podemos mover a String da memória heap para a pool de strings? Para isso, o método intern() é usado e ele retorna uma representação canônica do objeto de string. Quando chamamos o método intern() no objeto de string que é criado usando a nova palavra-chave, ele verifica se já existe uma String com o mesmo valor na pool? Se sim, então retorna a referência desse objeto String da pool. Se não, então cria uma nova String com o mesmo conteúdo na 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

	}

}

Verifique esta postagem para aprender mais sobre o método intern do Java String.

Benefícios da Imutabilidade da String

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

Piscina Constante de Strings, portanto economiza memória.
Segurança, pois não pode ser alterada.
Segura para threads
Segurança no carregamento da classe

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

Java 8 String join()

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

Resultado: Olá Mundo 2019

Métodos de String do Java 9

Há dois métodos adicionados 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 olhada rápida nesses métodos.

String s = "abc";

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

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

Resultado:

Métodos Novos da Classe String em Java 11

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

isBlank() – retorna verdadeiro se a string estiver vazia ou contiver apenas pontos de código de espaço 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 iniciais e finais da string.
repeat() – retorna uma string cujo valor é a concatenação desta string repetida um número de vezes dado.

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

	}

}

Output:

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 do GitHub.

Referência: Doc de 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()