Alkarakterlánc Java nyelven

A Java-ban a String legnépszerűbb műveletei az összefűzés, a karakterek indexenkénti lekérése és egy részkarakterlánc beszerzése. Ebben a cikkben a Java részstring metódusáról fogunk beszélni.

Mi az a Java Substring?

A Java Substring általában egy összefüggő karaktersorozat a Stringben. Ez lehet a String egy része vagy az egész karakterlánc is. Mi az a részstring a Java-ban? Ennek a nyelvnek van egy substring() metódusa, vagy inkább két metódusa a Java metódusok túlterhelésének köszönhetően. Használhatja őket részstring lekéréséhez a Java programban. Az első Java részstring metódus a String substring(firstIndex) , a második pedig a String substring (firstIndex, lastIndex) .

Hogyan használjunk részstringet a Java-ban

A válasz egyszerű: csak használja az alkarakterláncot. A Java substring() metódus a karakterlánc egy részét adja vissza. Ehhez két módszert használhat: Nagyon népszerű feladatok, amelyek segítenek megérteni

• Hogyan szerezzünk be egy részkarakterláncot Java-ban
• Hogyan lehet megtalálni egy adott karakterlánc összes részkarakterláncát
• Hogyan lehet megtalálni a leghosszabb közös karakterláncot

Hogyan szerezzünk be egy részkarakterláncot Java nyelven (különösen)

Ez az első Java részkarakterlánc-példa meglehetősen egyszerű. Van egy karakterláncod , és meg kell találnod benne a "CodeGym" részkarakterláncot. Tudtad már, hogyan lehet részkarakterláncot szerezni Java nyelven. Tehát itt van a megoldás erre a problémára:

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

   }
}

A kimenet a következő: CodeGym Process befejezve a 0 kilépési kóddal Hogyan lehet megtalálni egy adott karakterlánc összes alsztringjét Itt van a legegyszerűbb módja egy adott String összes részstringjének megkeresésére.

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

A kimenet a következő: C Cod Code CodeG CodeGy CodeGym o od ode odeG odeGy odeGym d de deG deGy deGym e eG eGy eGym G Gym y ymm A folyamat a 0 kilépési kóddal befejeződött Hogyan találjuk meg a leghosszabb közös részstringet A leghosszabb közös részstring probléma a számítástechnika egyik legnépszerűbb feladata. Elég nagy valószínűséggel találkozhat vele a Junior Developer interjún. Amúgy próbáld meg megoldani, kezdő programozónak nagyon hasznos gyakorlat. A leghosszabb általános karakterlánc-probléma azt jelenti, hogy meg kell találni a leghosszabb karakterláncot (vagy néhányat), amely két vagy több karakterlánc részkarakterlánca (vagy részkarakterlánca). Például két karakterláncod van

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

A kimenetnek a következőnek kell lennie: eGym Tehát az "első" és a "második" karakterláncokat kell megadnia. Nyomtassa ki a leghosszabb közös karakterláncot. Ha két vagy több részkarakterláncnak ugyanaz az értéke a leghosszabb közös karakterlánchoz, nyomtassa ki bármelyiket. Nyomatékosan javasoljuk, hogy próbálja meg egyedül megoldani ezt a problémát, és csak ezután tekintse meg az alábbi kódot.

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

A kimenet a következő: A leghosszabb közös karakterlánc = eGym

Hogyan működik a részkarakterlánc Java-ban

A JDK 7 és újabb verzióiban a substring() már nem számolja az általa létrehozott karaktertömb karaktereinek számát, mint a JDK 6 előtti verziókban, hanem egyszerűen létrehoz egy új tömböt a memóriában (heap), és hivatkozik rá. . Íme egy példa:

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

Tehát a JDK 7 és újabb verzióiban az x objektumra alkalmazott substring() metódus eredményeként létrehozott y és z objektumok két újonnan létrehozott tömbre hivatkoznak (a kupacban) - {d,e, G, y} y esetén és {C, o} z esetén . A metódus részkarakterlánc JDK 7+ verziójában ez a két új sor (azaz két új karaktertömb) az eredeti myLongString karakterlánccal együtt kerül tárolásra ({C, o, d, e, G, y, m, i, s, t, h, e, b,e,s,t} tömb formájában) .

A részkarakterlánc JDK 6 verziója

Néhány nagy projektnél még ma is hatszor találkozhat a JDK örökölt kódbázisával. A JDK 6-ban a substring() metódus másképpen működik. Amint azt bizonyára tudod, a String egy megváltoztathatatlan osztály, és az alstring eléréséhez a Java ezt a megváltoztathatatlanságot használta korábban a JDK 6-ban. A String típusú objektum belül csak egy karaktertömb, vagy inkább egy karaktertömböt tartalmaz. A JDK 6 idején még két változót tároltak ott: a karaktertömb első karakterének számát és mennyiségét. Így a JDK 6-ban a String három mezővel rendelkezik: char érték [] (karaktertömb), int offset (a tömb első karakterének indexe) és int count.(a karakterek száma a tömbben). Amikor létrehoz egy részkarakterláncot a JDK 6-ban, a karaktertömb nem kerül az új String objektumba. Ehelyett mindkét objektum ugyanarra a karaktertömbre hivatkozik. A második objektum azonban még két változót tárol, az első karakterlánc szimbólumát, a második pedig arról szól, hogy hány szimbólum van a karakterláncban. A JDK 6 módszert memóriaszivárgási probléma miatt helyettesítették. Mit jelent? Tegyük fel, hogy van egy karakterláncunk x, és létrehozunk néhány részkarakterláncot a részstring segítségével.

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

Most van egy x objektum a memória egy speciális területén, amelyet kupacnak nevezünk, és két y és z objektum , amelyek ugyanarra az x objektumra utalnak . Csak az x a másodiktól a hatodikig terjedő elemekre, a z pedig az x elemekre nullától a harmadikig. Mi van akkor, ha az eredeti x objektumot már használták, és hivatkozás nélkül maradt rajta? Egy programban az összes többi objektum csak y- val és z- vel működik . Ebben az esetben a szemétgyűjtő tönkreteheti az x objektumot, míg a memóriatömb megmarad, és y és z használja. Megtörténik a memóriaszivárgás. Tehát az újabb, JDK 7 és újabb verziójú módszer meglehetősen költséges a memóriahasználat szempontjából. Ez azonban lehetővé teszi a memóriaszivárgás megelőzését. Ráadásul az új módszer gyorsabban működik, hiszen nem kell karakterszámot számolnia. A tanultak megerősítése érdekében javasoljuk, hogy nézzen meg egy videóleckét a Java-tanfolyamról