जावा String.split () विधि

आइए Java के String.split मेथड के बारे में बात करते हैं: यह क्या करता है और इसकी आवश्यकता क्यों है। यह अनुमान लगाना मुश्किल नहीं है कि यह जावा स्ट्रिंग को विभाजित करता है, लेकिन व्यवहार में यह कैसे काम करता है? आइए विधि के संचालन में गहराई से गोता लगाएँ और कुछ गैर-स्पष्ट विवरणों पर चर्चा करें। उसी समय, हम सीखेंगे कि स्ट्रिंग में वास्तव में कितने विभाजित तरीके हैं। चल दर!

जावा के String.split के लिए विवरण और हस्ताक्षर

जावा में, विभाजन विधि नियमित अभिव्यक्ति का उपयोग करके परिभाषित डिलीमीटर का उपयोग करके स्ट्रिंग को सबस्ट्रिंग में विभाजित करती है। आइए विधि हस्ताक्षर प्रस्तुत करें और अपना गोता लगाएँ:

String[] split(String regex)

हस्ताक्षर से दो बातें स्पष्ट होती हैं:

1. विधि स्ट्रिंग्स की एक सरणी देता है।
2. विधि में एक स्ट्रिंग इनपुट पैरामीटर है जिसे रेगेक्स कहा जाता है ।

आइए इनमें से प्रत्येक का अलग-अलग विश्लेषण करें क्योंकि हम ऊपर दिए गए विवरण को तोड़ते हैं।

1. विधि स्ट्रिंग्स की एक सरणी देता है।

   घोषणा में निम्नलिखित शब्द हैं: "जावा में, विभाजन विधि एक स्ट्रिंग को सबस्ट्रिंग में विभाजित करती है।" विधि इन सबस्ट्रिंग्स को एक सरणी में एकत्रित करती है जो वापसी मान बन जाती है।

2. विधि में एक स्ट्रिंग इनपुट पैरामीटर है जिसे रेगेक्स कहा जाता है ।

   दोबारा, विवरण को याद करें: "रेगुलर एक्सप्रेशन का उपयोग करके परिभाषित डिलीमीटर का उपयोग करके स्ट्रिंग को सबस्ट्रिंग में विभाजित करता है।" रेगेक्स इनपुट पैरामीटर एक रेगुलर एक्सप्रेशन है जो मूल स्ट्रिंग पर लागू होता है । जब वर्ण या वर्णों का संयोजन मेल खाता है, तो उन्हें सीमांकक के रूप में माना जाता है।

व्यवहार में जावा का विभाजन

अब चलिए बिंदु के करीब आते हैं। आइए कल्पना करें कि हमारे पास शब्दों की एक श्रृंखला है। उदाहरण के लिए, इस तरह: हमें स्ट्रिंग को शब्दों में विभाजित करने की आवश्यकता है। हम देखते हैं कि इस स्ट्रिंग में शब्द एक दूसरे से रिक्त स्थान से अलग होते हैं। इस मामले में, एक अंतरिक्ष चरित्र हमारे सीमांकक के लिए एकदम सही उम्मीदवार है। हमारे कार्य को हल करने के लिए कोड इस प्रकार दिखाई देगा:

public class Main {
    public static void main(String[] args) {
        String str = "I love Java";
        String[] words = str.split(" ");
        for (String word : words) {
            System.out.println(word);
        }
    }
}

मुख्य विधि का आउटपुट निम्न पंक्तियां होगी: आइए कुछ और उदाहरण देखें कि स्प्लिट मेथड कैसे काम करेगा: उपरोक्त तालिका में अंतिम दो पंक्तियों के बीच के अंतरों पर ध्यान दें। दूसरी से अंतिम पंक्ति में, अल्पविराम का उपयोग सीमांकक के रूप में किया जाता है। नतीजतन, जब स्ट्रिंग विभाजित होती है, तो कुछ शब्दों में आगे की जगह होती है। अंतिम पंक्ति में, हमने सीमांकक के रूप में अल्पविराम और स्थान का उपयोग किया। यही कारण है कि परिणामी सरणी में अग्रणी रिक्त स्थान वाले कोई सबस्ट्रिंग नहीं थे। यह केवल एक सूक्ष्म विवरण है जो दर्शाता है कि सही सीमांकक को सावधानी से चुनना कितना महत्वपूर्ण है।

अग्रणी सीमांकक

