Substring sa Java

Ang pinakasikat na mga aksyon sa String sa Java ay concatenation, pagkuha ng character sa pamamagitan ng index at pagkuha ng substring. Sa artikulong ito sasabihin namin sa iyo ang tungkol sa Java substring method.

Ano ang Java Substring?

Ang Java Substring sa pangkalahatan ay isang magkadikit na pagkakasunod-sunod ng mga character sa loob ng String. Maaari itong maging bahagi ng String o ang buong String din. Ano ang substring sa Java? Ang wikang ito ay may substring() na pamamaraan, o sa halip ay dalawang pamamaraan, salamat sa Java method overloading. Maaari mong gamitin ang mga ito upang makakuha ng substring sa Java program. Ang unang Java substring method ay String substring(firstIndex) at ang pangalawa ay String substring (firstIndex, lastIndex) .

Paano gamitin ang substring sa Java

Ang sagot ay simple: gamitin lamang ang substring. Ang Java substring() method ay nagbabalik ng isang bahagi ng string. Mayroong dalawang paraan na maaari mong gamitin para dito: Napakasikat na mga gawain na makakatulong sa iyo na maunawaan

• Paano makakuha ng isang substring sa Java
• Paano mahanap ang lahat ng mga substring ng isang ibinigay na string
• Paano mahanap ang pinakamahabang karaniwang substring

Paano makakuha ng isang substring sa Java (partikular)

Ang unang halimbawa ng substring ng Java ay medyo madali. Mayroon kang String at kailangan mong maghanap ng substring na "CodeGym" dito. Alam mo na kung paano makakuha ng substring sa Java. Kaya narito ang solusyon sa partikular na problemang ito:

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

   }
}

Ang output ay: CodeGym Proseso tapos na may exit code 0 Paano hanapin ang lahat ng mga substring ng isang ibinigay na string Narito mayroon kaming ang pinakasimpleng paraan upang mahanap ang lahat ng mga substring ng isang ibinigay na String.

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

Ang output ay: 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 Proseso tapos gamit ang exit code 0 Paano mahanap ang pinakamahabang karaniwang substring Ang pinakamahabang karaniwang problema sa substring ay isa sa mga pinakasikat na gawain sa computer science. Matutugunan mo ito sa iyong panayam sa Junior Developer na may medyo mataas na posibilidad. Anyway, subukang lutasin ito, ito ay isang napaka-kapaki-pakinabang na ehersisyo para sa isang baguhan na programmer. Ang pinakamahabang karaniwang problema sa substring ay nangangahulugan na mahanap ang pinakamahabang string (o ilan sa mga ito) na isang substring (o mga substring) ng dalawa o higit pang mga string. Halimbawa mayroon kang dalawang string

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

Ang output ay dapat na: eGym Kaya, kailangan mong i-string ang "una" at "ikalawa". I-print ang pinakamahabang karaniwang substring. Kung ang dalawa o higit pang mga substring ay may parehong halaga para sa pinakamahabang karaniwang substring, i-print ang alinman sa mga ito. Lubos naming inirerekumenda sa iyo na subukang lutasin ang problemang ito nang mag-isa at pagkatapos lamang na tingnan ang code sa ibaba.

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

Ang output ay: Ang pinakamahabang karaniwang substring = eGym

Paano gumagana ang substring sa Java

Sa JDK 7 at mas bagong mga bersyon, hindi na binibilang ng substring() ang bilang ng mga character sa character array na nilikha nito, tulad ng ginawa nito sa mga bersyon bago ang JDK 6 inclusive, ngunit lumilikha lamang ng bagong array sa memorya (heap) at tinutukoy ito . Narito ang isang halimbawa:

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

Kaya, sa JDK 7 at mas bago, ang mga object na y at z na nilikha bilang resulta ng substring() na pamamaraan na inilapat sa object x ay tumutukoy sa dalawang bagong likhang array (sa heap) - {d,e, G, y} para sa y at {C, o} para sa z . Sa JDK 7 + na bersyon ng method na substring, ang dalawang bagong linyang ito (iyon ay, dalawang bagong character array) ay maiimbak sa memorya kasama ang orihinal na string myLongString ({ C, o, d, e, G, y, m, i, s, t, h, e, b,e,s,t} sa anyo ng array) .

JDK 6 na bersyon ng substring

Kahit ngayon sa ilang malalaking proyekto maaari mong matugunan ang legacy code base mula sa JDK nang 6 na beses. Sa JDK 6 method substring() gumagana sa ibang paraan. Tulad ng malamang na alam mo, ang String ay isang hindi nababagong Klase at para magamit ng substring na Java ang immutability na ito nang mas maaga sa JDK 6. Ang Object ng uri ng String sa loob ay isang hanay lamang ng mga character, o sa halip, ay naglalaman ng hanay ng mga character. Sa panahon ng JDK 6, dalawa pang variable ang naimbak doon: ang bilang ng unang character sa array ng character at ang dami ng mga ito. Kaya, sa JDK 6, ang String ay may tatlong field ng char value [] (character array), int offset (index ng unang character sa array), at int count(ang bilang ng mga character sa array). Kapag ang isang substring ay ginawa sa JDK 6, ang hanay ng mga character ay hindi kinokopya sa bagong String object. Sa halip na ito, ang parehong Objects ay nag-iimbak ng reference sa parehong Character Array. Gayunpaman, ang pangalawang Object ay nag-iimbak ng dalawa pang variable, ang unang simbolo ng substring at ang pangalawa ay tungkol sa kung gaano karaming mga simbolo ang nasa substring. Ang JDK 6 na pamamaraan ay pinalitan dahil sa problema sa pagtagas ng memorya. Ano ang ibig sabihin nito? Ipagpalagay natin na mayroon tayong string x, at lumikha tayo ng ilang substring gamit ang substring.

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

Ngayon mayroon kaming isang bagay na x na nakaimbak sa isang espesyal na lugar ng memorya na tinatawag na heap, at dalawang bagay na y at z na tumutukoy sa parehong bagay na x . Ang x lamang ang tumutukoy sa mga elemento mula sa pangalawa hanggang sa ikaanim, at ang z ay tumutukoy sa mga elemento ng x mula sa zero hanggang sa ikatlo. Paano kung ang orihinal na bagay na x ay nagamit na at iniwan nang walang anumang mga sanggunian dito? Sa isang programa ang lahat ng iba pang mga bagay ay gumagana sa y at z lamang. Sa kasong ito, maaaring sirain ng tagakolekta ng basura ang bagay na x, habang ang memory array ay nananatili, at ito ay ginagamit ng y at z. Nangyayari ang pagtagas ng memorya. Kaya, ang mas bago, JDK 7 at mas bagong bersyon, ang pamamaraan ay medyo magastos sa mga tuntunin ng paggamit ng memorya. Gayunpaman, pinapayagan ka nitong maiwasan ang pagtagas ng memorya. Bilang karagdagan, ang bagong pamamaraan ay gumagana nang mas mabilis, dahil hindi nito kailangang kalkulahin ang bilang ng mga character. Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course