Delsträng i Java

De mest populära åtgärderna på String i Java är sammanlänkning, att få ett tecken för index och att få en delsträng. I den här artikeln kommer vi att berätta om Java-delsträngsmetoden.

Vad är Java Substring?

Java-delsträng i allmänhet är en sammanhängande sekvens av tecken inuti strängen. Det kan vara en del av strängen eller hela strängen också. Vad är delsträng i Java? Detta språk har en substring()- metod, eller snarare två metoder, tack vare Java-metodens överbelastning. Du kan använda dem för att få delsträng i Java-programmet. Den första Java-delsträngsmetoden är String substring(firstIndex) och den andra är String substring (firstIndex, lastIndex) .

Hur man använder delsträng i Java

Svaret är enkelt: använd bara delsträngen. Java substring() -metoden returnerar en del av strängen. Det finns två metoder du kan använda för detta: Mycket populära uppgifter som hjälper dig att förstå

• Hur man får en delsträng i Java
• Hur man hittar alla delsträngar av en given sträng
• Hur man hittar den längsta gemensamma delsträngen

Hur man får en delsträng i Java (särskilt)

Det här första Java-substrängexemplet är ganska enkelt. Du har en sträng och du måste hitta en delsträng "CodeGym" i den. Du har redan vetat hur man får en delsträng i Java. Så här är lösningen på detta specifika 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));

   }
}

Utdata är: CodeGym Processen avslutad med exit-kod 0 Hur man hittar alla delsträngar av en given sträng Här har vi det enklaste sättet att hitta alla delsträngar av en given sträng.

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

Utdata är: 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 Processen avslutad med utgångskod 0 Hur man hittar den längsta gemensamma delsträngen Det längsta vanliga substrängproblemet är en av de mest populära uppgifterna inom datavetenskap. Du kan möta det på din Junior Developer-intervju med ganska stor sannolikhet. Hur som helst, försök att lösa det, det är en mycket användbar övning för en nybörjare. Det längsta vanliga delsträngsproblemet innebär att hitta den längsta strängen (eller några av dem) som är en delsträng (eller är delsträngar) av två eller flera strängar. Du har till exempel två strängar

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

Utdata ska vara: eGym Så du måste stränga "första" och "andra". Skriv ut den längsta gemensamma delsträngen. Om två eller flera delsträngar har samma värde för den längsta gemensamma delsträngen, skriv ut någon av dem. Vi rekommenderar starkt att du försöker lösa det här problemet själv och först efter det titta på koden nedan.

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

Utdata är: Den längsta gemensamma delsträngen = eGym

Hur fungerar delsträng i Java

I JDK 7 och nyare versioner räknar substring() inte längre antalet tecken i teckenuppsättningen den skapar, som den gjorde i versioner före JDK 6 inklusive, utan skapar helt enkelt en ny matris i minnet (hög) och refererar till den . Här är ett exempel:

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

Så i JDK 7 och senare kommer objekt y och z skapade som ett resultat av substring() -metoden som tillämpas på objekt x att hänvisa till två nyskapade arrayer (på högen) - {d,e, G, y} för y och {C, o} för z . I JDK 7+ versionen av metoddelsträngen kommer dessa två nya rader (det vill säga två nya teckenuppsättningar) att lagras i minnet tillsammans med den ursprungliga strängen myLongString ({C, o, d, e, G, y, m, i, s, t, h, e, b, e, s, t} i form av en array) .

JDK 6 version av delsträng

Till och med idag på vissa stora projekt kan du träffa äldre kodbas från JDK 6 gånger. I JDK 6-metoden fungerar substring() på ett annat sätt. Som du säkert vet är String en oföränderlig klass och för att få delsträngen använde Java denna oföränderlighet tidigare i JDK 6. Objektet av typen String inuti är bara en array av tecken, eller snarare, innehåller en array av tecken. Vid tiden för JDK 6 lagrades ytterligare två variabler där: numret på det första tecknet i teckenuppsättningen och deras kvantitet. I JDK 6 hade String således tre fält med char-värde [] (teckenmatris), int offset (index för det första tecknet i matrisen) och int-antal(antal tecken i arrayen). När en delsträng skapas i JDK 6, kopieras inte arrayen av tecken till det nya String -objektet. Istället för detta lagrar båda objekten en referens till samma teckenarray. Men det andra objektet lagrar ytterligare två variabler, den första symbolen för delsträng och den andra handlar om hur många symboler som finns i delsträngen. JDK 6-metoden ersattes på grund av minnesläckageproblem. Vad betyder det? Låt oss anta att vi har en sträng xoch vi skapar ett par delsträngar med hjälp av delsträng.

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

Nu har vi ett objekt x lagrat i ett speciellt minnesområde som kallas högen, och två objekt y och z som refererar till samma objekt x . Endast x hänvisar till elementen från det andra till det sjätte, och z hänvisar till x -elementen från noll till tredje. Vad händer om det ursprungliga objektet x redan har använts och lämnats utan några referenser på det? I ett program fungerar alla andra objekt endast med y och z . I detta fall kan sopsamlaren förstöra föremålet x, medan minnesmatrisen finns kvar, och den används av y och z. Minnesläckan inträffar. Så den nyare, JDK 7 och senare version, metoden är ganska kostsam när det gäller minnesanvändning. Men det låter dig förhindra minnesläckan. Dessutom fungerar den nya metoden snabbare, eftersom den inte behöver beräkna antalet tecken. För att förstärka det du lärde dig föreslår vi att du tittar på en videolektion från vår Java-kurs