ജാവയിൽ ഒരു സ്ട്രിംഗ് ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു

ജാവയിൽ സ്ട്രിംഗ് ടു ഇൻറ്റ് പരിവർത്തനം മനസ്സിലാക്കുന്നു

ജാവ പ്രോഗ്രാമിംഗിൽ ഒരു സ്ട്രിംഗ് ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുക എന്നത് ഒരു സാധാരണ ജോലിയാണ്. പലപ്പോഴും, വിവിധ കണക്കുകൂട്ടലുകൾക്കും പ്രവർത്തനങ്ങൾക്കുമായി നിങ്ങൾ സ്ട്രിംഗുകളായി പ്രതിനിധീകരിക്കുന്ന സംഖ്യാ മൂല്യങ്ങളെ അവയുടെ പൂർണ്ണസംഖ്യകളാക്കി മാറ്റേണ്ടതുണ്ട്. ഈ പരിവർത്തനം ലളിതമാണ് കൂടാതെ ജാവ ഭാഷ നൽകുന്ന നിരവധി രീതികൾ ഉപയോഗിച്ച് ഇത് നേടാനാകും.

ഈ ലേഖനത്തിൽ, ജാവയിൽ ഒരു സ്ട്രിംഗിനെ ഒരു പൂർണ്ണസംഖ്യയാക്കി മാറ്റുന്നതിനുള്ള വിവിധ സാങ്കേതിക വിദ്യകൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. നിങ്ങൾ ഉപയോക്തൃ ഇൻപുട്ട്, ഡാറ്റ പാഴ്‌സിംഗ് അല്ലെങ്കിൽ ഒരു ഫയലിൽ നിന്നുള്ള സ്ട്രിംഗുകൾ പ്രോസസ്സ് ചെയ്യുക എന്നിവയുമായി ബന്ധപ്പെട്ടാലും, ഈ പരിവർത്തനം എങ്ങനെ കാര്യക്ഷമമായും കൃത്യമായും നടത്താമെന്ന് അറിയുന്നത് ഏതൊരു ജാവ ഡെവലപ്പർക്കും അത്യന്താപേക്ഷിതമാണ്.

സ്ട്രിംഗ് ടു ഇൻറ്റ് പരിവർത്തന രീതികൾ മനസ്സിലാക്കുന്നു

നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകൾ ജാവയിൽ ഒരു സ്ട്രിംഗിനെ ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിനുള്ള വിവിധ രീതികൾ കാണിക്കുന്നു. ആദ്യ രീതി ഉപയോഗിക്കുന്നു Integer.parseInt() കമാൻഡ്, ഇത് ഒരു സാധുവായ പൂർണ്ണസംഖ്യാ പ്രാതിനിധ്യം അടങ്ങിയ ഒരു സ്ട്രിംഗ് ഒരു int തരത്തിലേക്ക് പാഴ്‌സ് ചെയ്യുന്നതിനുള്ള ഒരു നേരായ മാർഗമാണ്. ഈ രീതി കാര്യക്ഷമമാണ് എ എറിയുന്നു NumberFormatException സ്ട്രിംഗ് പാഴ്‌സ് ചെയ്യാൻ കഴിയുന്നില്ലെങ്കിൽ. രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നു Integer.valueOf(), ഇത് സമാനമാണ് Integer.parseInt() എന്നാൽ ഒരു തിരികെ നൽകുന്നു Integer ഒരു പ്രാകൃത സംഖ്യയ്ക്ക് പകരം ഒബ്ജക്റ്റ്. പ്രാകൃത തരങ്ങളേക്കാൾ ഒബ്ജക്റ്റുകൾ ആവശ്യമുള്ള ശേഖരങ്ങളിലോ മറ്റ് ഡാറ്റാ ഘടനകളിലോ പ്രവർത്തിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാകും.

