Subșir în Java

Cele mai populare acțiuni pe String în Java sunt concatenarea, obținerea unui caracter cu index și obținerea unui subșir. În acest articol vă vom spune despre metoda subșirurilor Java.

Ce este Java Substring?

Subșirul Java în general este o secvență adiacentă de caractere în interiorul șirului. Ar putea fi o parte din String sau întregul șir. Ce este subșirul în Java? Acest limbaj are o metodă substring() , sau mai degrabă două metode, datorită supraîncărcării metodei Java. Le puteți folosi pentru a obține subșiruri în programul Java. Prima metodă Java subșir este String substring(firstIndex), iar a doua este String subșir (firstIndex, lastIndex) .

Cum se utilizează subșirul în Java

Răspunsul este simplu: folosește doar subșirul. Metoda Java substring() returnează o parte a șirului. Există două metode pe care le puteți folosi pentru aceasta: Sarcini foarte populare care vă ajută să înțelegeți

• Cum să obțineți un subșir în Java
• Cum să găsiți toate subșirurile unui șir dat
• Cum să găsiți cel mai lung subșir comun

Cum să obțineți un subșir în Java (în special)

Acest prim exemplu de subșir Java este destul de ușor. Aveți un șir și trebuie să găsiți un subșir „CodeGym” în el. Ați știut deja cum să obțineți un subșir în Java. Deci, iată soluția acestei probleme specifice:

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

   }
}

Rezultatul este: CodeGym Procesul terminat cu codul de ieșire 0 Cum să găsiți toate subșirurile unui șir dat Aici avem cel mai simplu mod de a găsi toate subșirurile unui șir dat.

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

Ieșirea este: C Co Cod Cod CodeG CodeGy CodeGym o od ode odeG odeGy odeGym d de deG deGy deGym e eG eGy eGym G Gy Gym y ym m Procesul terminat cu codul de ieșire 0 Cum să găsiți cel mai lung subșir comun Problema cea mai lungă comună subșir este una dintre cele mai populare sarcini în informatică. Îl poți întâlni la interviul tău Junior Developer cu o probabilitate destul de mare. Oricum, incearca sa o rezolvi, este un exercitiu foarte util pentru un programator incepator. Cea mai lungă problemă comună de subșir înseamnă să găsiți cel mai lung șir (sau câteva dintre ele) care este un subșir (sau sunt subșiruri) de două sau mai multe șiruri. De exemplu, aveți două șiruri

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

Ieșirea ar trebui să fie: eGym Deci, trebuie să introduceți șiruri „primul” și „al doilea”. Tipăriți cel mai lung subșir comun. Dacă două sau mai multe subșiruri au aceeași valoare pentru cel mai lung subșir comun, tipăriți oricare dintre ele. Vă recomandăm insistent să încercați să rezolvați singur această problemă și numai după aceea să vă uitați la codul de mai jos.

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

Rezultatul este: Cel mai lung subșir comun = eGym

Cum funcționează subșirul în Java

În JDK 7 și versiunile mai noi, substring() nu mai numără numărul de caractere din matricea de caractere pe care o creează, așa cum a făcut în versiunile anterioare JDK 6 inclusiv, ci pur și simplu creează o nouă matrice în memorie (heap) și se referă la acesta. . Iată un exemplu:

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

Deci, în JDK 7 și mai târziu, obiectele y și z create ca urmare a metodei substring() aplicate obiectului x se vor referi la două tablouri nou create (pe heap) - {d,e, G, y} pentru y și {C, o} pentru z . În versiunea JDK 7 + a subșirului metodei, aceste două linii noi (adică două matrice de caractere noi) vor fi stocate în memorie împreună cu șirul original myLongString ({ C, o, d, e, G, y, m, i, s, t, h, e, b,e,s,t} sub forma unui tablou) .

Versiunea JDK 6 a subșirului

Chiar și astăzi, la unele proiecte mari, este posibil să întâlniți baza de cod moștenit de la JDK de 6 ori. În metoda JDK 6 substring() funcționează într-un mod diferit. După cum probabil știți, String este o clasă imuabilă și pentru a obține subșirul Java a folosit această imuabilitate mai devreme în JDK 6. Obiectul de tip String din interior este doar o matrice de caractere, sau mai degrabă, conține o matrice de caractere. La momentul JDK 6, încă două variabile erau stocate acolo: numărul primului caracter din matricea de caractere și cantitatea acestora. Astfel, în JDK 6, String avea trei câmpuri de valoare char [] (matrice de caractere), int offset (indicele primului caracter din matrice) și număr de int(numărul de caractere din matrice). Când un subșir este creat în JDK 6, matricea de caractere nu este copiată în noul obiect String . În loc de aceasta, ambele obiecte stochează o referință la aceeași matrice de caractere. Cu toate acestea, al doilea obiect stochează încă două variabile, primul simbol al subșirului și al doilea este despre câte simboluri sunt în subșir. Metoda JDK 6 a fost înlocuită din cauza unei probleme de scurgere a memoriei. Ce înseamnă? Să presupunem că avem un șir xși creăm câteva subșiruri folosind subșir.

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

Acum avem un obiect x stocat într-o zonă specială de memorie numită heap și două obiecte y și z care se referă la același obiect x . Doar x se referă la elementele de la al doilea la al șaselea, iar z se referă la elementele x de la zero la al treilea. Ce se întâmplă dacă obiectul original x a fost deja folosit și lăsat fără nicio referință pe el? Într-un program toate celelalte obiecte funcționează numai cu y și z . În acest caz, colectorul de gunoi poate distruge obiectul x, în timp ce matricea de memorie rămâne și este folosită de y și z. Scurgerea de memorie are loc. Deci, metoda mai nouă, JDK 7 și versiunea ulterioară, este destul de costisitoare în ceea ce privește utilizarea memoriei. Cu toate acestea, vă permite să preveniți scurgerea memoriei. În plus, noua metodă funcționează mai rapid, deoarece nu trebuie să calculeze numărul de caractere. Pentru a consolida ceea ce ați învățat, vă sugerăm să urmăriți o lecție video de la Cursul nostru Java