जावा में सबस्ट्रिंग

जावा में स्ट्रिंग पर सबसे लोकप्रिय क्रियाएं संयोजन हैं, सूचकांक द्वारा एक चरित्र प्राप्त करना और एक सबस्ट्रिंग प्राप्त करना। इस आर्टिकल में हम आपको जावा सबस्ट्रिंग मेथड के बारे में बताने जा रहे हैं।

जावा सबस्ट्रिंग क्या है?

जावा सबस्ट्रिंग सामान्य रूप से स्ट्रिंग के अंदर वर्णों का एक सन्निहित अनुक्रम है। यह स्ट्रिंग या संपूर्ण स्ट्रिंग का भी हिस्सा हो सकता है। जावा में सबस्ट्रिंग क्या है? जावा विधि ओवरलोडिंग के लिए धन्यवाद, इस भाषा में एक सबस्ट्रिंग() विधि, या बल्कि दो विधियां हैं। आप जावा प्रोग्राम में सबस्ट्रिंग प्राप्त करने के लिए उनका उपयोग कर सकते हैं। पहली जावा सबस्ट्रिंग विधि स्ट्रिंग सबस्ट्रिंग (फर्स्टइंडेक्स) है और दूसरी स्ट्रिंग सबस्ट्रिंग (फर्स्टइंडेक्स, लास्टइंडेक्स) है ।

जावा में सबस्ट्रिंग का उपयोग कैसे करें

उत्तर सरल है: केवल सबस्ट्रिंग का उपयोग करें। जावा सबस्ट्रिंग () विधि स्ट्रिंग का एक हिस्सा लौटाती है। इसके लिए आप दो तरीकों का इस्तेमाल कर सकते हैं: बहुत लोकप्रिय कार्य जो आपको समझने में मदद करते हैं

• जावा में एक सबस्ट्रिंग कैसे प्राप्त करें
• किसी दिए गए स्ट्रिंग के सभी सबस्ट्रिंग कैसे खोजें
• सबसे लंबा सामान्य सबस्ट्रिंग कैसे खोजें

जावा में एक सबस्ट्रिंग कैसे प्राप्त करें (विशेष)

यह पहला जावा सबस्ट्रिंग उदाहरण बहुत आसान है। आपके पास एक स्ट्रिंग है और आपको इसमें एक सबस्ट्रिंग "CodeGym" खोजने की आवश्यकता है। आप पहले ही जान चुके हैं कि जावा में सबस्ट्रिंग कैसे प्राप्त करें। तो पेश है इस खास समस्या का समाधान:

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 Code CodeG CodeGy CodeGym o od 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 और नए संस्करणों में, सबस्ट्रिंग () अब इसके द्वारा बनाए गए वर्ण सरणी में वर्णों की संख्या की गणना नहीं करता है, जैसा कि इसने JDK 6 समावेशी से पहले के संस्करणों में किया था, लेकिन बस स्मृति (ढेर) में एक नई सरणी बनाता है और इसे संदर्भित करता है . यहाँ एक उदाहरण है:

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

इसलिए, JDK 7 और बाद में, ऑब्जेक्ट y और z ऑब्जेक्ट x पर लागू सबस्ट्रिंग () विधि के परिणामस्वरूप बनाए गए दो नए बनाए गए सरणियों (ढेर पर) - {d, e, G, y} को y के लिए संदर्भित करेंगे। और {सी, ओ} z के लिए । विधि सबस्ट्रिंग के JDK 7 + संस्करण में, इन दो नई पंक्तियों (यानी, दो नए वर्ण सरणियों) को मूल स्ट्रिंग myLongString ( {C, o, d, e, G, y, m, ) के साथ मेमोरी में संग्रहीत किया जाएगा। i, s, t, h, e, b,e,s,t} सरणी के रूप में) ।

सबस्ट्रिंग का JDK 6 संस्करण

आज भी कुछ बड़ी परियोजनाओं पर आपको 6 बार JDK से विरासत कोड आधार मिल सकता है। 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 है जिसे हीप कहा जाता है, और दो ऑब्जेक्ट y और z एक ही ऑब्जेक्ट x का संदर्भ देते हैं । केवल x तत्वों को दूसरे से छठे तक संदर्भित करता है, और z x तत्वों को शून्य से तीसरे तक संदर्भित करता है । क्या होगा यदि मूल वस्तु x का पहले ही उपयोग किया जा चुका है और उस पर बिना किसी संदर्भ के छोड़ दिया गया है? एक प्रोग्राम में अन्य सभी ऑब्जेक्ट केवल y और z के साथ काम करते हैं। इस मामले में कचरा संग्राहक वस्तु x को नष्ट कर सकता है, जबकि स्मृति सरणी बनी हुई है, और इसका उपयोग y और z द्वारा किया जाता है। स्मृति रिसाव होता है। तो, नया, JDK 7 और बाद का संस्करण, मेमोरी उपयोग करने के मामले में विधि बहुत महंगा है। हालाँकि यह आपको मेमोरी लीक को रोकने की अनुमति देता है। इसके अलावा, नई विधि तेजी से काम करती है, क्योंकि इसमें वर्णों की संख्या की गणना करने की आवश्यकता नहीं होती है। आपने जो सीखा है उसे सुदृढ़ करने के लिए, हमारा सुझाव है कि आप हमारे जावा कोर्स से एक वीडियो सबक देखें