മൂന്നാമത്തെ ഉദാഹരണം അവതരിപ്പിക്കുന്നു Scanner മുതൽ ക്ലാസ് java.util പാക്കേജ്, ഉപയോക്തൃ ഇൻപുട്ട് ഉൾപ്പെടെ വിവിധ ഉറവിടങ്ങളിൽ നിന്നുള്ള ഇൻപുട്ട് വായിക്കാൻ ഉപയോഗപ്രദമാണ്. ദി nextLine() സ്കാനർ ക്ലാസിൻ്റെ രീതി ഇൻപുട്ടിൻ്റെ അടുത്ത വരി ഒരു സ്ട്രിംഗ് ആയി വായിക്കുന്നു, അത് ഉപയോഗിച്ച് ഒരു ഇൻറ്റ് ആയി പരിവർത്തനം ചെയ്യുന്നു Integer.parseInt(). നിങ്ങൾക്ക് ഉപയോക്തൃ ഇൻപുട്ട് ചലനാത്മകമായി കൈകാര്യം ചെയ്യേണ്ടിവരുമ്പോൾ ഈ രീതി പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. നാലാമത്തെ സ്ക്രിപ്റ്റ് a ഉപയോഗിച്ച് പിശക് കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു പാളി ചേർക്കുന്നു try-catch പിടിക്കാൻ തടയുക NumberFormatException. സ്ട്രിംഗ് ഒരു പൂർണ്ണസംഖ്യയായി പാഴ്‌സ് ചെയ്യാൻ കഴിയുന്നില്ലെങ്കിൽ, പ്രോഗ്രാമിന് ക്രാഷുചെയ്യാതെ തന്നെ പിശക് ഭംഗിയായി കൈകാര്യം ചെയ്യാൻ കഴിയുമെന്ന് ഇത് ഉറപ്പാക്കുന്നു.

Integer.parseInt ഉപയോഗിച്ച് ജാവയിൽ ഒരു സ്ട്രിംഗ് ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു

ജാവയുടെ ബിൽറ്റ്-ഇൻ ഇൻ്റിജർ ക്ലാസ് ഉപയോഗിക്കുന്നു

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

ജാവയിൽ Integer.valueOf ഉപയോഗിച്ച് പൂർണ്ണസംഖ്യയിലേക്കുള്ള പരിവർത്തനം

ജാവയുടെ Integer.valueOf രീതി നടപ്പിലാക്കുന്നു

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

സ്കാനർ ഉപയോഗിച്ച് ജാവയിൽ ഒരു സ്ട്രിംഗ് ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു

പരിവർത്തനത്തിനായി ജാവയുടെ സ്കാനർ ക്ലാസ് ഉപയോഗിക്കുന്നു

import java.util.Scanner;
public class StringToIntExample3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a number: ");
        String str = scanner.nextLine();
        int number = Integer.parseInt(str);
        System.out.println("Converted number: " + number);
    }
}

പിശക് കൈകാര്യം ചെയ്യുന്നതിനായി ട്രൈ-ക്യാച്ച് ഉപയോഗിച്ച് ജാവയിൽ ഒരു സ്ട്രിംഗ് ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു

ജാവയിലെ ട്രൈ-ക്യാച്ച് ബ്ലോക്കുകൾക്കൊപ്പം പിശക് കൈകാര്യം ചെയ്യൽ സംയോജിപ്പിക്കുന്നു

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

ഇതര സ്ട്രിംഗ് മുതൽ പൂർണ്ണസംഖ്യ പരിവർത്തന രീതികൾ പര്യവേക്ഷണം ചെയ്യുന്നു

