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

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

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

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

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

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

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

Integer.parseInt ஐப் பயன்படுத்தி ஜாவாவில் சரத்தை முழு எண்ணாக மாற்றுவது எப்படி

ஜாவாவைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு

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

Integer.valueOf ஐப் பயன்படுத்தி ஜாவாவில் சரத்தை முழு எண்ணாக மாற்றுகிறது

ஜாவாவைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு

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. சரத்தை மாற்ற முயற்சிக்கும் முன் அதை சரிபார்ப்பது ஒரு நல்ல நடைமுறை. சரம் பூஜ்யமாக இல்லை மற்றும் வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்தி எண் வடிவத்துடன் பொருந்துகிறதா என்பதைச் சரிபார்ப்பதன் மூலம் இதைச் செய்யலாம்.

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

1. ஜாவாவில் ஒரு சரத்தை முழு எண்ணாக மாற்றுவது எப்படி?
2. நீங்கள் பயன்படுத்தலாம் Integer.parseInt அல்லது Integer.valueOf ஒரு சரத்தை முழு எண்ணாக மாற்ற.
3. சரம் சரியான முழு எண்ணாக இல்லாவிட்டால் என்ன நடக்கும்?
4. இரண்டும் Integer.parseInt மற்றும் Integer.valueOf ஒரு எறிவார்கள் NumberFormatException.
5. மாற்றத்தின் போது பிழைகளை எவ்வாறு கையாளலாம்?
6. பயன்படுத்தவும் try மற்றும் catch கையாள தடை NumberFormatException மற்றும் ஒரு பிழை செய்தியை அச்சிடவும்.
7. Integer.parseInt மற்றும் Integer.valueOf இடையே வேறுபாடு உள்ளதா?
8. ஆம், Integer.parseInt ஒரு primitive int ஐத் தருகிறது Integer.valueOf ஒரு முழு எண் பொருளை வழங்குகிறது.
9. எண் அல்லாத எழுத்துக்களைக் கொண்ட சரத்தை முழு எண்ணாக மாற்ற முடியுமா?
10. இல்லை, அத்தகைய சரத்தை மாற்ற முயல்வது ஒரு NumberFormatException.
11. சரத்திற்கு முழு எண் மாற்றத்தில் வழக்கமான வெளிப்பாடுகளின் பங்கு என்ன?
12. ஒரு சரம் மாற்றுவதற்கு முன் எண் எழுத்துக்களை மட்டுமே கொண்டுள்ளது என்பதை சரிபார்க்க வழக்கமான வெளிப்பாடுகள் பயன்படுத்தப்படலாம்.
13. பயனர் உள்ளீட்டிலிருந்து படிக்கும்போது ஒரு சரத்தை முழு எண்ணாக மாற்றுவது எப்படி?
14. நீங்கள் பயன்படுத்தலாம் Scanner வகுப்பு மற்றும் அதன் nextInt பயனர் உள்ளீட்டை நேரடியாகப் படித்து மாற்றும் முறை.

சரத்திற்கு முழு எண் மாற்றத்திற்கான இறுதி எண்ணங்கள்

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