Classes auxiliares para trabalhar com strings em Java

1. StringTokenizeraula

E agora mais alguns cenários comuns envolvendo o trabalho com strings. Como dividir uma string em várias partes? Existem várias maneiras de fazer isso.

split()método

A primeira maneira de dividir uma string em várias partes é usar o split()método. Uma expressão regular que define uma string de delimitação especial deve ser passada como um argumento. Você aprenderá o que é uma expressão regular na missão Java Multithreading .

Exemplo:

String str = "Good news everyone!";
String[] strings = str.split("ne");
System.out.println(Arrays.toString(strings));

["Good ", "ws everyo", "!"]

Simples, mas às vezes essa abordagem é excessiva. Se houver muitos delimitadores (por exemplo, espaços, caracteres de nova linha, tabulações, pontos), será necessário construir uma expressão regular bastante complexa. É difícil de ler e, portanto, difícil de modificar.

StringTokenizeraula

Java tem uma classe especial cujo trabalho é dividir uma string em substrings.

Esta classe não usa expressões regulares: em vez disso, você simplesmente passa uma string que consiste em delimitadores. A vantagem dessa abordagem é que ela não quebra a corda inteira em pedaços de uma só vez, mas se move do começo ao fim, um passo de cada vez.

A classe tem um construtor e dois métodos importantes. Passamos ao construtor uma string que dividimos em partes e uma string composta por um conjunto de caracteres delimitadores.

String nextToken()

boolean hasMoreTokens()

Essa classe lembra de alguma forma a classe Scanner, que também possui métodos nextLine()e hasNextLine().

Você pode criar um StringTokenizerobjeto com este comando:

StringTokenizer name = new StringTokenizer(string, delimiters);

Onde stringestá a string a ser dividida em partes. E delimitersé uma string e cada caractere nela é tratado como um delimitador. Exemplo:

String str = "Good news everyone!";

StringTokenizer tokenizer = new StringTokenizer(str,"ne");
while (tokenizer.hasMoreTokens())
{
   String token = tokenizer.nextToken();
   System.out.println(token);
}

Good 
ws 
v
ryo
!

Observe que cada caractere na string passado como a segunda string para o StringTokenizerconstrutor é considerado um separador.

2. String.format()método e StringFormatterclasse

Outro método interessante da classe String é format().

Digamos que você tenha várias variáveis ​​armazenando dados. Como você os exibe na tela em uma linha? Por exemplo, temos alguns dados (coluna da esquerda) e saída desejada (coluna da direita):

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

User = {name: Amigo, age: 12 years, friend: Diego, weight: 200 kg.}

Seu código provavelmente ficará mais ou menos assim:

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + name + ", age:" + age + " years, friend: " + friend+", weight: " + weight + " kg.}");

Esse código não é muito legível. E se os nomes das variáveis ​​fossem mais longos, o código se tornaria ainda mais difícil:

class User {
    ......
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getFriends() {
        return friends;
    }

    public ExtraInformation getExtraInformation() {
        return extraInformation;
    }
}

User user = new User();

System.out.println("User = {name: " + user.getName() + ", age:" + user.getAge() + " years, friend: " + user.getFriends().get(0) + ", weight: " + user.getExtraInformation().getWeight() + " kg.}");

Não é muito legível, não é?

Mas esta é uma situação comum em programas do mundo real, então quero falar sobre uma maneira de escrever este código de forma mais simples e concisa.

String.format

A classe String tem um format()método estático: permite especificar um padrão para montar uma string com dados. A aparência geral do comando é a seguinte:

String name = String.format(pattern, parameters);

Exemplo:

String.format("Age=%d, Name=%s", age, name);

Age=12, Name=Amigo

String.format("Width=%d, Height=%d", width, height);

Width=20, Height=10

String.format("Fullname=%s", name);

Fullname=Diego

O format()primeiro parâmetro do método é uma string de formato que contém todo o texto desejado junto com caracteres especiais chamados especificadores de formato (como %de %s) nos locais onde você precisa inserir dados.

O format()método substitui esses %se %dos especificadores de formato pelos parâmetros que seguem a string de formato na lista de parâmetros. Se quisermos inserir uma string, escrevemos %s. Se quisermos inserir um número, o especificador de formato é %d. Exemplo:

String s = String.format("a=%d, b=%d, c=%d", 1, 4, 3);

Aqui está uma pequena lista de especificadores de formato que podem ser usados ​​dentro da string de formato:

%s

%d

%f

%b

%c

%t

%%

Esses especificadores indicam o tipo de dados, mas também existem especificadores que indicam a ordem dos dados. Para obter um argumento pelo seu número (a numeração começa em um), você precisa escrever " " em vez de " ". Exemplo:%1$d%d

String s = String.format("a=%3$d, b=%2$d, c=%d", 11, 12, 13);

%3$dobterá o terceiro argumento, %2$dobterá o segundo argumento e %dobterá o primeiro argumento. Os especificadores de formato %se %dreferem-se a argumentos independentemente de especificadores como %3$dou%2$s

3. Conjunto de Strings

Cada string especificada no código como uma string literal é armazenada em uma área da memória chamada StringPoolenquanto o programa está em execução. StringPool é uma tabela especial para armazenar strings (na prática, uma tabela hash). Sua finalidade é otimizar o armazenamento de strings:

Primeiro, as strings especificadas no código devem ser armazenadas em algum lugar, certo? O código consiste em comandos, mas os dados (especialmente strings grandes) devem ser armazenados na memória separadamente do código. Somente referências a objetos de string aparecem no código.

Em segundo lugar, todas as strings literais idênticas devem ser armazenadas na memória apenas uma vez. E é exatamente assim que funciona: para cada string literal, a máquina Java usa uma string do StringPool. Se essa string ainda não estiver lá, ela é adicionada; se já estiver, é usada uma referência a ela. (Quando exatamente isso acontece — ao carregar a classe ou no primeiro uso do literal — depende da implementação da JVM.)

Da mesma forma, se você atribuir o mesmo literal a várias Stringvariáveis ​​em seu código, essas variáveis ​​conterão a mesma referência. Um literal será adicionado StringPoolapenas uma vez. Em todos os outros casos, o código obterá uma referência à string já carregada no arquivo StringPool.

Aqui está mais ou menos como funciona:

String a = "Hello";
String b = "Hello";
String c = "Bye";

String[] pool = {"Hello", "Bye"};
a = pool[0];
b = pool[0];
c = pool[1];

É por isso que as variáveis a​​e birão armazenar as mesmas referências.

intern()método

E a melhor parte é que você pode adicionar programaticamente qualquer string ao arquivo StringPool. Para fazer isso, basta chamar o método Stringda variável intern().

O intern()método adicionará a string ao StringPoolse ainda não estiver lá e retornará uma referência à string no arquivo StringPool.

Se duas strings idênticas forem adicionadas ao StringPoolusando o intern()método, o método retornará a mesma referência. Isso pode ser usado para comparar strings por referência. Exemplo:

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);

false

String a = new String("Hello");
String b = new String("Hello");

String t1 = a.intern();
String t2 = b.intern();
System.out.println(a == b);
System.out.println(t1 == t2);

false
true

É improvável que você use esse método com frequência, mas as pessoas adoram perguntar sobre isso em entrevistas . Então é melhor saber do que não saber.