ജാവയിൽ ഒരു സ്‌ട്രിംഗിനെ ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു: ഘട്ടം ഘട്ടമായുള്ള ഗൈഡ്

ജാവയിൽ പൂർണ്ണസംഖ്യയിലേക്കുള്ള പരിവർത്തനം

ജാവ പ്രോഗ്രാമിംഗിൽ ഒരു സ്ട്രിംഗ് ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുക എന്നത് ഒരു സാധാരണ ജോലിയാണ്, കൂടാതെ ഡാറ്റ പ്രോസസ്സിംഗിനും ഉപയോക്തൃ ഇൻപുട്ട് മൂല്യനിർണ്ണയത്തിനും മറ്റ് നിരവധി പ്രവർത്തനങ്ങൾക്കും ഇത് അത്യന്താപേക്ഷിതമാണ്. ഈ പരിവർത്തനം നേടുന്നതിന് ജാവ ഒന്നിലധികം മാർഗങ്ങൾ നൽകുന്നു, ഓരോന്നും വ്യത്യസ്ത സാഹചര്യങ്ങൾക്കും ആവശ്യകതകൾക്കും അനുയോജ്യമാണ്.

ഈ ലേഖനത്തിൽ, ഏറ്റവും കാര്യക്ഷമവും വിശ്വസനീയവുമായ സമീപനങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിച്ച്, "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 ഡാറ്റയിൽ നിന്ന് സ്ട്രിംഗ് എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്ന സാഹചര്യങ്ങൾ നിങ്ങൾ അഭിമുഖീകരിച്ചേക്കാം. അത്തരം സന്ദർഭങ്ങളിൽ, ഡാറ്റ പാഴ്‌സ് ചെയ്യാനും ആവശ്യമായ ഫീൽഡുകൾ പൂർണ്ണസംഖ്യകളാക്കി മാറ്റാനും ജാക്‌സൺ അല്ലെങ്കിൽ ജാക്‌സ് ബി പോലുള്ള ലൈബ്രറികൾ ഉപയോഗിക്കാം.

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