यह एक और महत्वपूर्ण बारीकियाँ है। यदि मूल स्ट्रिंग डिलीमीटर से शुरू होती है, तो परिणामी सरणी का पहला तत्व एक खाली स्ट्रिंग होगा। उदाहरण के लिए, यह इस तरह दिखेगा: मूल स्ट्रिंग: "मुझे जावा से प्यार है" सीमांकक: "" परिणामी सरणी: {"", "मैं", "प्रेम", "जावा"} लेकिन यदि मूल स्ट्रिंग एक सीमांकक के बजाय समाप्त होती है एक के साथ शुरुआत की तुलना में, तो परिणाम अलग होगा: मूल स्ट्रिंग: "मुझे जावा पसंद है" सीमांकक: "" परिणामी सरणी: {"मैं", "प्रेम", "जावा"

public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" "));
        print(" I love Java".split(" "));
        print("I love Java ".split(" "));
        print(" I love Java ".split(" "));
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

मुख्य विधि का आउटपुट इस तरह होगा : फिर से अपना ध्यान इस तथ्य की ओर मोड़ें कि जब मूल स्ट्रिंग में पहला वर्ण एक सीमांकक वर्ण होता है, तो परिणाम यह होता है कि सरणी में पहला तत्व एक खाली स्ट्रिंग होगा।

ओवरलोडेड भाई

निम्नलिखित हस्ताक्षर के साथ स्ट्रिंग वर्ग की एक और विभाजन विधि है :

String[] split(String regex, int limit)

इस पद्धति में एक अतिरिक्त सीमा पैरामीटर है: यह निर्धारित करता है कि मूल स्ट्रिंग पर रेगेक्स पैटर्न कितनी बार लागू किया जाएगा। नीचे स्पष्टीकरण देखें:

सीमा > 0

पैटर्न लागू सीमा -1 बार है। क्या अधिक है, लौटाए गए सरणी की लंबाई सीमा पैरामीटर के मान से अधिक नहीं होगी। सरणी का अंतिम तत्व स्ट्रिंग का वह भाग होगा जो उस अंतिम स्थान का अनुसरण करता है जहां सीमांकक पाया गया था। उदाहरण:

