Java String.split() முறை

ஜாவாவின் String.split முறையைப் பற்றி பேசலாம் : அது என்ன செய்கிறது மற்றும் ஏன் தேவைப்படுகிறது. இது ஒரு ஜாவா சரத்தை பிரிக்கிறது என்று யூகிக்க கடினமாக இல்லை, ஆனால் இது நடைமுறையில் எவ்வாறு செயல்படுகிறது? முறையின் செயல்பாட்டில் ஆழமாக மூழ்கி, சில வெளிப்படையான விவரங்களைப் பற்றி விவாதிப்போம். அதே நேரத்தில், சரம் உண்மையில் எத்தனை பிளவு முறைகளைக் கொண்டுள்ளது என்பதைக் கற்றுக்கொள்வோம் . போகலாம்!

Java's 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;
    }
}

இந்த முறை எவ்வாறு செயல்படுகிறது என்பதை நீங்களே கண்டுபிடிக்க முடியுமா என்று பாருங்கள். இந்த எடுத்துக்காட்டுகளின் அடிப்படையில், சில தரவு சரமாக வடிவமைக்கப்படும்போது, ​​​​பிளவு முறை பயன்படுத்தப்படுகிறது என்று கூறலாம் , மேலும் அதிலிருந்து சில குறிப்பிட்ட தகவலைப் பிரித்தெடுக்க வேண்டும்.

சுருக்கம்

சரம் வகுப்பின் பிளவு முறையை நாங்கள் ஆய்வு செய்தோம் . ஒரு பிரத்யேக டிலிமிட்டரின் உதவியுடன் ஒரு சரத்தை அதன் கூறு பாகங்களாகப் பிரிக்க வேண்டியிருக்கும் போது இது உங்களுக்குத் தேவையானது. இந்த முறை சரங்களின் வரிசையை வழங்குகிறது (அசல் சரத்தை உள்ளடக்கிய துணைச்சரங்கள்). இது வழக்கமான வெளிப்பாட்டை ஏற்றுக்கொள்கிறது, அதன் பொருத்தங்கள் டிலிமிட்டர் எழுத்து(களை) குறிக்கும். இந்த முறையின் பல்வேறு நுணுக்கங்களை நாங்கள் ஆராய்ந்தோம்:

• ஒரு முன்னணி டிலிமிட்டர்;
• இரண்டு அளவுருக்கள் கொண்ட அதன் ஓவர்லோடட் உடன்பிறப்பு.

கற்பனையான, ஆனால் மிகவும் யதார்த்தமான சிக்கல்களைத் தீர்க்க பிளவு முறையைப் பயன்படுத்திய சில நிஜ வாழ்க்கைச் சூழ்நிலைகளையும் மாதிரியாகக் காட்ட முயற்சித்தோம் .