Substring in Java

Die gängigsten Aktionen für Strings in Java sind Verkettung, Abrufen eines Zeichens nach Index und Abrufen eines Teilstrings (Substrings). In diesem Artikel werden wir dir die Java substring-Methode erklären.

Was ist ein Substring in Java?

Ein Substring ist im Allgemeinen eine zusammenhängende Folge von Zeichen innerhalb eines Strings. Es kann ein Teil des Strings oder auch der ganze String sein. Was ist ein Substring in Java? Diese Sprache hat eine substring()-Methode, oder besser gesagt zwei Methoden, dank der Java-Methodenüberladung. Du kannst sie verwenden, um Teilstrings in Java-Programmen zu erhalten. Die erste Java-Substring-Methode ist String substring(firstIndex) und die zweite ist String substring (firstIndex, lastIndex).

Wie man substring in Java verwendet

Die Antwort ist einfach: Verwende einfach substring. Die Java-Methode substring() gibt einen Teil des Strings zurück. Es gibt zwei Methoden, die du dafür verwenden kannst: Typische Aufgaben, die dir helfen zu verstehen:

• Wie man einen Teilstring in Java erhält
• Wie man alle Teilstrings eines gegebenen Strings findet
• Wie man den längsten gemeinsamen Teilstring findet

Wie man einen Teilstring in Java erhält

Dieses erste Beispiel für die Java-substring-Methode ist ziemlich einfach. Du hast einen String und musst den Teilstring „CodeGym“ darin finden. Du weißt bereits, wie man in Java einen Teilstring erhält. Hier ist also die Lösung für dieses spezielle Problem:

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

   }
}

Die Ausgabe ist:

Wie finde ich alle Teilstrings eines gegebenen Strings

Hier haben wir die einfachste Möglichkeit, alle Teilstrings eines gegebenen Strings zu finden.

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

Die Ausgabe ist:

Wie man den längste gemeinsamen Teilstring findet

Das Problem des längsten gemeinsamen Teilstrings ist eine der beliebtesten Aufgaben in der Informatik. Mit ziemlich hoher Wahrscheinlichkeit kannst du in deinem Junior-Developer-Interview darauf treffen. Wie auch immer, versuche diese Aufgabe zu lösen, es ist eine sehr nützliche Übung für einen Programmieranfänger. Das Problem des längsten gemeinsamen Teilstrings bedeutet, den längsten String (oder einige von ihnen) zu finden, der ein Teilstring (bzw. die Teilstrings) von zwei oder mehr Strings ist (sind). Du hast zum Beispiel zwei Strings

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

Die Ausgabe sollte sein: Du hast also die Strings "first" und "second“. Gib nun den längsten gemeinsamen Teilstring aus. Wenn zwei oder mehr Teilstrings den gleichen Wert für den längsten gemeinsamen Teilstring haben, wird einer von ihnen ausgegeben. Wir empfehlen dir dringend, dieses Problem selbst zu lösen und erst danach in den unten stehenden Code zu schauen.

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

Die Ausgabe ist:

Wie funktioniert substring in Java?

In JDK 7 und neueren Versionen zählt substring() nicht mehr die Anzahl der Zeichen in dem von ihm erstellten Zeichenarray, wie es in Versionen bis einschließlich JDK 6 der Fall war, sondern erstellt einfach ein neues Array im Speicher (Heap) und verweist auf dieses. Hier ist ein Beispiel:

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

Ab JDK 7 verweisen die Objekte y und z, die durch die Anwendung der substring()-Methode auf das Objekt x erstellt wurden, auf zwei neu erstellte Arrays (auf dem Heap) – {d, e, G, y} für y und {C, o} für z. Ab der JDK-7-Version der Methode substring werden diese beiden neuen Zeilen (d. h. zwei neue Zeichenarrays) zusammen mit dem ursprünglichen String myLongString ({C, o, d, e, G, y, m, i, s, t, h, e, b, e, s, t} in Form eines Arrays) im Speicher abgelegt.

JDK-6-Version von substring

Auch heute noch kann es vorkommen, dass du bei einigen großen Projekten auf alten Code aus dem JDK 6 triffst. Im JDK 6 funktioniert die Methode substring() auf eine andere Weise. Wie du wahrscheinlich weißt, ist String eine unveränderliche Klasse und um den Teilstring zu erhalten, hat Java diese Unveränderlichkeit früher im JDK 6 genutzt. Das darin enthaltene Objekt vom Typ String ist einfach ein Array von Zeichen, oder besser gesagt, es enthält ein Array von Zeichen. Zur Zeit des JDK 6 wurden dort zwei weitere Variablen gespeichert: die Nummer des ersten Zeichens im Zeichenarray und ihre Anzahl. So hatte String im JDK 6 die drei Felder char value [] (Zeichenarray), int offset (Index des ersten Zeichens im Array) und int count (die Anzahl der Zeichen im Array). Wenn ein Teilstring im JDK 6 erstellt wird, wird das Array der Zeichen nicht in das neue String-Objekt kopiert. Stattdessen speichern beide Objekte einen Verweis auf dasselbe Zeichenarray. Das zweite Objekt speichert jedoch zwei weitere Variablen, das erste Zeichen des Teilstrings und die zweite Variable gibt an, wie viele Zeichen im Teilstring enthalten sind. Die JDK-6-Methode wurde aufgrund eines Speicherleckproblems ersetzt. Was bedeutet das? Nehmen wir an, wir haben einen String x und erstellen mit substring ein paar Teilstrings.

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

Jetzt haben wir ein Objekt x, das in einem speziellen Bereich des Speichers, dem Heap, gespeichert ist, und zwei Objekte y und z, die sich auf das gleiche Objekt x beziehen. Nur x bezieht sich auf die Elemente von der zweiten bis zur sechsten Stelle, und z bezieht sich auf die x-Elemente von null bis zur dritten Stelle. Was ist, wenn das ursprüngliche Objekt x bereits verwendet wurde und keine Referenzen mehr darauf vorhanden sind? In einem Programm arbeiten alle anderen Objekte nur mit y und z. In diesem Fall kann der Garbage Collector das Objekt x zerstören, während das Speicherarray bestehen bleibt und von y und z verwendet wird. Das Speicherleck tritt auf. Die neuere Methode (JDK 7 und spätere Versionen) ist also ziemlich teuer, was den Speicherverbrauch angeht. Es ermöglicht dir jedoch, das Speicherleck zu verhindern. Außerdem arbeitet die neue Methode schneller, da sie die Anzahl der Zeichen nicht berechnen muss.