Delstreng i Java

De mest populære handlingene på String i Java er sammenkobling, å få et tegn etter indeks og å få en understreng. I denne artikkelen skal vi fortelle deg om Java-delstrengmetoden.

Hva er Java Substring?

Java Substring generelt er en sammenhengende sekvens av tegn inne i strengen. Det kan være en del av strengen eller hele strengen også. Hva er understreng i Java? Dette språket har en substring()- metode, eller rettere sagt to metoder, takket være overbelastning av Java-metoden. Du kan bruke dem til å få delstreng i Java-programmet. Den første Java-delstrengmetoden er String-substring(firstIndex) og den andre er String-substring (firstIndex, lastIndex) .

Hvordan bruke understreng i Java

Svaret er enkelt: bare bruk understrengen. Java substring()- metoden returnerer en del av strengen. Det er to metoder du kan bruke for dette: Veldig populære oppgaver som hjelper deg å forstå

• Hvordan få en delstreng i Java
• Hvordan finne alle understrenger av en gitt streng
• Hvordan finne den lengste felles understrengen

Hvordan få en delstreng i Java (spesielt)

Dette første Java-understrengeksemplet er ganske enkelt. Du har en streng og du må finne en understreng "CodeGym" i den. Du har allerede visst hvordan du får en delstreng i Java. Så her er løsningen på dette spesielle problemet:

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

   }
}

Utgangen er: CodeGym Prosess ferdig med utgangskode 0 Hvordan finne alle delstrenger til en gitt streng Her har vi den enkleste måten å finne alle delstrenger til en gitt streng.

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

Utgangen er: 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 Prosess ferdig med utgangskode 0 Hvordan finne den lengste felles understrengen Det lengste vanlige substrengproblemet er en av de mest populære oppgavene innen informatikk. Du kan møte det på ditt juniorutviklerintervju med ganske høy sannsynlighet. Uansett, prøv å løse det, det er en veldig nyttig øvelse for en nybegynner programmerer. Det lengste vanlige understrengproblemet betyr å finne den lengste strengen (eller noen få av dem) som er en understreng (eller er understrenger) av to eller flere strenger. For eksempel har du to strenger

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

Utdata skal være: eGym Så du må strenge "først" og "andre". Skriv ut den lengste felles understrengen. Hvis to eller flere understrenger har samme verdi for den lengste felles understrengen, skriv ut en av dem. Vi anbefaler deg på det sterkeste å prøve å løse dette problemet selv og først etter det se på koden nedenfor.

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

Utgangen er: Den lengste felles understrengen = eGym

Hvordan fungerer understreng i Java

I JDK 7 og nyere versjoner teller ikke substring() lenger antall tegn i tegnarrayen den oppretter, slik den gjorde i versjoner før JDK 6 inklusive, men oppretter ganske enkelt en ny matrise i minnet (heap) og refererer til den . Her er et eksempel:

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

Så i JDK 7 og senere vil objekter y og z opprettet som et resultat av substring() -metoden brukt på objekt x referere til to nyopprettede arrays (på haugen) - {d,e, G, y} for y og {C, o} for z . I JDK 7+ versjonen av metodedelstrengen vil disse to nye linjene (det vil si to nye tegnarrayer) lagres i minnet sammen med den originale strengen myLongString ({ C, o, d, e, G, y, m, i, s, t, h, e, b, e, s, t} i form av en matrise) .

JDK 6-versjon av understreng

Selv i dag på noen store prosjekter kan du møte eldre kodebase fra JDK 6 ganger. I JDK 6-metoden fungerer substring() på en annen måte. Som du sikkert vet, er String en uforanderlig klasse, og for å få delstrengen brukte Java denne uforanderligheten tidligere i JDK 6. Objektet av typen String inni er bare en rekke tegn, eller rettere sagt, inneholder en rekke tegn. På tidspunktet for JDK 6 ble ytterligere to variabler lagret der: nummeret på det første tegnet i tegnarrayen og deres mengde. I JDK 6 hadde String således tre felt med char-verdi [] (tegnmatrise), int offset (indeks for det første tegnet i matrisen) og int-antall(antall tegn i matrisen). Når en delstreng opprettes i JDK 6, kopieres ikke arrayen av tegn inn i det nye String -objektet. I stedet for dette lagrer begge objektene en referanse til samme tegnarray. Imidlertid lagrer det andre objektet ytterligere to variabler, det første symbolet for delstreng og det andre handler om hvor mange symboler som er i delstrengen. JDK 6-metoden ble erstattet på grunn av minnelekkasjeproblem. Hva betyr det? La oss anta at vi har en streng x, og vi lager et par delstrenger ved å bruke delstrenger.

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

Nå har vi et objekt x lagret i et spesielt minneområde kalt haugen, og to objekter y og z som refererer til det samme objektet x . Bare x refererer til elementene fra den andre til den sjette, og z refererer til x -elementene fra null til den tredje. Hva om det opprinnelige objektet x allerede er brukt og står uten noen referanser på det? I et program fungerer alle andre objekter kun med y og z . I dette tilfellet kan søppelsamleren ødelegge objektet x, mens minnearrayen forblir, og den brukes av y og z. Minnelekkasjen skjer. Så, den nyere, JDK 7 og nyere versjon, metoden er ganske kostbar når det gjelder minnebruk. Det lar deg imidlertid forhindre minnelekkasje. I tillegg fungerer den nye metoden raskere, siden den ikke trenger å beregne antall tegn. For å forsterke det du lærte, foreslår vi at du ser en videoleksjon fra vårt Java-kurs