Java String.split() पद्धत

चला Java च्या String.split पद्धतीबद्दल बोलू: ते काय करते आणि ते का आवश्यक आहे. हे जावा स्ट्रिंग विभाजित करते याचा अंदाज लावणे कठीण नाही, परंतु हे व्यवहारात कसे कार्य करते? चला या पद्धतीच्या ऑपरेशनमध्ये खोलवर जाऊया आणि काही गैर-स्पष्ट तपशीलांवर चर्चा करूया. त्याच वेळी, स्ट्रिंगमध्ये किती विभाजित पद्धती आहेत हे आपण शिकू. चल जाऊया!

Java च्या String.split साठी वर्णन आणि स्वाक्षरी

Java मध्ये, स्प्लिट पद्धत रेग्युलर एक्स्प्रेशन वापरून परिभाषित केलेल्या डिलिमिटरचा वापर करून स्ट्रिंगला सबस्ट्रिंगमध्ये विभाजित करते. चला पद्धत स्वाक्षरी सादर करूया आणि आपला गोतावळा सुरू करूया:

String[] split(String regex)

स्वाक्षरीतून दोन गोष्टी स्पष्ट होतात:

1. पद्धत स्ट्रिंगची अॅरे मिळवते.
2. पद्धतीमध्ये regex नावाचे स्ट्रिंग इनपुट पॅरामीटर आहे .

आपण वर दिलेले वर्णन मोडून काढत या प्रत्येकाचे स्वतंत्रपणे विश्लेषण करूया.

1. पद्धत स्ट्रिंगची अॅरे मिळवते.

   घोषणेमध्ये खालील शब्द आहेत: "जावामध्ये, स्प्लिट पद्धत स्ट्रिंगला सबस्ट्रिंगमध्ये विभाजित करते." पद्धत ही सबस्ट्रिंग्स एका अॅरेमध्ये एकत्रित करते जी रिटर्न व्हॅल्यू बनते.

2. पद्धतीमध्ये regex नावाचे स्ट्रिंग इनपुट पॅरामीटर आहे .

   पुन्हा, वर्णन आठवा: "रेग्युलर एक्स्प्रेशन वापरून परिभाषित केलेल्या परिसीमक वापरून स्ट्रिंगला सबस्ट्रिंगमध्ये विभाजित करते." regex इनपुट पॅरामीटर एक नियमित अभिव्यक्ती आहे जी मूळ स्ट्रिंगवर लागू केली जाते . जेव्हा वर्ण किंवा वर्णांचे संयोजन जुळते तेव्हा त्यांना परिसीमक मानले जाते.

व्यवहारात जावाचे विभाजन

आता मुद्याच्या जवळ जाऊया. कल्पना करूया की आपल्याकडे शब्दांची स्ट्रिंग आहे. उदाहरणार्थ, यासारखे: आपण स्ट्रिंगला शब्दांमध्ये विभाजित करणे आवश्यक आहे. आपण पाहतो की या स्ट्रिंगमधील शब्द स्पेसद्वारे एकमेकांपासून वेगळे केलेले आहेत. या प्रकरणात, स्पेस कॅरेक्टर हे आमच्या डिलिमिटरसाठी योग्य उमेदवार आहे. आमचे कार्य सोडवण्याचा कोड यासारखा दिसेल:

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

मुख्य पद्धतीचे आउटपुट खालील ओळी असेल: स्प्लिट पद्धत कशी कार्य करेल याची आणखी काही उदाहरणे पाहू या : वरील सारणीतील शेवटच्या दोन ओळींमधील फरक लक्षात घ्या. दुसऱ्या ते शेवटच्या पंक्तीमध्ये, स्वल्पविराम हा परिसीमक म्हणून वापरला जातो. परिणामी, जेव्हा स्ट्रिंग विभाजित होते, तेव्हा काही शब्दांमध्ये अग्रस्थानी जागा असतात. शेवटच्या ओळीत, आम्ही आमचा परिसीमक म्हणून स्वल्पविराम आणि स्पेस वापरले. म्हणूनच परिणामी अॅरेमध्ये अग्रगण्य स्थानांसह कोणतेही सबस्ट्रिंग नव्हते. हे फक्त एक सूक्ष्म तपशील आहे जे योग्य परिसीमक काळजीपूर्वक निवडणे किती महत्वाचे आहे हे दर्शवते.

अग्रगण्य परिसीमक

ही आणखी एक महत्त्वाची सूक्ष्मता आहे. जर मूळ स्ट्रिंग डिलिमिटरने सुरू होत असेल, तर परिणामी अॅरेचा पहिला घटक रिक्त स्ट्रिंग असेल. उदाहरणार्थ, हे असे दिसेल: मूळ स्ट्रिंग: " मला जावा आवडते" डिलिमिटर: " " परिणामी अॅरे: { "", "I", "love", "Java" } पण जर मूळ स्ट्रिंग डिलिमिटरने संपत असेल तर एकाने सुरुवात करण्यापेक्षा, नंतर परिणाम भिन्न असेल: मूळ स्ट्रिंग: "मला जावा आवडते" डिलिमिटर: " " परिणामी अॅरे: { "मी", "प्रेम", "जावा"

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)

या पद्धतीमध्ये अतिरिक्त मर्यादा पॅरामीटर आहे: मूळ स्ट्रिंगवर regex नमुना किती वेळा लागू केला जाईल हे ते निर्धारित करते . खालील स्पष्टीकरण पहा:

मर्यादा > 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;
    }
}

ही पद्धत स्वतः कशी कार्य करते हे आपण शोधू शकता का ते पहा. या उदाहरणांच्या आधारे, आम्ही असे म्हणू शकतो की स्प्लिट पद्धत वापरली जाते जेव्हा आमच्याकडे काही डेटा स्ट्रिंग म्हणून फॉरमॅट केलेला असतो आणि आम्हाला त्यातून काही अधिक विशिष्ट माहिती काढायची असते.

सारांश

आम्ही स्ट्रिंग वर्गाच्या विभाजन पद्धतीचे परीक्षण केले . जेव्हा तुम्हाला स्ट्रिंगला त्याच्या घटक भागांमध्ये स्पेशल डिलिमिटरच्या साहाय्याने विभाजित करावे लागते तेव्हा तुम्हाला तेच हवे असते. पद्धत स्ट्रिंगची अॅरे मिळवते (मूळ स्ट्रिंग असलेले सबस्ट्रिंग). हे एक नियमित अभिव्यक्ती स्वीकारते ज्याचे सामने परिसीमक वर्ण(चे) दर्शवतात. आम्ही या पद्धतीच्या विविध सूक्ष्मता तपासल्या:

• अग्रगण्य परिसीमक;
• दोन पॅरामीटर्ससह त्याचे ओव्हरलोड केलेले भावंड.

आम्ही काल्पनिक, परंतु अगदी वास्तववादी, समस्यांचे निराकरण करण्यासाठी स्प्लिट पद्धतीचा वापर करून काही वास्तविक जीवनातील परिस्थितींचे मॉडेल करण्याचा प्रयत्न केला.