ஜாவாவில் சப்ஸ்ட்ரிங்

ஜாவாவில் உள்ள String இல் மிகவும் பிரபலமான செயல்கள் ஒருங்கிணைப்பு, குறியீட்டின் மூலம் ஒரு எழுத்தைப் பெறுதல் மற்றும் சப்ஸ்ட்ரிங் பெறுதல். இந்தக் கட்டுரையில் ஜாவா சப்ஸ்ட்ரிங் முறையைப் பற்றிச் சொல்லப் போகிறோம்.

ஜாவா சப்ஸ்ட்ரிங் என்றால் என்ன?

பொதுவாக ஜாவா சப்ஸ்ட்ரிங் என்பது சரத்திற்குள் இருக்கும் எழுத்துக்களின் தொடர்ச்சியான வரிசையாகும். இது சரத்தின் ஒரு பகுதியாகவோ அல்லது முழு சரமாகவோ இருக்கலாம். ஜாவாவில் சப்ஸ்ட்ரிங் என்றால் என்ன? ஜாவா முறை ஓவர்லோடிங்கிற்கு நன்றி, இந்த மொழியில் சப்ஸ்ட்ரிங்() முறை அல்லது இரண்டு முறைகள் உள்ளன. ஜாவா நிரலில் சப்ஸ்ட்ரிங் பெற நீங்கள் அவற்றைப் பயன்படுத்தலாம். முதல் ஜாவா சப்ஸ்ட்ரிங் முறை சரம் சப்ஸ்ட்ரிங் (முதல்இண்டெக்ஸ்) மற்றும் இரண்டாவது சரம் சப்ஸ்ட்ரிங் (முதல்இண்டெக்ஸ், லாஸ்ட்இண்டெக்ஸ்) .

ஜாவாவில் சப்ஸ்ட்ரிங் பயன்படுத்துவது எப்படி

பதில் எளிது: சப்ஸ்ட்ரிங் பயன்படுத்தவும். ஜாவா சப்ஸ்ட்ரிங்() முறை சரத்தின் ஒரு பகுதியை வழங்குகிறது. இதற்கு நீங்கள் பயன்படுத்தக்கூடிய இரண்டு முறைகள் உள்ளன: நீங்கள் புரிந்து கொள்ள உதவும் மிகவும் பிரபலமான பணிகள்

• ஜாவாவில் சப்ஸ்ட்ரிங் எப்படி பெறுவது
• கொடுக்கப்பட்ட சரத்தின் அனைத்து துணைச்சரங்களையும் எவ்வாறு கண்டுபிடிப்பது
• மிக நீளமான பொதுவான சப்ஸ்ட்ரிங்கை எப்படி கண்டுபிடிப்பது

ஜாவாவில் சப்ஸ்ட்ரிங் எப்படி பெறுவது (குறிப்பாக)

இந்த முதல் ஜாவா சப்ஸ்ட்ரிங் உதாரணம் மிகவும் எளிதானது. உங்களிடம் ஒரு சரம் உள்ளது , அதில் "கோட்ஜிம்" என்ற துணைச் சரத்தை நீங்கள் கண்டுபிடிக்க வேண்டும். ஜாவாவில் சப்ஸ்ட்ரிங் எப்படி பெறுவது என்பது உங்களுக்கு ஏற்கனவே தெரியும். எனவே இந்த குறிப்பிட்ட பிரச்சனைக்கான தீர்வு இங்கே:

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

   }
}

வெளியீடு: CodeGym செயல்முறை வெளியேறும் குறியீட்டுடன் முடிந்தது 0 கொடுக்கப்பட்ட சரத்தின் அனைத்து துணைச்சரங்களையும் எவ்வாறு கண்டுபிடிப்பது, கொடுக்கப்பட்ட சரத்தின் அனைத்து துணைச்சரங்களையும் கண்டுபிடிப்பதற்கான எளிய வழி இங்கே உள்ளது.

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

