Sottostringa in Java

Le azioni più popolari su String in Java sono la concatenazione, ottenere un carattere per indice e ottenere una sottostringa. In questo articolo ti parleremo del metodo di sottostringa Java.

Cos'è la sottostringa Java?

La sottostringa Java in generale è una sequenza contigua di caratteri all'interno della stringa. Potrebbe anche essere una parte della stringa o l'intera stringa. Cos'è la sottostringa in Java? Questo linguaggio ha un metodo substring() , o meglio due metodi, grazie all'overloading dei metodi Java. Puoi usarli per ottenere una sottostringa nel programma Java. Il primo metodo di sottostringa Java è String substring(firstIndex) e il secondo è String substring (firstIndex, lastIndex) .

Come usare la sottostringa in Java

La risposta è semplice: basta usare la sottostringa. Il metodo Java substring() restituisce una parte della stringa. Ci sono due metodi che puoi usare per questo: Attività molto popolari che ti aiutano a capire

• Come ottenere una sottostringa in Java
• Come trovare tutte le sottostringhe di una data stringa
• Come trovare la sottostringa comune più lunga

Come ottenere una sottostringa in Java (particolare)

Questo primo esempio di sottostringa Java è piuttosto semplice. Hai una stringa e devi trovare una sottostringa "CodeGym" in essa. Hai già saputo come ottenere una sottostringa in Java. Quindi ecco la soluzione di questo particolare problema:

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

   }
}

L'output è: CodeGym Processo terminato con codice di uscita 0 Come trovare tutte le sottostringhe di una data stringa Qui abbiamo il modo più semplice per trovare tutte le sottostringhe di una data stringa.

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

L'output è: 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 Processo terminato con codice di uscita 0 Come trovare la sottostringa comune più lunga Il problema della sottostringa comune più lunga è uno dei compiti più popolari nell'informatica. Puoi incontrarlo durante il tuo colloquio con lo sviluppatore junior con una probabilità piuttosto alta. Ad ogni modo, prova a risolverlo, è un esercizio molto utile per un programmatore principiante. Il problema della sottostringa comune più lunga significa trovare la stringa più lunga (o alcune di esse) che è una sottostringa (o sono sottostringhe) di due o più stringhe. Ad esempio hai due stringhe

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

L'output dovrebbe essere: eGym Quindi, devi inserire le stringhe "first" e "second". Stampa la sottostringa comune più lunga. Se due o più sottostringhe hanno lo stesso valore per la sottostringa comune più lunga, stampane una qualsiasi. Ti consigliamo vivamente di provare a risolvere questo problema da solo e solo dopo esaminare il codice sottostante.

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

L'output è: La sottostringa comune più lunga = eGym

Come funziona la sottostringa in Java

In JDK 7 e versioni successive, substring() non conta più il numero di caratteri nell'array di caratteri che crea, come nelle versioni precedenti a JDK 6 incluso, ma crea semplicemente un nuovo array in memoria (heap) e fa riferimento ad esso . Ecco un esempio:

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

Quindi, in JDK 7 e versioni successive, gli oggetti y e z creati come risultato del metodo substring() applicato all'oggetto x faranno riferimento a due array appena creati (sull'heap) - {d,e, G, y} per y e {C, o} per z . Nella versione JDK 7 + della sottostringa del metodo, queste due nuove righe (ovvero due nuovi array di caratteri) verranno archiviate in memoria insieme alla stringa originale myLongString ({ C, o, d, e, G, y, m, i, s, t, h, e, b,e,s,t} sotto forma di un array) .

Versione JDK 6 della sottostringa

Ancora oggi su alcuni grandi progetti potresti incontrare la base di codice legacy del JDK 6 volte. Nel metodo JDK 6 substring() funziona in modo diverso. Come probabilmente saprai, String è una classe immutabile e per ottenere la sottostringa Java ha utilizzato questa immutabilità in precedenza in JDK 6. L'oggetto di tipo String all'interno è solo un array di caratteri, o meglio, contiene un array di caratteri. Al momento del JDK 6, vi erano memorizzate altre due variabili: il numero del primo carattere nell'array di caratteri e la loro quantità. Pertanto, in JDK 6, String aveva tre campi di char value [] (array di caratteri), int offset (indice del primo carattere nell'array) e int count(il numero di caratteri nell'array). Quando viene creata una sottostringa in JDK 6, l'array di caratteri non viene copiato nel nuovo oggetto String . Invece di questo, entrambi gli oggetti memorizzano un riferimento allo stesso array di caratteri. Tuttavia il secondo oggetto memorizza altre due variabili, il primo simbolo della sottostringa e il secondo riguarda quanti simboli ci sono nella sottostringa. Il metodo JDK 6 è stato sostituito a causa di un problema di perdita di memoria. Cosa significa? Supponiamo di avere una stringa xe creiamo un paio di sottostringhe usando substring.

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

Ora abbiamo un oggetto x memorizzato in una speciale area di memoria chiamata heap, e due oggetti y e z riferiti allo stesso oggetto x . Solo x si riferisce agli elementi dal secondo al sesto e z si riferisce agli elementi x dallo zero al terzo. Cosa succede se l'oggetto originale x è già stato utilizzato e lasciato senza alcun riferimento su di esso? In un programma tutti gli altri oggetti funzionano solo con y e z . In questo caso il Garbage Collector può distruggere l'oggetto x, mentre l'array di memoria rimane ed è usato da y e z. La perdita di memoria accade. Quindi, il metodo più recente, JDK 7 e versioni successive, è piuttosto costoso in termini di utilizzo della memoria. Tuttavia ti consente di prevenire la perdita di memoria. Inoltre, il nuovo metodo funziona più velocemente, poiché non deve calcolare il numero di caratteri. Per rafforzare ciò che hai imparato, ti suggeriamo di guardare una lezione video dal nostro corso Java