ഇതിനകം ചർച്ച ചെയ്ത രീതികൾ കൂടാതെ, ജാവയിലെ ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് ഒരു സ്ട്രിംഗ് പരിവർത്തനം ചെയ്യുന്നതിനുള്ള മറ്റൊരു മാർഗ്ഗം അപ്പാച്ചെ കോമൺസ് ലാംഗ് പോലുള്ള മൂന്നാം കക്ഷി ലൈബ്രറികൾ ഉപയോഗിക്കുന്നത് ഉൾപ്പെടുന്നു. ദി NumberUtils ഈ ലൈബ്രറിയിൽ നിന്നുള്ള ക്ലാസ് ഒരു യൂട്ടിലിറ്റി രീതി നൽകുന്നു, NumberUtils.toInt(), ഇത് പരിവർത്തനത്തിന് ഉപയോഗിക്കാം. ഈ രീതി പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും, കാരണം ഇത് പരിവർത്തനം പരാജയപ്പെടുകയാണെങ്കിൽ സ്ഥിരസ്ഥിതി മൂല്യം തിരികെ നൽകുക, ഒഴിവാക്കലുകൾ ഒഴിവാക്കുക, കോഡ് കൂടുതൽ ശക്തമാക്കുക തുടങ്ങിയ അധിക സവിശേഷതകൾ നൽകുന്നു.

മറ്റൊരു രസകരമായ രീതി ഉപയോഗിക്കുന്നത് DecimalFormat മുതൽ ക്ലാസ് java.text പാക്കേജ്. ദശാംശ സംഖ്യകൾ ഫോർമാറ്റ് ചെയ്യുന്നതിന് പ്രാഥമികമായി ഉപയോഗിക്കുന്നുണ്ടെങ്കിലും, ഇതിന് സ്ട്രിംഗുകളെ അക്കങ്ങളാക്കി പാഴ്‌സ് ചെയ്യാനും കഴിയും. ഒരു ഉദാഹരണം സൃഷ്ടിച്ചുകൊണ്ട് DecimalFormat അതിൻ്റെ ഉപയോഗവും parse() രീതി, ഒരു സ്ട്രിംഗ് ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യാനും തുടർന്ന് ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് കാസ്‌റ്റ് ചെയ്യാനും കഴിയും. ഈ സമീപനം സാധാരണമല്ലെങ്കിലും നമ്പർ ഫോർമാറ്റിംഗ് ആവശ്യമായ പ്രത്യേക സാഹചര്യങ്ങളിൽ ഇത് ഉപയോഗപ്രദമാകും. ഈ ബദൽ രീതികൾ മനസ്സിലാക്കുന്നത് സ്ട്രിംഗ് ടു ഇൻ്റിജർ പരിവർത്തനത്തെക്കുറിച്ചുള്ള വിശാലമായ വീക്ഷണം നൽകുകയും ആപ്ലിക്കേഷൻ്റെ നിർദ്ദിഷ്ട ആവശ്യകതകളെ അടിസ്ഥാനമാക്കി മികച്ച രീതി തിരഞ്ഞെടുക്കാൻ സഹായിക്കുകയും ചെയ്യുന്നു.

ജാവയിലെ സ്ട്രിംഗ് ടു ഇൻ്റിജർ പരിവർത്തനത്തെക്കുറിച്ചുള്ള പൊതുവായ ചോദ്യങ്ങളും ഉത്തരങ്ങളും

