Understreng i Java

De mest populære handlinger på String i Java er sammenkædning, at få et tegn efter indeks og at få en understreng. I denne artikel vil vi fortælle dig om Java-understrengsmetoden.

Hvad er Java Substring?

Java Substring er generelt en sammenhængende sekvens af tegn inde i strengen. Det kan også være en del af strengen eller hele strengen. Hvad er understreng i Java? Dette sprog har en substring()- metode, eller rettere to metoder, takket være Java-metodens overbelastning. Du kan bruge dem til at hente understreng i Java-programmet. Den første Java-understrengsmetode er String-substring(firstIndex), og den anden er String-understreng (firstIndex, lastIndex) .

Sådan bruger du understreng i Java

Svaret er enkelt: brug blot understrengen. Java substring()- metoden returnerer en del af strengen. Der er to metoder, du kan bruge til dette: Meget populære opgaver, der hjælper dig med at forstå

• Sådan får du en understreng i Java
• Sådan finder du alle understrenge af en given streng
• Sådan finder du den længste fælles understreng

Sådan får du en understreng i Java (særlig)

Dette første Java-understreng-eksempel er ret nemt. Du har en streng , og du skal finde en understreng "CodeGym" i den. Du har allerede vidst, hvordan du får en understreng i Java. Så her er løsningen på dette særlige 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));

   }
}

Outputtet er: CodeGym Proces afsluttet med udgangskode 0 Sådan finder du alle understrenge af en given streng Her har vi den enkleste måde at finde alle understrenge af en given 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));
           }
       }    
   }
}

Outputtet 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 Process afsluttet med udgangskode 0 Sådan finder du den længste fælles understreng Det længste almindelige understrengsproblem er en af ​​de mest populære opgaver inden for datalogi. Du kan møde det på dit juniorudviklerinterview med ret stor sandsynlighed. Prøv alligevel at løse det, det er en meget nyttig øvelse for en nybegynder programmør. Det længste fælles understrengproblem betyder at finde den længste streng (eller nogle få af dem), der er en understreng (eller er understrenge) af to eller flere strenge. For eksempel har du to strenge

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

Output skal være: eGym Så du skal strenge "først" og "anden". Udskriv den længste fælles understreng. Hvis to eller flere understrenge har samme værdi for den længste fælles understreng, skal du udskrive en af ​​dem. Vi anbefaler dig på det kraftigste at prøve at løse dette problem selv og først derefter 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));
   }
}

Outputtet er: Den længste fælles understreng = eGym

Hvordan virker understreng i Java

I JDK 7 og nyere versioner tæller substring() ikke længere antallet af tegn i det tegnarray, det opretter, som det gjorde i versioner før JDK 6 inklusive, men opretter blot et nyt array i hukommelsen (heap) og henviser til det . 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 oprettet som et resultat af substring() -metoden anvendt på objekt x referere til to nyoprettede arrays (på heapen) - {d,e, G, y} for y og {C, o} for z . I JDK 7+ version af metodeunderstrengen vil disse to nye linjer (det vil sige to nye tegnarrays) blive gemt i hukommelsen sammen med den originale streng myLongString ({ C, o, d, e, G, y, m, i, s, t, h, e, b, e, s, t} i form af et array) .

JDK 6 version af understreng

Selv i dag på nogle store projekter kan du møde ældre kodebase fra JDK 6 gange. I JDK 6-metoden virker substring() på en anden måde. Som du sikkert ved, er String en uforanderlig klasse, og for at få delstrengen brugte Java denne uforanderlighed tidligere i JDK 6. Objektet af typen String inde er kun en række af tegn, eller rettere sagt, indeholder en række tegn. På tidspunktet for JDK 6 blev yderligere to variabler gemt der: nummeret på det første tegn i tegnarrayet og deres mængde. I JDK 6 havde String således tre felter med char-værdi [] (character array), int offset (indeks for det første tegn i arrayet) og int count(antallet af tegn i arrayet). Når en understreng oprettes i JDK 6, kopieres arrayet af tegn ikke ind i det nye String- objekt. I stedet for dette gemmer begge objekter en reference til det samme tegnarray. Men det andet objekt gemmer yderligere to variabler, det første symbol på understrengen og det andet handler om, hvor mange symboler der er i understrengen. JDK 6-metoden blev erstattet på grund af hukommelseslækageproblem. Hvad betyder det? Lad os antage, at vi har en streng x, og vi opretter et par understrenge ved hjælp af understreng.

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

Nu har vi et objekt x gemt i et særligt hukommelsesområde kaldet heapen, og to objekter y og z , der refererer til det samme objekt x . Kun x refererer til elementerne fra anden til sjette, og z refererer til x elementer fra nul til tredje. Hvad hvis det originale objekt x allerede er blevet brugt og efterladt uden nogen referencer på det? I et program virker alle andre objekter kun med y og z . I dette tilfælde kan affaldssamleren ødelægge objektet x, mens hukommelsesarrayet forbliver, og det bruges af y og z. Hukommelseslækken sker. Så den nyere, JDK 7 og nyere version, metode er ret dyr med hensyn til hukommelsesbrug. Men det giver dig mulighed for at forhindre hukommelseslækage. Derudover virker den nye metode hurtigere, da den ikke skal beregne antallet af tegn. For at styrke det, du har lært, foreslår vi, at du ser en videolektion fra vores Java-kursus