स्ट्रिंग हैंडलिंग (String handling)

स्ट्रिंग्स की वास्तुशिल्प अपरिवर्तनीयता:

जावा में, स्ट्रिंग्स को java.lang.String वर्ग द्वारा दर्शाया जाता है। आदिम वर्णों के विपरीत, एक स्ट्रिंग ऑब्जेक्ट अपरिवर्तनीय है - इसके वर्ण सरणी को निर्माण के बाद संशोधित, आकार बदलने या अधिलेखित नहीं किया जा सकता है। कोई भी विधि जो स्ट्रिंग को संशोधित करती प्रतीत होती है (जैसे concat(), replace(), या toUpperCase()) मूल उदाहरण को नहीं बदलती है; यह ढेर पर पूरी तरह से नया स्ट्रिंग ऑब्जेक्ट आवंटित करता है और लौटाता है।

स्ट्रिंग कॉन्स्टेंट पूल (एससीपी) बनाम स्टैंडर्ड हीप:

रैम को संरक्षित करने के लिए, जेवीएम हीप मेमोरी में एक विशेष कैश का प्रबंधन करता है जिसे स्ट्रिंग कॉन्स्टेंट पूल (एससीपी):

• लिटरल क्रिएशन (स्ट्रिंग एस1 = "इंडिया";): जेवीएम एससीपी की जांच करता है। यदि "INDIA" पहले से मौजूद है, तो कोई नई मेमोरी आवंटित नहीं की जाती है; s1 बस मौजूदा पूल किए गए उदाहरण का संदर्भ प्राप्त करता है।
• कीवर्ड निर्माण (String s2 = new String("INDIA");): new ऑपरेटर SCP जांच को बायपास करता है और नियमित हीप मेमोरी में एक स्वतंत्र, विशिष्ट ऑब्जेक्ट को जबरन इंस्टेंट करता है।

स्ट्रिंग तुलना के तीन तरीके:

1. charAt(int सूचकांक):

निर्दिष्ट सूचकांक पर वर्ण लौटाता है ($0$ से $\text{length} - 1$).

स्ट्रिंग एस = "कंप्यूटर";
चार ch = s.charAt(3); // रिटर्न 'पी' (सूचकांक: 0:सी, 1:ओ, 2:एम, 3:पी)

2. सबस्ट्रिंग(इंट बिगिन्डेक्स):

एक नई स्ट्रिंग लौटाता है जिसमें beginIndex से लेकर स्ट्रिंग के अंत तक के अक्षर होते हैं।

स्ट्रिंग एस = "समझें";
स्ट्रिंग उप = s.सबस्ट्रिंग(5); // रिटर्न "स्टैंड" (सूचकांक 5 से 9)

3. सबस्ट्रिंग (इंट स्टार्ट इंडेक्स, इंट एंड इंडेक्स):

स्ट्रिंग एस = "अद्भुत";
स्ट्रिंग उप = s.सबस्ट्रिंग(0, 6); // रिटर्न "वंडर" (सूचकांक 0, 1, 2, 3, 4, 5)

मानक उपयोगिता संचालन:

स्ट्रिंगबफ़र / स्ट्रिंगबिल्डर क्यों?

क्योंकि String अपरिवर्तनीय है, लूप के अंदर बार-बार संयोजन से हीप पर सैकड़ों छोड़े गए मध्यवर्ती ऑब्जेक्ट बनते हैं, जिससे प्रदर्शन ख़राब होता है। इसे हल करने के लिए, जावा दो परिवर्तनशील साथी वर्ग प्रदान करता है:

• StringBuffer: बहु-थ्रेडेड वातावरण के लिए थ्रेड-सुरक्षित, सिंक्रनाइज़, थ्रेड-सुरक्षित।
• स्ट्रिंगबिल्डर: गैर-सिंक्रनाइज़, तेज़ प्रदर्शन, एकल-थ्रेडेड एल्गोरिदम के लिए आदर्श।

स्ट्रिंगबिल्डर एसबी = नया स्ट्रिंगबिल्डर('जावा');
sb.append('प्रोग्रामिंग'); //स्थान में परिवर्तन करता है!
sb.रिवर्स();              // वर्ण क्रम को सीधे उलट देता है!
System.out.println(sb);    // मध्यवर्ती ऑब्जेक्ट बनाए बिना उलटी स्ट्रिंग प्रिंट करता है

