Java String.split() పద్ధతి

జావా యొక్క String.split పద్ధతి గురించి మాట్లాడుదాం : అది ఏమి చేస్తుంది మరియు ఎందుకు అవసరం. ఇది జావా స్ట్రింగ్‌ను విభజిస్తుందని ఊహించడం కష్టం కాదు, అయితే ఇది ఆచరణలో ఎలా పని చేస్తుంది? పద్ధతి యొక్క ఆపరేషన్‌లో లోతుగా డైవ్ చేద్దాం మరియు కొన్ని స్పష్టమైన వివరాలను చర్చిద్దాం. అదే సమయంలో, స్ట్రింగ్ వాస్తవానికి ఎన్ని స్ప్లిట్ పద్ధతులను కలిగి ఉందో మేము నేర్చుకుంటాము. వెళ్దాం!

Java యొక్క String.split కోసం వివరణ మరియు సంతకం

జావాలో, స్ప్లిట్ పద్ధతి సాధారణ వ్యక్తీకరణను ఉపయోగించి నిర్వచించిన డీలిమిటర్‌ని ఉపయోగించి స్ట్రింగ్‌ను సబ్‌స్ట్రింగ్‌లుగా విభజిస్తుంది. పద్ధతి సంతకాన్ని ప్రదర్శించి, మా డైవ్‌ని ప్రారంభిద్దాం:

String[] split(String regex)

సంతకం నుండి రెండు విషయాలు స్పష్టంగా ఉన్నాయి:

1. పద్ధతి స్ట్రింగ్‌ల శ్రేణిని అందిస్తుంది.
2. పద్ధతి regex అనే స్ట్రింగ్ ఇన్‌పుట్ పరామితిని కలిగి ఉంది .

మేము పైన ఇచ్చిన వివరణను విచ్ఛిన్నం చేస్తున్నప్పుడు వీటిలో ప్రతి ఒక్కటి విడిగా విశ్లేషిద్దాం.

1. పద్ధతి స్ట్రింగ్‌ల శ్రేణిని అందిస్తుంది.

   డిక్లరేషన్ కింది పదాలను కలిగి ఉంది: "జావాలో, స్ప్లిట్ పద్ధతి ఒక స్ట్రింగ్‌ను సబ్‌స్ట్రింగ్‌లుగా విభజిస్తుంది." పద్ధతి ఈ సబ్‌స్ట్రింగ్‌లను తిరిగి విలువగా మార్చే శ్రేణిలోకి సేకరిస్తుంది.

2. పద్ధతి 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);
        }
    }
}

ప్రధాన పద్ధతి యొక్క అవుట్పుట్ క్రింది పంక్తులుగా ఉంటుంది: స్ప్లిట్ పద్ధతి ఎలా పని చేస్తుందో మరికొన్ని ఉదాహరణలను చూద్దాం : పై పట్టికలో చివరి రెండు వరుసల మధ్య తేడాలను గమనించండి. రెండవ నుండి చివరి వరుస వరకు, ఒక కామా డీలిమిటర్‌గా ఉపయోగించబడుతుంది. ఫలితంగా, స్ట్రింగ్ విభజించబడినప్పుడు, కొన్ని పదాలు ప్రముఖ ఖాళీలను కలిగి ఉంటాయి. చివరి వరుసలో, మేము మా డీలిమిటర్‌గా కామా మరియు స్పేస్‌ని ఉపయోగించాము. అందుకే ఫలిత శ్రేణిలో లీడింగ్ స్పేస్‌లతో సబ్‌స్ట్రింగ్‌లు లేవు. ఇది సరైన డీలిమిటర్‌ను జాగ్రత్తగా ఎంచుకోవడం ఎంత ముఖ్యమో తెలియజేసే సూక్ష్మ వివరాలు మాత్రమే.

ప్రముఖ డీలిమిటర్

ఇది మరొక ముఖ్యమైన స్వల్పభేదాన్ని. అసలు స్ట్రింగ్ డీలిమిటర్‌తో ప్రారంభమైతే, ఫలిత శ్రేణి యొక్క మొదటి మూలకం ఖాళీ స్ట్రింగ్ అవుతుంది. ఉదాహరణకు, ఇది ఇలా ఉంటుంది: ఒరిజినల్ స్ట్రింగ్: " నేను జావాను ప్రేమిస్తున్నాను" డీలిమిటర్: " " ఫలిత శ్రేణి: { "", "నేను", "ప్రేమ", "జావా" } అయితే అసలు స్ట్రింగ్ డీలిమిటర్‌తో ముగిస్తే ఒకదానితో ప్రారంభం కాకుండా, ఫలితం భిన్నంగా ఉంటుంది: అసలు స్ట్రింగ్: "నేను జావాను ప్రేమిస్తున్నాను" డీలిమిటర్: " " ఫలిత శ్రేణి: { "నేను", "ప్రేమ", "జావా"

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

ఈ పద్ధతి మీ స్వంతంగా ఎలా పనిచేస్తుందో మీరు గుర్తించగలరో లేదో చూడండి. ఈ ఉదాహరణల ఆధారంగా, మేము కొంత డేటాను స్ట్రింగ్‌గా ఫార్మాట్ చేసినప్పుడు స్ప్లిట్ పద్ధతి ఉపయోగించబడుతుంది మరియు మేము దాని నుండి నిర్దిష్ట మరింత నిర్దిష్ట సమాచారాన్ని సంగ్రహించవలసి ఉంటుంది.

సారాంశం

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

• ఒక ప్రముఖ డీలిమిటర్;
• రెండు పారామితులతో దాని ఓవర్‌లోడ్ తోబుట్టువు.

మేము ఊహాజనిత, కానీ చాలా వాస్తవికమైన సమస్యలను పరిష్కరించడానికి విభజన పద్ధతిని ఉపయోగించిన కొన్ని నిజ జీవిత పరిస్థితులను రూపొందించడానికి కూడా ప్రయత్నించాము .