public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" ", 1));
        print("I love Java".split(" ", 2));
        /*
         Output:
         [I love Java]
         [I, love Java]
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

सीमा <0

सीमांकक नियमित अभिव्यक्ति स्ट्रिंग पर जितनी बार संभव हो लागू की जाती है। परिणामी सरणी में कोई लंबाई हो सकती है। उदाहरण:

public class Main {
    public static void main(String[] args) {
        // Note the space at the end of the string
        print("I love Java ".split(" ", -1));
        print("I love Java ".split(" ", -2));
        print("I love Java ".split(" ", -12));
        /*
         Output:
        [I, love, Java, ]
        [I, love, Java, ]
        [I, love, Java, ]

        Please note that the last element of the array is
        an empty string. This is caused by the whitespace
        at the end of the original string.
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

सीमा = 0

जैसा कि मामले के साथ जहां सीमा <0 है, सीमांकक पैटर्न को स्ट्रिंग पर जितनी बार संभव हो लागू किया जाता है। अंतिम सरणी में कोई भी लम्बाई हो सकती है। यदि अंतिम तत्व खाली तार हैं, तो उन्हें अंतिम सरणी से हटा दिया जाता है। उदाहरण:

public class Main {
    public static void main(String[] args) {
        // Note the space at the end of the string
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        /*
         Output:
        [I, love, Java]
        [I, love, Java]
        [I, love, Java]
        Note the absence of empty strings at the end of the arrays
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

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

public String[] split(String regex) {
    return split(regex, 0);
}

विभिन्न उदाहरण

वास्तविक दुनिया के अभ्यास में, कभी-कभी ऐसा होता है कि हमारे पास ऐसे तार होते हैं जो कुछ नियमों के अनुसार उत्पन्न होते हैं। हमारे कार्यक्रम में ऐसा तार कहीं से भी आ सकता है:

• तृतीय-पक्ष सेवा से;
• हमारे सर्वर को भेजे गए अनुरोध से;
• कॉन्फ़िगरेशन फ़ाइल से;
• और इसी तरह।

इन स्थितियों में, प्रोग्रामर आमतौर पर "खेल के नियम" जानता है। मान लीजिए कि एक प्रोग्रामर जानता है कि वह इस पैटर्न के अनुसार संग्रहीत उपयोगकर्ता जानकारी से निपट रहा है: उदाहरण के तौर पर कुछ विशिष्ट मान लेते हैं: मान लीजिए कि प्रोग्रामर का कार्य एक ऐसी विधि लिखना है जो उपयोगकर्ता को एक ईमेल भेजता है। प्रोग्रामर के पास उपयोगकर्ता डेटा तक पहुंच होती है, जो ऊपर दिए गए प्रारूप में दर्ज की जाती है। अब हम जिस उप-कार्य का विश्लेषण करना जारी रखेंगे, वह यह है कि ईमेल पते को शेष उपयोगकर्ता डेटा से कैसे अलग किया जाए। यह एक उदाहरण है जहाँ विभाजन विधि उपयोगी हो सकती है। आखिरकार, यदि हम उपयोगकर्ता डेटा टेम्प्लेट को देखते हैं, तो हम महसूस करते हैं कि उपयोगकर्ता के ईमेल पते को बाकी हिस्सों से निकालना स्ट्रिंग को विभाजित करने के लिए विभाजन विधि को कॉल करने जैसा सरल है। फिर ईमेल पता परिणामी सरणी के अंतिम तत्व में होगा। यहां एक विधि का उदाहरण दिया गया है जो उपयोगकर्ता डेटा वाली स्ट्रिंग लेती है और उपयोगकर्ता का ईमेल पता लौटाती है। सरलता के लिए, मान लीजिए कि डेटा स्ट्रिंग हमेशा उस प्रारूप में होती है जो हम चाहते हैं:

public class Main {
    public static void main(String[] args) {
        String userInfo = "135|bender|bender@gmail.com";
        System.out.println(getUserEmail(userInfo));
        // Output: bender@gmail.com
    }

    static String getUserEmail(String userInfo) {
        String[] data = userInfo.split("\\|");
        return data[2]; // or data[data.length - 1]
    }
}

सीमांकक पर ध्यान दें: "\\|" . रेगुलर एक्सप्रेशन में, "|" विशेष अर्थ वाला एक विशेष वर्ण है, इसलिए यदि हम इसे एक साधारण वर्ण (यानी जो हम मूल स्ट्रिंग में खोजना चाहते हैं) का उपयोग करना चाहते हैं, तो हमें दो बैकस्लैश वाले चरित्र से बचने की आवश्यकता है। एक और उदाहरण पर गौर कीजिए। मान लें कि हमारे पास ऑर्डर की जानकारी है जो इस तरह संरचित है: या हम कुछ विशिष्ट मूल्यों को भी अपना सकते हैं: हमारा काम ऑर्डर की कुल लागत की गणना करना है। यहाँ हमें विभाजन विधि को कई बार लागू करना होगा । पहला कदम ";" का उपयोग करके स्ट्रिंग को विभाजित करना है। इसके घटक भागों में इसे तोड़ने के लिए सीमांकक के रूप में। फिर प्रत्येक परिणामी सबस्ट्रिंग में एक अलग उत्पाद के बारे में जानकारी होगी, जिसे हम बाद में संसाधित कर सकते हैं। फिर, प्रत्येक उत्पाद के लिए, हम "," प्रतीक का उपयोग करके संबंधित जानकारी को अलग कर देंगे। हम परिणामी स्ट्रिंग सरणी से एक विशिष्ट इंडेक्स (वह जहां उत्पाद मूल्य संग्रहीत किया जाता है) के साथ एक तत्व लेंगे, इसे संख्यात्मक रूप में परिवर्तित करेंगे, और ऑर्डर की कुल लागत का मिलान करेंगे। आइए एक विधि लिखें जो इन सभी गणनाओं को करेगी:

public class Main {
    public static void main(String[] args) {
        String orderInfo = "1,cucumbers,2.39;2,tomatoes,1.89;3,bacon,4.99";
        System.out.println(getTotalOrderAmount(orderInfo));
        // Output: 9.27
    }

    static double getTotalOrderAmount(String orderInfo) {
        double totalAmount = 0d;
        final String[] items = orderInfo.split(";");

        for (String item : items) {
            final String[] itemInfo = item.split(",");
            totalAmount += Double.parseDouble(itemInfo[2]);
        }

        return totalAmount;
    }
}

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

सारांश

हमने स्ट्रिंग क्लास की स्प्लिट मेथड की जांच की। यह वही है जो आपको चाहिए जब आपको एक विशेष सीमांकक की मदद से एक स्ट्रिंग को उसके घटक भागों में विभाजित करना होता है। विधि स्ट्रिंग्स की एक सरणी देता है (सबस्ट्रिंग जिसमें मूल स्ट्रिंग शामिल है)। यह एक रेगुलर एक्सप्रेशन को स्वीकार करता है जिसके मैच सीमांकक वर्ण(नों) का प्रतिनिधित्व करते हैं। हमने इस पद्धति की विभिन्न सूक्ष्मताओं की जांच की:

• एक प्रमुख सीमांकक;
• इसके अतिभारित सहोदर दो मापदंडों के साथ।

हमने कुछ वास्तविक जीवन स्थितियों को मॉडल करने का भी प्रयास किया जहां हमने काल्पनिक, लेकिन काफी यथार्थवादी समस्याओं को हल करने के लिए विभाजन पद्धति का उपयोग किया।