வெளியீடு: C Co 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 வெளியேறும் குறியீட்டைக் கொண்டு செயல்முறை முடிந்தது 0 நீளமான பொதுவான சப்ஸ்ட்ரிங்கை எவ்வாறு கண்டறிவது நீண்ட பொதுவான சப்ஸ்ட்ரிங் பிரச்சனை கணினி அறிவியலில் மிகவும் பிரபலமான பணிகளில் ஒன்றாகும். நீங்கள் அதை உங்கள் ஜூனியர் டெவலப்பர் நேர்காணலில் மிக அதிக நிகழ்தகவுடன் சந்திக்கலாம். எப்படியிருந்தாலும், அதைத் தீர்க்க முயற்சி செய்யுங்கள், இது ஒரு தொடக்க புரோகிராமருக்கு மிகவும் பயனுள்ள பயிற்சியாகும். நீளமான பொதுவான சப்ஸ்ட்ரிங் பிரச்சனை என்பது இரண்டு அல்லது அதற்கு மேற்பட்ட சரங்களின் சப்ஸ்ட்ரிங் (அல்லது அவைகள்) நீளமான சரத்தை (அல்லது அவற்றில் சில) கண்டறிவதாகும். உதாரணமாக, உங்களிடம் இரண்டு சரங்கள் உள்ளன

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

வெளியீடு இருக்க வேண்டும்: eGym எனவே, நீங்கள் "முதல்" மற்றும் "இரண்டாவது" சரங்களைச் செய்ய வேண்டும். மிக நீளமான பொதுவான சப்ஸ்ட்ரிங்கை அச்சிடுங்கள். இரண்டு அல்லது அதற்கு மேற்பட்ட துணைச்சரங்கள் நீண்ட பொதுவான சப்ஸ்ட்ரிங்கிற்கு ஒரே மதிப்பைக் கொண்டிருந்தால், அவற்றில் ஏதேனும் ஒன்றை அச்சிடவும். இந்த சிக்கலை நீங்களே தீர்க்க முயற்சிக்குமாறு நாங்கள் கடுமையாக பரிந்துரைக்கிறோம், அதன் பிறகு கீழே உள்ள குறியீட்டைப் பார்க்கவும்.

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

வெளியீடு: நீண்ட பொதுவான சப்ஸ்ட்ரிங் = eGym

ஜாவாவில் சப்ஸ்ட்ரிங் எப்படி வேலை செய்கிறது

JDK 7 மற்றும் புதிய பதிப்புகளில், substring() ஆனது JDK 6 க்கு முந்தைய பதிப்புகளில் செய்தது போல், அது உருவாக்கும் எழுத்து வரிசையில் உள்ள எழுத்துக்களின் எண்ணிக்கையை இனி கணக்கிடாது, ஆனால் நினைவகத்தில் (குவியல்) ஒரு புதிய வரிசையை உருவாக்கி அதைக் குறிக்கிறது. . இங்கே ஒரு உதாரணம்:

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

எனவே, JDK 7 மற்றும் அதற்குப் பிறகு, பொருள் x க்குப் பயன்படுத்தப்படும் சப்ஸ்ட்ரிங்() முறையின் விளைவாக உருவாக்கப்பட்ட y மற்றும் z ஆகிய ஆப்ஜெக்ட்கள் புதிதாக உருவாக்கப்பட்ட இரண்டு வரிசைகளைக் குறிக்கும் (குவியல் மீது) - {d,e, G, y} y க்கு மற்றும் z க்கு {C, o} . முறை துணைச்சரத்தின் JDK 7 + பதிப்பில், இந்த இரண்டு புதிய வரிகளும் (அதாவது, இரண்டு புதிய எழுத்து வரிசைகள்) அசல் சரமான myLongString உடன் நினைவகத்தில் சேமிக்கப்படும் ({C, o, d, e, G, y, m, i, s, t, h, e, b,e,s,t} வரிசை வடிவில்) .

துணைச்சரத்தின் JDK 6 பதிப்பு