पैलिंड्रोम शब्द बनाम विशेष शब्द:

• पैलिंड्रोम वर्ड: आगे की तरह पीछे की ओर भी पढ़ता है (उदाहरण के लिए, MADAM, NITIN, RACECAR).
• विशेष शब्द: बिल्कुल एक ही अक्षर से शुरू और समाप्त होता है (उदाहरण के लिए, WINDOW 'W' से शुरू होता है और 'W' पर समाप्त होता है; EXIST 'E' से शुरू और समाप्त होता है)।

// विशेष शब्द और पैलिंड्रोम मूल्यांकन
स्ट्रिंग w = "मैडम";
w = w.toUpperCase();

// 1. विशेष शब्द जाँच:
बूलियन isSpecial = (w.charAt(0) == w.charAt(w.length() - 1));

// 2. पैलिंड्रोम चेक:
स्ट्रिंग रेव = "";
के लिए (int i = w.length() - 1; i >= 0; i--) {
    रेव += w.charAt(i);
}
बूलियन isPalindrome = w.equals(rev);

System.out.println('विशेष शब्द :' + isSpecial);
System.out.println("Palindrome Word: " + isPalindrome);

मॉडल प्रोग्राम 1: पिग लैटिन अनुवाद एल्गोरिदम

पिग लैटिन परिभाषा: शब्द ($A, E, I, O, U$) में प्रथम स्वर का पता लगाकर एक शब्द को पिग लैटिन में परिवर्तित किया जाता है। उस स्वर से शब्द के अंत तक के सभी अक्षर पिग लैटिन शब्द की शुरुआत बनाते हैं, उसके बाद स्वर से पहले व्यंजन आते हैं, और अंत में "AY" के साथ प्रत्यय लगाया जाता है। यदि कोई स्वर नहीं मिलता है, तो "AY" को अंत में जोड़ दिया जाता है।

उदाहरण: "लंदन" → "ONDONLAY"; "मुसीबत" → "ओबलट्रे"; "खाओ" → "खाओ".

आयात java.util.स्कैनर;

सार्वजनिक वर्ग PigLatinTranslator {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर एससी = नया स्कैनर (System.in);
        System.out.print('एक शब्द दर्ज करें:');
        स्ट्रिंग शब्द = sc.next().toUpperCase();

        पूर्णांक स्वर सूचकांक = -1;
        के लिए (int i = 0; i < word.length(); i++) {
            char ch = word.charAt(i);
            if (ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U') {
                vowelIndex = i;
                break;
            }
        }

        String pigLatin;
        if (vowelIndex != -1) {
            pigLatin = word.substring(vowelIndex) + word.substring(0, vowelIndex) + "AY";
        } else {
            pigLatin = word + "AY";
        }

        System.out.println("Original Word : " + word);
        System.out.println("Pig Latin Word: " + pigLatin);
    }
}

मॉडल प्रोग्राम 2: CompareTo()

आयात java.util.Scanner;

सार्वजनिक वर्ग SortNamesLexicographical {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर इन = नया स्कैनर (System.in);
        स्ट्रिंग[] नाम = नया स्ट्रिंग[5];

        System.out.println('5 नाम दर्ज करें:');
        के लिए (int i = 0; i < names.length; i++) {
            System.out.print("Name " + (i + 1) + ": ");
            names[i] = in.nextLine().trim();
        }

        // Bubble Sort using compareTo()
        for (int i = 0; i < names.length - 1; i++) {
            for (int j = 0; j < names.length - 1 - i; j++) {
                // If names[j] comes alphabetically after names[j+1]:
                if (names[j].compareTo(names[j + 1]) > 0) {
                    स्ट्रिंग अस्थायी = नाम[जे];
                    नाम[जे] = नाम[जे + 1];
                    नाम[जे + 1] = अस्थायी;
                }
            }
        }

        System.out.println("
वर्णानुक्रम में नाम (लेक्सिकोग्राफ़िक) क्रम:");
        (स्ट्रिंग एन: नाम) के लिए {
            System.out.println(n);
        }
    }
}