Subtekenreeks in Java

De meest populaire acties op String in Java zijn aaneenschakeling, een teken per index ophalen en een substring ophalen. In dit artikel gaan we u vertellen over de Java-substring-methode.

Wat is Java-subtekenreeks?

Java-substring is in het algemeen een aaneengesloten reeks tekens binnen de string. Het kan ook een deel van de string of de hele string zijn. Wat is subtekenreeks in Java? Deze taal heeft een substring() -methode, of liever twee methoden, dankzij overbelasting van de Java-methode. U kunt ze gebruiken om een ​​substring in het Java-programma te krijgen. De eerste Java-substringmethode is String substring(firstIndex) en de tweede is String substring (firstIndex, lastIndex) .

Subtekenreeks gebruiken in Java

Het antwoord is simpel: gebruik gewoon de substring. De Java- methode substring() retourneert een deel van de tekenreeks. Er zijn twee methodes die je hiervoor kunt gebruiken: Zeer populaire taken die u helpen te begrijpen

• Hoe een substring in Java te krijgen
• Hoe alle substrings van een bepaalde string te vinden
• Hoe de langste gemeenschappelijke subtekenreeks te vinden

Hoe een substring in Java te krijgen (in het bijzonder)

Dit eerste voorbeeld van een Java-substring is vrij eenvoudig. Je hebt een String en je moet er een substring "CodeGym" in vinden. U weet al hoe u een substring in Java kunt krijgen. Dus hier is de oplossing van dit specifieke probleem:

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

   }
}

De uitvoer is: CodeGym Proces beëindigd met afsluitcode 0 Hoe alle substrings van een bepaalde string te vinden Hier hebben we de eenvoudigste manier om alle substrings van een bepaalde string te vinden.

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

De uitvoer is: 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 Proces voltooid met exitcode 0 Hoe de langste gemeenschappelijke substring te vinden Het langste gemeenschappelijke substring-probleem is een van de meest populaire taken in de informatica. Je kunt het met een vrij grote waarschijnlijkheid ontmoeten tijdens je Junior Developer-interview. Hoe dan ook, probeer het op te lossen, het is een zeer nuttige oefening voor een beginnende programmeur. Het langste gemeenschappelijke subtekenreeksprobleem betekent het vinden van de langste tekenreeks (of een paar daarvan) die een subtekenreeks is (of subtekenreeksen zijn) van twee of meer tekenreeksen. Je hebt bijvoorbeeld twee strings

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

Uitvoer zou moeten zijn: eGym Dus je moet de strings "eerste" en "tweede" gebruiken. Druk de langste gemeenschappelijke subtekenreeks af. Als twee of meer subtekenreeksen dezelfde waarde hebben voor de langste gemeenschappelijke subtekenreeks, drukt u ze af. We raden u ten zeerste aan om te proberen dit probleem zelf op te lossen en pas daarna de onderstaande code te bekijken.

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

De uitvoer is: De langste gemeenschappelijke substring = eGym

Hoe werkt substring in Java

In JDK 7 en nieuwere versies telt substring() niet langer het aantal tekens in de tekenarray die het maakt, zoals in eerdere versies dan JDK 6, maar maakt gewoon een nieuwe array in het geheugen (heap) aan en verwijst ernaar . Hier is een voorbeeld:

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

Dus in JDK 7 en hoger verwijzen objecten y en z die zijn gemaakt als resultaat van de methode substring() toegepast op object x naar twee nieuw gemaakte arrays (op de heap) - {d,e, G, y} voor y en {C, o} voor z . In JDK 7 + versie van de methode substring worden deze twee nieuwe regels (dat wil zeggen twee nieuwe karakterarrays) in het geheugen opgeslagen samen met de originele string myLongString ({ C, o, d, e, G, y, m, i, s, t, h, e, b,e,s,t} in de vorm van een array) .

JDK 6-versie van subtekenreeks

Zelfs vandaag de dag kunt u bij sommige grote projecten 6 keer de oude codebasis van de JDK tegenkomen. In JDK 6 werkt methode substring() op een andere manier. Zoals u waarschijnlijk weet, is String een onveranderlijke klasse en om de substring te krijgen gebruikte Java deze onveranderlijkheid eerder in JDK 6. Het object van het type String binnenin is slechts een reeks tekens, of beter gezegd, bevat een reeks tekens. Ten tijde van JDK 6 waren daar nog twee variabelen opgeslagen: het nummer van het eerste teken in de tekenarray en hun aantal. In JDK 6 had String dus drie velden met char value [] (character array), int offset (index van het eerste karakter in de array) en int count(het aantal tekens in de array). Wanneer een substring wordt gemaakt in JDK 6, wordt de reeks tekens niet gekopieerd naar het nieuwe String- object. In plaats daarvan slaan beide objecten een verwijzing op naar dezelfde tekenarray. Het tweede object slaat echter nog twee variabelen op, het eerste symbool van een substring en het tweede gaat over het aantal symbolen in de substring. De JDK 6-methode is vervangen vanwege een geheugenlekprobleem. Wat betekent het? Laten we aannemen dat we een string hebben xen we maken een aantal substrings met behulp van substring.

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

Nu hebben we een object x opgeslagen in een speciaal geheugengebied dat de heap wordt genoemd, en twee objecten y en z verwijzen naar hetzelfde object x . Alleen x verwijst naar de elementen van de tweede tot de zesde, en z verwijst naar de x- elementen van nul tot derde. Wat als het originele object x al is gebruikt en er geen referenties op staan? In een programma werken alle andere objecten alleen met y en z . In dit geval mag de vuilnisman het object x vernietigen, terwijl de geheugenarray blijft en wordt gebruikt door y en z. Het geheugenlek gebeurt. Dus de nieuwere, JDK 7 en latere versie, methode is behoorlijk duur in termen van geheugengebruik. Hiermee kunt u echter het geheugenlek voorkomen. Bovendien werkt de nieuwe methode sneller, omdat het aantal tekens niet hoeft te worden berekend. Om te versterken wat je hebt geleerd, raden we je aan een videoles van onze Java-cursus te bekijken