Substring em Java

As ações mais populares em String em Java são concatenação, obtendo um caractere por índice e obtendo uma substring. Neste artigo, falaremos sobre o método Java substring.

O que é Java Substring?

Java Substring em geral é uma sequência contígua de caracteres dentro da String. Pode ser uma parte da String ou a String inteira também. O que é substring em Java? Essa linguagem possui um método substring() , ou melhor, dois métodos, graças à sobrecarga do método Java. Você pode usá-los para obter substring no programa Java. O primeiro método de substring Java é String substring(firstIndex) e o segundo é String substring (firstIndex, lastIndex) .

Como usar substring em Java

A resposta é simples: basta usar a substring. O método Java substring() retorna uma parte da string. Existem dois métodos que você pode usar para isso: Tarefas muito populares que ajudam você a entender

• Como obter uma substring em Java
• Como encontrar todas as substrings de uma determinada string
• Como encontrar a substring comum mais longa

Como obter uma substring em Java (particular)

Este primeiro exemplo de substring Java é bem fácil. Você tem uma String e precisa encontrar uma substring "CodeGym" nela. Você já sabe como obter uma substring em Java. Então, aqui está a solução deste problema específico:

import java.io.IOException;

public class Main {

   public static void main(String[] args) throws IOException {

       String s1 = "the best Java Core course is CourseCodeGym.  End of story";
       String myTarget = "CodeGym";
       int index1 = s1.indexOf(myTarget);
      
       int index2 = index1 + myTarget.length();
       System.out.println(s1.substring(index1, index2));

   }
}

A saída é: CodeGym Processo finalizado com código de saída 0 Como encontrar todas as substrings de uma determinada string Aqui temos a maneira mais simples de encontrar todas as substrings de uma determinada String.

import java.io.IOException;
public class Main {
   public static void main(String[] args) throws IOException {
       String myTarget = "CodeGym";
       for (int i = 0; i < myTarget.length(); i++) {
           for (int j = i + 1; j <= myTarget.length(); j++) {
               System.out.println(myTarget.substring(i, j));
           }
       }    
   }
}

A saída é: C Co Cod Code CodeG CodeGy CodeGym o ode odeG odeGy odeGym d de deG deGy deGym e eG eGy eGym G Gy Gym y ym m Processo finalizado com o código de saída 0 Como encontrar a substring comum mais longa O problema da substring comum mais longa é uma das tarefas mais populares na ciência da computação. Você pode encontrá-lo em sua entrevista de desenvolvedor júnior com uma probabilidade bastante alta. De qualquer forma, tente resolvê-lo, é um exercício muito útil para um programador iniciante. O problema da substring comum mais longa significa encontrar a string mais longa (ou algumas delas) que é uma substring (ou são substrings) de duas ou mais strings. Por exemplo, você tem duas strings

String first = "CodeGym" 
String second = "SomeGym"

A saída deve ser: eGym Então, você tem que colocar as strings "first" e "second". Imprima a substring comum mais longa. Se duas ou mais substrings tiverem o mesmo valor para a substring comum mais longa, imprima qualquer uma delas. Recomendamos enfaticamente que você tente resolver esse problema sozinho e somente depois dê uma olhada no código abaixo.

public class SubStringTest {

   //  in this method we are looking for the Longest common substring of
   // first String with length = m  and the second String with length = n
   public static String longestCS(String first, String second, int m, int n) {
       // the maximal length
       int maxLength = 0;
       // the last index of the longest common substring
       int endIndex = m;

       // array stores the length of substring
       int[][] keeper = new int[m + 1][n + 1];

       for (int i = 1; i <= m; i++) {
           for (int j = 1; j <= n; j++) {
               // check if current characters of first and second strings match
               if (first.charAt(i - 1) == second.charAt(j - 1)) {
                   keeper[i][j] = keeper[i - 1][j - 1] + 1;
                  
                   if (keeper[i][j] > maxLength) {
                       maxLength = keeper[i][j];
                       endIndex = i;
                   }
               }
           }
       }
       return first.substring(endIndex - maxLength, endIndex);
   }


   public static void main(String[] args) {
       String first = "CodeGym";
       String second = "SomeGym";
       int m = first.length(), n = second.length();
       System.out.println("The longest common substring = " + longestCS(first, second, m, n));
   }
}

A saída é: A substring comum mais longa = eGym

Como funciona a substring em Java

No JDK 7 e versões mais recentes, substring() não conta mais o número de caracteres no array de caracteres que ele cria, como fazia nas versões anteriores ao JDK 6 inclusive, mas simplesmente cria um novo array na memória (heap) e se refere a ele . Aqui está um exemplo:

String x = "CodeGymIsTheBest";
String y = x.substring (2,6);
String z = x.substring (0,3);

Portanto, no JDK 7 e posterior, os objetos y e z criados como resultado do método substring() aplicado ao objeto x se referirão a dois arrays recém-criados (no heap) - {d,e, G, y} para y e {C, o} para z . Na versão JDK 7 + do método substring, essas duas novas linhas (ou seja, dois novos arrays de caracteres) serão armazenadas na memória junto com a string original myLongString ({ C, o, d, e, G, y, m, i, s, t, h, e, b,e,s,t} na forma de uma matriz) .

Versão JDK 6 da substring

Ainda hoje, em alguns grandes projetos, você pode encontrar a base de código herdada do JDK 6 vezes. No JDK 6, o método substring() funciona de maneira diferente. Como você provavelmente sabe, String é uma classe imutável e para obter a substring Java usou essa imutabilidade anteriormente no JDK 6. O Object do tipo String dentro dele é apenas um array de caracteres, ou melhor, contém um array de caracteres. Na época do JDK 6, mais duas variáveis ​​eram armazenadas lá: o número do primeiro caractere na matriz de caracteres e sua quantidade. Assim, no JDK 6, String tinha três campos de char value [] (array de caracteres), int offset (índice do primeiro caractere no array) e int count(o número de caracteres na matriz). Quando uma substring é criada no JDK 6, o array de caracteres não é copiado para o novo objeto String . Em vez disso, ambos os Objetos armazenam uma referência ao mesmo Array de Caracteres. No entanto, o segundo objeto armazena mais duas variáveis, o primeiro símbolo da substring e o segundo é sobre quantos símbolos existem na substring. O método JDK 6 foi substituído devido ao problema de vazamento de memória. O que isso significa? Vamos supor que temos uma string xe criamos algumas substrings usando substring.

String x = "CodeGymIsTheBest";
String y = x.substring (2,6);
String z = x.substring (0,3);

Agora temos um objeto x armazenado em uma área especial da memória chamada heap, e dois objetos y e z referentes ao mesmo objeto x . Apenas x refere-se aos elementos do segundo ao sexto, e z refere-se aos elementos x de zero ao terceiro. E se o objeto original x já tiver sido usado e deixado sem nenhuma referência a ele? Em um programa, todos os outros objetos funcionam apenas com y e z . Neste caso o coletor de lixo pode destruir o objeto x, enquanto a matriz de memória permanece e é usada por y e z. O vazamento de memória acontece. Portanto, o método mais recente, JDK 7 e versões posteriores, é bastante caro em termos de uso de memória. No entanto, permite evitar o vazamento de memória. Além disso, o novo método funciona mais rápido, pois não precisa calcular o número de caracteres. Para reforçar o que você aprendeu, sugerimos que você assista a uma vídeo aula do nosso Curso de Java