జావాలో సబ్‌స్ట్రింగ్

జావాలోని స్ట్రింగ్‌లో అత్యంత జనాదరణ పొందిన చర్యలు ఏకీకరణ, సూచిక ద్వారా అక్షరాన్ని పొందడం మరియు సబ్‌స్ట్రింగ్‌ను పొందడం. ఈ వ్యాసంలో మేము జావా సబ్‌స్ట్రింగ్ పద్ధతి గురించి మీకు చెప్పబోతున్నాము.

జావా సబ్‌స్ట్రింగ్ అంటే ఏమిటి?

సాధారణంగా జావా సబ్‌స్ట్రింగ్ అనేది స్ట్రింగ్ లోపల ఉన్న అక్షరాల వరుస క్రమం. ఇది స్ట్రింగ్ లేదా మొత్తం స్ట్రింగ్‌లో ఒక భాగం కావచ్చు. జావాలో సబ్‌స్ట్రింగ్ అంటే ఏమిటి? ఈ భాషకు సబ్‌స్ట్రింగ్() పద్ధతి లేదా రెండు పద్ధతులు ఉన్నాయి , జావా పద్ధతి ఓవర్‌లోడింగ్‌కు ధన్యవాదాలు. జావా ప్రోగ్రామ్‌లో సబ్‌స్ట్రింగ్ పొందడానికి మీరు వాటిని ఉపయోగించవచ్చు. మొదటి జావా సబ్‌స్ట్రింగ్ పద్ధతి స్ట్రింగ్ సబ్‌స్ట్రింగ్ (ఫస్ట్ ఇండెక్స్) మరియు రెండవది స్ట్రింగ్ సబ్‌స్ట్రింగ్ (ఫస్ట్ ఇండెక్స్, లాస్ట్ ఇండెక్స్) .

జావాలో సబ్‌స్ట్రింగ్‌ను ఎలా ఉపయోగించాలి

సమాధానం సులభం: కేవలం సబ్‌స్ట్రింగ్‌ని ఉపయోగించండి. జావా సబ్‌స్ట్రింగ్() పద్ధతి స్ట్రింగ్‌లో కొంత భాగాన్ని అందిస్తుంది. దీని కోసం మీరు ఉపయోగించగల రెండు పద్ధతులు ఉన్నాయి: మీరు అర్థం చేసుకోవడానికి సహాయపడే చాలా ప్రజాదరణ పొందిన పనులు

• జావాలో సబ్‌స్ట్రింగ్‌ను ఎలా పొందాలి
• ఇచ్చిన స్ట్రింగ్ యొక్క అన్ని సబ్‌స్ట్రింగ్‌లను ఎలా కనుగొనాలి
• పొడవైన సాధారణ సబ్‌స్ట్రింగ్‌ను ఎలా కనుగొనాలి

జావాలో సబ్‌స్ట్రింగ్‌ను ఎలా పొందాలి (ప్రత్యేకంగా)

ఈ మొదటి జావా సబ్‌స్ట్రింగ్ ఉదాహరణ చాలా సులభం. మీకు స్ట్రింగ్ ఉంది మరియు మీరు దానిలో "కోడ్ జిమ్" అనే సబ్‌స్ట్రింగ్‌ను కనుగొనాలి. జావాలో సబ్‌స్ట్రింగ్‌ను ఎలా పొందాలో మీకు ఇప్పటికే తెలుసు. కాబట్టి ఈ ప్రత్యేక సమస్యకు పరిష్కారం ఇక్కడ ఉంది:

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

   }
}