இன்றும் கூட சில பெரிய திட்டங்களில் நீங்கள் JDK இலிருந்து 6 முறை மரபுக் குறியீட்டுத் தளத்தை சந்திக்கலாம். JDK 6 முறை substring() வேறு வழியில் வேலை செய்கிறது. நீங்கள் அறிந்திருப்பதைப் போல, String என்பது ஒரு மாறாத வகுப்பு மற்றும் ஜேடிகே 6 இல், ஜாவா இந்த மாறாத தன்மையைப் பயன்படுத்தியது . JDK 6 இல், மேலும் இரண்டு மாறிகள் அங்கு சேமிக்கப்பட்டன: எழுத்து வரிசையில் முதல் எழுத்தின் எண்ணிக்கை மற்றும் அவற்றின் அளவு. எனவே, ஜேடிகே 6 இல், சரம் சார் மதிப்பு [] (எழுத்து வரிசை), இன்ட் ஆஃப்செட் (வரிசையில் உள்ள முதல் எழுத்தின் குறியீடு) மற்றும் எண்ணாக எண்ணிக்கை ஆகிய மூன்று புலங்களைக் கொண்டிருந்தது.(வரிசையில் உள்ள எழுத்துகளின் எண்ணிக்கை). JDK 6 இல் சப்ஸ்ட்ரிங் உருவாக்கப்படும்போது, ​​புதிய சரம் பொருளில் எழுத்துகளின் வரிசை நகலெடுக்கப்படாது . இதற்குப் பதிலாக, இரண்டு பொருள்களும் ஒரே எழுத்து வரிசைக்கான குறிப்பைச் சேமிக்கின்றன. இருப்பினும், இரண்டாவது பொருள் மேலும் இரண்டு மாறிகளை சேமிக்கிறது, சப்ஸ்ட்ரிங்கின் முதல் சின்னம் மற்றும் இரண்டாவது சப்ஸ்ட்ரிங்கில் எத்தனை சின்னங்கள் உள்ளன என்பது பற்றியது. நினைவக கசிவு பிரச்சனை காரணமாக JDK 6 முறை மாற்றப்பட்டது. இதற்கு என்ன அர்த்தம்? எங்களிடம் ஒரு சரம் உள்ளது என்று வைத்துக் கொள்வோம் x, மேலும் சப்ஸ்ட்ரிங் பயன்படுத்தி இரண்டு சப்ஸ்ட்ரிங்களை உருவாக்குகிறோம்.

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

இப்போது குவியல் எனப்படும் நினைவகத்தின் ஒரு சிறப்புப் பகுதியில் ஒரு பொருள் x சேமிக்கப்பட்டுள்ளது, மேலும் y மற்றும் z ஆகிய இரண்டு பொருள்கள் ஒரே பொருளைக் குறிக்கும் x . இரண்டிலிருந்து ஆறாவது வரையிலான தனிமங்களை மட்டுமே x குறிக்கிறது, மேலும் z என்பது பூஜ்ஜியத்திலிருந்து மூன்றாவது வரையிலான x உறுப்புகளைக் குறிக்கிறது . அசல் பொருள் x ஏற்கனவே பயன்படுத்தப்பட்டு, அதில் எந்த குறிப்பும் இல்லாமல் இருந்தால் என்ன செய்வது? ஒரு நிரலில் மற்ற அனைத்து பொருட்களும் y மற்றும் z உடன் மட்டுமே வேலை செய்யும். இந்த வழக்கில், குப்பை சேகரிப்பான் x என்ற பொருளை அழிக்கக்கூடும், நினைவக வரிசை இருக்கும் போது, ​​அது y மற்றும் z ஆல் பயன்படுத்தப்படுகிறது. நினைவக கசிவு ஏற்படுகிறது. எனவே, புதிய, JDK 7 மற்றும் அதற்குப் பிந்தைய பதிப்பு, நினைவகத்தைப் பயன்படுத்துவதில் மிகவும் விலை உயர்ந்தது. இருப்பினும், நினைவக கசிவைத் தடுக்க இது உங்களை அனுமதிக்கிறது. கூடுதலாக, புதிய முறை வேகமாக வேலை செய்கிறது, ஏனெனில் இது எழுத்துக்களின் எண்ணிக்கையைக் கணக்கிட வேண்டியதில்லை. நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்