Subcadena en Java

Las acciones más populares en String en Java son la concatenación, obtener un carácter por índice y obtener una subcadena. En este artículo, le informaremos sobre el método de subcadena de Java.

¿Qué es la subcadena de Java?

Java Substring en general es una secuencia contigua de caracteres dentro de String. Podría ser una parte de la Cadena o toda la Cadena también. ¿Qué es una subcadena en Java? Este lenguaje tiene un método substring() , o más bien dos métodos, gracias a la sobrecarga de métodos de Java. Puede usarlos para obtener una subcadena en el programa Java. El primer método de subcadena de Java es String substring(firstIndex) y el segundo es String substring (firstIndex, lastIndex) .

Cómo usar subcadena en Java

La respuesta es simple: simplemente use la subcadena. El método Java substring() devuelve una parte de la cadena. Hay dos métodos que puede utilizar para esto: Tareas muy populares que te ayudan a entender

• Cómo obtener una subcadena en Java
• Cómo encontrar todas las subcadenas de una cadena dada
• Cómo encontrar la subcadena común más larga

Cómo obtener una subcadena en Java (particular)

Este primer ejemplo de subcadena de Java es bastante fácil. Tienes una cadena y necesitas encontrar una subcadena "CodeGym" en ella. Ya sabes cómo obtener una subcadena en Java. Así que aquí está la solución de este problema en particular:

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

   }
}

El resultado es: CodeGym El proceso terminó con el código de salida 0 Cómo encontrar todas las subcadenas de una cadena dada Aquí tenemos la forma más sencilla de encontrar todas las subcadenas de una Cadena dada.

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

El resultado es: C Co Cod Code CodeG CodeGy CodeGym o od ode odeG odeGy odeGym d de deG deGy deGym e eG eGy eGym G Gy Gym y ym m Proceso terminado con el código de salida 0 Cómo encontrar la subcadena común más larga El problema de la subcadena común más larga es una de las tareas más populares en informática. Puede encontrarlo en su entrevista con Junior Developer con una probabilidad bastante alta. De todos modos, intenta resolverlo, es un ejercicio muy útil para un programador principiante. El problema de la subcadena común más larga significa encontrar la cadena más larga (o algunas de ellas) que es una subcadena (o son subcadenas) de dos o más cadenas. Por ejemplo, tienes dos cadenas.

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

El resultado debe ser: eGym Por lo tanto, debe escribir "primero" y "segundo". Imprime la subcadena común más larga. Si dos o más subcadenas tienen el mismo valor para la subcadena común más larga, imprima cualquiera de ellas. Le recomendamos encarecidamente que intente resolver este problema usted mismo y solo después de eso, consulte el código a continuación.

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

El resultado es: La subcadena común más larga = eGym

¿Cómo funciona la subcadena en Java?

En JDK 7 y versiones posteriores, substring() ya no cuenta la cantidad de caracteres en la matriz de caracteres que crea, como lo hacía en versiones anteriores a JDK 6 inclusive, sino que simplemente crea una nueva matriz en la memoria (montón) y hace referencia a ella. . Aquí hay un ejemplo:

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

Entonces, en JDK 7 y versiones posteriores, los objetos y y z creados como resultado del método substring() aplicado al objeto x se referirán a dos matrices recién creadas (en el montón): {d,e, G, y} para y y {C, o} para z . En la versión JDK 7 + de la subcadena del método, estas dos nuevas líneas (es decir, dos nuevas matrices de caracteres) se almacenarán en la memoria junto con la cadena original myLongString ({ C, o, d, e, G, y, m, i, s, t, h, e, b,e,s,t} en forma de matriz) .

Versión JDK 6 de subcadena

Incluso hoy en día, en algunos proyectos grandes, es posible que encuentre una base de código heredada del JDK 6 veces. En el método JDK 6, substring() funciona de manera diferente. Como probablemente sepa, String es una clase inmutable y, para obtener la subcadena, Java usó esta inmutabilidad anteriormente en JDK 6. El objeto de tipo String dentro es solo una matriz de caracteres, o más bien, contiene una matriz de caracteres. En el momento de JDK 6, se almacenaron allí dos variables más: el número del primer carácter en la matriz de caracteres y su cantidad. Por lo tanto, en JDK 6, String tenía tres campos de valor char [] (matriz de caracteres), int offset (índice del primer carácter de la matriz) e int count(el número de caracteres en la matriz). Cuando se crea una subcadena en JDK 6, la matriz de caracteres no se copia en el nuevo objeto String . En lugar de esto, ambos Objetos almacenan una referencia a la misma Matriz de Caracteres. Sin embargo, el segundo Objeto almacena dos variables más, el primer símbolo de la subcadena y el segundo es sobre cuántos símbolos hay en la subcadena. El método JDK 6 fue sustituido debido a un problema de pérdida de memoria. ¿Qué significa? Supongamos que tenemos una cadena xy creamos un par de subcadenas usando subcadena.

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

Ahora tenemos un objeto x almacenado en un área especial de la memoria llamada heap, y dos objetos y y z que hacen referencia al mismo objeto x . Solo x se refiere a los elementos del segundo al sexto, y z se refiere a los elementos x del cero al tercero. ¿Qué sucede si el objeto original x ya se usó y se dejó sin ninguna referencia? En un programa, todos los demás objetos funcionan solo con y y z . En este caso el recolector de basura puede destruir el objeto x, mientras que la matriz de memoria permanece, y es utilizada por y y z. Ocurre la fuga de memoria. Por lo tanto, el método más nuevo, JDK 7 y versiones posteriores, es bastante costoso en términos de uso de memoria. Sin embargo, le permite evitar la pérdida de memoria. Además, el nuevo método funciona más rápido, ya que no tiene que calcular la cantidad de caracteres. Para reforzar lo que aprendió, le sugerimos que vea una lección en video de nuestro Curso de Java