అవుట్‌పుట్: కోడ్‌జిమ్ ప్రక్రియ నిష్క్రమణ కోడ్‌తో పూర్తయింది 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 జిమ్ 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 మరియు కొత్త సంస్కరణల్లో, సబ్‌స్ట్రింగ్() అది సృష్టించే అక్షర శ్రేణిలోని అక్షరాల సంఖ్యను లెక్కించదు, 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 పద్ధతిలో సబ్‌స్ట్రింగ్() వేరే విధంగా పనిచేస్తుంది. మీకు బహుశా తెలిసినట్లుగా, స్ట్రింగ్ అనేది మార్పులేని క్లాస్ మరియు సబ్‌స్ట్రింగ్‌ను పొందడానికి జావా ముందుగా JDK 6లో ఈ ఇమ్యుటబిలిటీని ఉపయోగించింది. లోపల టైప్ స్ట్రింగ్ యొక్క ఆబ్జెక్ట్ కేవలం అక్షరాల శ్రేణి లేదా అక్షరాల శ్రేణిని కలిగి ఉంటుంది. JDK 6 సమయంలో, మరో రెండు వేరియబుల్స్ అక్కడ నిల్వ చేయబడ్డాయి: అక్షర శ్రేణిలోని మొదటి అక్షరం సంఖ్య మరియు వాటి పరిమాణం. కాబట్టి, JDK 6లో, స్ట్రింగ్ చార్ విలువ [] (అక్షర శ్రేణి), పూర్ణాంక ఆఫ్‌సెట్ (అరేలోని మొదటి అక్షరం యొక్క సూచిక) మరియు పూర్ణాంక గణన యొక్క మూడు ఫీల్డ్‌లను కలిగి ఉంది.(శ్రేణిలోని అక్షరాల సంఖ్య). JDK 6లో సబ్‌స్ట్రింగ్ సృష్టించబడినప్పుడు, అక్షరాల శ్రేణి కొత్త స్ట్రింగ్ ఆబ్జెక్ట్‌లోకి కాపీ చేయబడదు. దీనికి బదులుగా, రెండు వస్తువులు ఒకే అక్షర శ్రేణికి సూచనను నిల్వ చేస్తాయి. అయితే రెండవ ఆబ్జెక్ట్ మరో రెండు వేరియబుల్స్‌ను స్టోర్ చేస్తుంది, సబ్‌స్ట్రింగ్ యొక్క మొదటి చిహ్నం మరియు రెండవది సబ్‌స్ట్రింగ్‌లో ఎన్ని చిహ్నాలు ఉన్నాయి. మెమరీ లీక్ సమస్య కారణంగా JDK 6 పద్ధతిని భర్తీ చేశారు. దాని అర్థం ఏమిటి? మనకు స్ట్రింగ్ ఉందని అనుకుందాం xమరియు మేము సబ్‌స్ట్రింగ్‌ని ఉపయోగించి రెండు సబ్‌స్ట్రింగ్‌లను సృష్టిస్తాము.

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

ఇప్పుడు మనకు హీప్ అని పిలువబడే ఒక ప్రత్యేక మెమరీ ప్రాంతంలో నిల్వ చేయబడిన ఆబ్జెక్ట్ x మరియు ఒకే వస్తువు x ని సూచించే y ​​మరియు z అనే రెండు వస్తువులు ఉన్నాయి . x మాత్రమే రెండవ నుండి ఆరవ మూలకాలను సూచిస్తుంది మరియు z సున్నా నుండి మూడవ వరకు ఉన్న x మూలకాలను సూచిస్తుంది . అసలు ఆబ్జెక్ట్ x ఇప్పటికే ఉపయోగించబడి, దానిపై ఎలాంటి రిఫరెన్స్ లేకుండా వదిలేస్తే? ప్రోగ్రామ్‌లో అన్ని ఇతర వస్తువులు y మరియు z తో మాత్రమే పని చేస్తాయి. ఈ సందర్భంలో చెత్త కలెక్టర్ వస్తువు x ని నాశనం చేయవచ్చు, మెమరీ శ్రేణి మిగిలి ఉండగా, అది y మరియు z ద్వారా ఉపయోగించబడుతుంది. మెమరీ లీక్ జరుగుతుంది. కాబట్టి, కొత్త, JDK 7 మరియు తదుపరి వెర్షన్, మెమొరీని ఉపయోగించడం పరంగా చాలా ఖరీదైనది. అయితే ఇది మెమరీ లీక్‌ను నిరోధించడానికి మిమ్మల్ని అనుమతిస్తుంది. అదనంగా, కొత్త పద్ధతి వేగంగా పని చేస్తుంది, ఎందుకంటే ఇది అక్షరాల సంఖ్యను లెక్కించాల్సిన అవసరం లేదు. మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము