ஜாவாவில் ஒரு சரத்தை முழு எண்ணாக மாற்றுதல்: படி-படி-படி வழிகாட்டி

ஜாவாவில் சரம் முழு எண் மாற்றும்

ஜாவா நிரலாக்கத்தில் ஒரு சரத்தை முழு எண்ணாக மாற்றுவது ஒரு பொதுவான பணியாகும், மேலும் இது தரவு செயலாக்கம், பயனர் உள்ளீடு சரிபார்ப்பு மற்றும் பல செயல்பாடுகளுக்கு அவசியம். இந்த மாற்றத்தை அடைவதற்கு Java பல வழிகளை வழங்குகிறது, ஒவ்வொன்றும் வெவ்வேறு காட்சிகள் மற்றும் தேவைகளுக்கு ஏற்றது.

இந்தக் கட்டுரையில், "1234" போன்ற சரம் மதிப்பை முழு எண் வகையாக மாற்றும் முறைகளை ஆராய்வோம், மிகவும் திறமையான மற்றும் நம்பகமான அணுகுமுறைகளில் கவனம் செலுத்துவோம். நீங்கள் ஒரு தொடக்கக்காரராக இருந்தாலும் அல்லது அனுபவம் வாய்ந்த டெவலப்பராக இருந்தாலும், இந்த நுட்பங்களைப் புரிந்துகொள்வது உங்கள் குறியீட்டு திறன்களை மேம்படுத்துவதோடு உங்கள் ஜாவா பயன்பாடுகளையும் மேம்படுத்தும்.

ஜாவா ஸ்டிரிங் முதல் முழு எண் மாற்றத்தைப் புரிந்துகொள்வது

முதல் ஸ்கிரிப்ட் ஒரு சரத்தை எப்படி முழு எண்ணாக மாற்றுவது என்பதை விளக்குகிறது Integer.parseInt. இந்த முறை நேரடியானது மற்றும் ஒரு வீசுகிறது NumberFormatException சரம் சரியான முழு எண்ணாக இல்லாவிட்டால். தி System.out.println கன்சோலுக்கு மாற்றும் முடிவை அச்சிட கட்டளை பயன்படுத்தப்படுகிறது. இந்த எடுத்துக்காட்டில், சரம் "1234" வெற்றிகரமாக முழு எண் 1234 ஆக மாற்றப்பட்டது. இரண்டாவது ஸ்கிரிப்ட் பயன்படுத்துகிறது Integer.valueOf, இது ஒரு சரத்தை முழு எண்ணாக மாற்றுகிறது, ஆனால் ஒரு வரியை வழங்குகிறது Integer பொருள். இந்த பொருள் பின்னர் ஒரு எண்ணாக அன்பாக்ஸ் செய்யப்படுகிறது. இந்த முறை ஒத்ததாகும் Integer.parseInt ஆனால் பெரும்பாலும் சூழல்களில் பயன்படுத்தப்படுகிறது Integer பொருள் தேவை.

மூன்றாவது ஸ்கிரிப்ட் a ஐப் பயன்படுத்தி மாற்று செயல்முறைக்கு பிழை கையாளுதலை சேர்க்கிறது try மற்றும் catch தொகுதி. சரத்தை முழு எண்ணாக பாகுபடுத்த முடியாவிட்டால், a NumberFormatException பிடிபட்டது, மற்றும் ஒரு பிழை செய்தி அச்சிடப்பட்டது System.out.println. பயனர் உள்ளீடு அல்லது வெளிப்புறத் தரவைக் கையாளும் போது இந்த அணுகுமுறை பயனுள்ளதாக இருக்கும், அங்கு உள்ளீட்டு வடிவமைப்பிற்கு உத்தரவாதம் இல்லை. விதிவிலக்கைப் பிடிப்பதன் மூலம், நிரல் செயலிழக்காமல் பிழையைக் கையாள முடியும். இந்த ஸ்கிரிப்ட் சாத்தியமான பிழைகளை திறம்பட நிர்வகிக்கும் போது சரங்களை முழு எண்களாக மாற்றுவதற்கான ஒரு வலுவான வழியை நிரூபிக்கிறது.

public class StringToIntExample1 {
    public static void main(String[] args) {
        String number = "1234";
        int result = Integer.parseInt(number);
        System.out.println("String to int using Integer.parseInt: " + result);
    }
}

public class StringToIntExample2 {
    public static void main(String[] args) {
        String number = "1234";
        int result = Integer.valueOf(number);
        System.out.println("String to int using Integer.valueOf: " + result);
    }
}

public class StringToIntExample3 {
    public static void main(String[] args) {
        String number = "1234a";
        try {
            int result = Integer.parseInt(number);
            System.out.println("Conversion successful: " + result);
        } catch (NumberFormatException e) {
            System.out.println("Invalid number format: " + e.getMessage());
        }
    }
}

ஜாவாவில் சரம் முதல் முழு எண் மாற்றத்திற்கான மேம்பட்ட நுட்பங்கள்

ஜாவாவில் ஒரு சரத்தை முழு எண்ணாக மாற்றுவதற்கான அடிப்படை முறைகளைத் தவிர Integer.parseInt மற்றும் Integer.valueOf, பல்வேறு சூழ்நிலைகளில் பயனுள்ளதாக இருக்கும் பிற மேம்பட்ட நுட்பங்களும் பரிசீலனைகளும் உள்ளன. உதாரணமாக, பயன்படுத்தி Scanner அல்லது BufferedReader பயனர் உள்ளீட்டைப் படிக்க வகுப்புகள் மற்றும் உள்ளீட்டு சரத்தை முழு எண்ணாக மாற்றும். தி Scanner வர்க்கம் என்று ஒரு முறை உள்ளது nextInt இது உள்ளீட்டிலிருந்து ஒரு முழு எண்ணை நேரடியாகப் படித்து, மாற்றும் செயல்முறையை எளிதாக்குகிறது. கூடுதலாக, நிறுவன பயன்பாடுகளில், JSON அல்லது XML தரவிலிருந்து சரம் பிரித்தெடுக்கப்படும் காட்சிகளை நீங்கள் சந்திக்கலாம். இது போன்ற சமயங்களில், Jackson அல்லது JAXB போன்ற நூலகங்கள் தரவை அலசவும், பின்னர் தேவையான புலங்களை முழு எண்களாக மாற்றவும் பயன்படுத்தப்படலாம்.

கருத்தில் கொள்ள வேண்டிய மற்றொரு முக்கியமான அம்சம் செயல்திறன். அதிக எண்ணிக்கையிலான மாற்றங்களைக் கையாளும் போது, ​​வெவ்வேறு முறைகளின் செயல்திறனை மதிப்பிடுவது பயனுள்ளதாக இருக்கும். உதாரணமாக, Integer.parseInt விட பொதுவாக வேகமானது Integer.valueOf ஏனெனில் பிந்தையது ஒரு முழு எண் பொருளுக்கு பழமையான எண்ணை குத்துச்சண்டை செய்வதற்கான கூடுதல் படியை உள்ளடக்கியது. கூடுதலாக, பூஜ்ய அல்லது வெற்று சரங்களைக் கையாள்வது தடுக்க மிகவும் முக்கியமானது NullPointerException அல்லது NumberFormatException. சரத்தை மாற்ற முயற்சிக்கும் முன் அதை சரிபார்ப்பது ஒரு நல்ல நடைமுறை. சரம் பூஜ்யமாக இல்லை மற்றும் வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்தி எண் வடிவத்துடன் பொருந்துகிறதா என்பதைச் சரிபார்ப்பதன் மூலம் இதைச் செய்யலாம்.