1. സ്ട്രിംഗിൽ അക്കമല്ലാത്ത പ്രതീകങ്ങൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ എന്ത് സംഭവിക്കും?
2. സ്ട്രിംഗിൽ നോൺ-സംഖ്യാ പ്രതീകങ്ങൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, രീതികൾ Integer.parseInt() ഒപ്പം Integer.valueOf() എ എറിയും NumberFormatException.
3. പരിവർത്തന പിശകുകൾ എങ്ങനെ ഭംഗിയായി കൈകാര്യം ചെയ്യാം?
4. നിങ്ങൾക്ക് എ ഉപയോഗിക്കാം try-catch പിടിക്കാൻ തടയുക NumberFormatException കൂടാതെ പിഴവ് ഭംഗിയായി കൈകാര്യം ചെയ്യുക.
5. പരിവർത്തനം പരാജയപ്പെടുകയാണെങ്കിൽ ഒരു സ്ഥിര മൂല്യം നൽകാൻ എന്തെങ്കിലും വഴിയുണ്ടോ?
6. അതെ, Apache Commons Lang's ഉപയോഗിക്കുന്നു NumberUtils.toInt() രീതി, പരിവർത്തനം പരാജയപ്പെടുകയാണെങ്കിൽ തിരികെ നൽകുന്നതിന് നിങ്ങൾക്ക് ഒരു സ്ഥിരസ്ഥിതി മൂല്യം വ്യക്തമാക്കാൻ കഴിയും.
7. ഒരു ദശാംശ പോയിൻ്റുള്ള ഒരു സ്ട്രിംഗ് എനിക്ക് ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യാൻ കഴിയുമോ?
8. അത്തരം ഒരു സ്ട്രിംഗ് നേരിട്ട് പരിവർത്തനം ചെയ്യുന്നത് ഒരു അപവാദം എറിയും. നിങ്ങൾ അത് ആദ്യം a ലേക്ക് പാഴ്സ് ചെയ്യണം float അഥവാ double, പിന്നെ ഒരു കാസ്റ്റ് int.
9. എന്താണ് തമ്മിലുള്ള വ്യത്യാസം Integer.parseInt() ഒപ്പം Integer.valueOf()?
10. Integer.parseInt() ഒരു പ്രാകൃത സംഖ്യ നൽകുന്നു, അതേസമയം Integer.valueOf() ഒരു തിരികെ നൽകുന്നു Integer വസ്തു.
11. എനിക്ക് ഉപയോഗിക്കാമോ Scanner ഒരു കൺസോൾ ആപ്ലിക്കേഷനിൽ പരിവർത്തനം ചെയ്യണോ?
12. അതെ, ദി Scanner ഉപയോക്തൃ ഇൻപുട്ട് വായിക്കുന്നതിനും സ്ട്രിംഗുകൾ പൂർണ്ണസംഖ്യകളാക്കി മാറ്റുന്നതിനും ക്ലാസ് അനുയോജ്യമാണ്.
13. കോഡിൻ്റെ ഒരു വരിയിൽ ഒരു സ്ട്രിംഗിനെ ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യാൻ എന്തെങ്കിലും രീതിയുണ്ടോ?
14. അതെ, നിങ്ങൾക്ക് ഉപയോഗിക്കാം Integer.parseInt() അഥവാ Integer.valueOf() ഒരു സ്ട്രിംഗിനെ ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യാൻ ഒരൊറ്റ വരിയിൽ.

സ്ട്രിംഗ് ടു ഇൻറ്റ് പരിവർത്തനത്തെക്കുറിച്ചുള്ള ചർച്ചകൾ പൊതിയുന്നു

ജാവയിൽ ഒരു സ്ട്രിംഗ് ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നത് വിവിധ രീതികൾ ഉപയോഗിച്ച് പൂർത്തിയാക്കാൻ കഴിയുന്ന ഒരു അടിസ്ഥാന കഴിവാണ്. ശരിയായ രീതി മനസ്സിലാക്കുന്നതും തിരഞ്ഞെടുക്കുന്നതും നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ പ്രത്യേക ആവശ്യങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു. പോലുള്ള അടിസ്ഥാന രീതികൾ നിങ്ങൾ ഉപയോഗിക്കുന്നുണ്ടോ എന്ന് Integer.parseInt() ഒപ്പം Integer.valueOf(), അല്ലെങ്കിൽ ഇതുപോലുള്ള കൂടുതൽ ശക്തമായ പരിഹാരങ്ങൾ Scanner ക്ലാസ്, തേർഡ്-പാർട്ടി ലൈബ്രറികൾ, ഈ ടെക്നിക്കുകൾ മാസ്റ്റേഴ്സ് ചെയ്യുന്നത് നിങ്ങൾക്ക് കാര്യക്ഷമമായും ഫലപ്രദമായും പൂർണ്ണസംഖ്യകളിലേക്കുള്ള പരിവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു.