జావా ఉదాహరణలతో చార్‌ని Intకి మార్చండి

వినియోగదారులు కీబోర్డ్ నుండి నమోదు చేసే చాలా తరచుగా సంకేత సమాచారం సంఖ్యలుగా మార్చబడాలి లేదా ప్రోగ్రామర్ దాని నుండి సంఖ్యలను పొందాలి. దీన్ని చేయడానికి జావాలో కొన్ని పద్ధతులు ఉన్నాయి. ఈ కథనంలో, చార్‌ను పూర్ణాంక విలువగా మార్చడంలో మాకు సహాయపడే పద్ధతులను మేము కనుగొంటాము.

అవ్యక్త రకం сasting

టైప్ కాస్టింగ్ అనేది ఒక డేటా రకం విలువను మరొక డేటా రకం విలువగా మార్చే ప్రక్రియ. టైప్ కాస్టింగ్ అనేది రకాలను బట్టి మాన్యువల్ లేదా ఆటోమేటిక్‌గా ఉండవచ్చు. రకాలు అనుకూలంగా ఉండాలి. జావాలో మనకు స్పష్టమైన మరియు అవ్యక్తమైన రెండు రకాల టైప్‌కాస్టింగ్ ఉంది. మనం వేరియబుల్‌ని " పెద్ద" నుండి "చిన్న" రకానికి మార్చినట్లయితే మాత్రమే అవ్యక్తంగా చేయవచ్చు (చెప్పండి, పూర్ణాంకానికి పొడవుగా) మేము చార్ టైప్ యొక్క వేరియబుల్‌ను Int డేటా టైప్‌గా మార్చాలనుకుంటే, చాలా తరచుగా మనం ASCII పట్టిక నుండి దాని సమానమైన విలువను పొందాలి. డిజిటల్‌గా నమోదు చేయగల ప్రతి అక్షరం లేదా చిహ్నం సంబంధిత ప్రత్యేక పూర్ణాంకం సంఖ్యను కలిగి ఉంటుంది. ఉదాహరణకు, 'A' వర్ణమాల 65 యొక్క ASCII కోడ్‌ని కలిగి ఉంది. టైప్ కాస్టింగ్ ద్వారా, మేము అక్షర విలువను దాని సమానమైన ASCII పూర్ణాంక కోడ్‌గా బలవంతంగా మారుస్తున్నాము. టైప్ కాస్టింగ్ ఉపయోగించి పూర్ణాంక ఉదాహరణకి మా జావా చార్ ఇక్కడ ఉంది.

జావా చార్ నుండి పూర్ణాంకానికి ఉదాహరణ (టైప్‌కాస్టింగ్ ఉపయోగించి)

package charToInt;

public class Implicit {

       public static void main(String[] args) {
           char char1 = 'A';
           char char2 = 'a';
           int x = char1;
           int y = char2;

           System.out.println("ASCII value of '" + char1 + "' is " + x);
           System.out.println("ASCII value of '" + char2 + "' is " + y);
       }
   }

అవుట్‌పుట్:

స్పష్టమైన రకం కాస్టింగ్

మనం పైన చూసినట్లుగా, చార్ నుండి పూర్ణాంకానికి మార్పిడి విషయంలో, దీన్ని స్పష్టంగా చేయవలసిన అవసరం లేదు, ఎందుకంటే చార్‌ను నిల్వ చేయడానికి 2 బైట్‌లు మరియు పూర్ణాన్ని నిల్వ చేయడానికి 4 బైట్లు ఉపయోగించబడతాయి. అంటే, Int రకం "పెద్దది". అయినప్పటికీ, ఒక వ్యాయామంగా, మనం చార్ వేరియబుల్‌ని పూర్ణాంకానికి స్పష్టంగా ప్రసారం చేయవచ్చు. ఈ ఆపరేషన్ కోసం, మేము కుండలీకరణాల్లో (పూర్ణాంకానికి) పేర్కొన్నాము.

package charToInt;

public class Explicit {

       public static void main(String[] args) {
           char char1 = 'A';
           System.out.println("ASCII value of '" + char1 + "' is " + (int)char1);
       }
   }

అవుట్‌పుట్:

getNumericValue()ని ఉపయోగించడం

getNumericValue() టైప్ కాస్టింగ్ మాదిరిగానే పనిచేస్తుంది, కానీ ASCII పట్టికను అనుసరించడానికి బదులుగా, ఇది యూనికోడ్ ఎన్‌కోడింగ్ ప్రమాణాన్ని అనుసరిస్తుంది. ASCII లాటిన్ అక్షరాలు (అదనంగా కొన్ని జాతీయ వర్ణమాల చిహ్నాలు), సంఖ్యలు, విరామచిహ్నాలు మరియు నియంత్రణ అక్షరాలు వంటి నిర్దిష్ట చిహ్నాలు మరియు అక్షరాలను మాత్రమే సూచించగలదు. యూనికోడ్ ప్రపంచంలోని ప్రతి భాషకు అక్షరాలు మరియు చిహ్నాలను కలిగి ఉన్న మిలియన్ విలువలను కలిగి ఉంది. ఉదాహరణకు, యూనికోడ్‌లో A యొక్క విలువ \u0041, ఇది 10 యొక్క సంఖ్యా విలువకు సమానం. అక్షరానికి సంఖ్యా విలువ లేకపోతే, పద్ధతి -1ని అందిస్తుంది. ఈ పద్ధతిని ఉపయోగించడం వలన నాన్-నెగటివ్ పూర్ణాంకాలను తిరిగి పొందడం సౌకర్యంగా ఉంటుంది.

package charToInt;

public class UsingGetNumericValue {

       public static void main(String[] args) {
           char char1 = '7';
           char char2 = 'A';
           char char3 = '*';

           int x = Character.getNumericValue(char1);
           int y = Character.getNumericValue(char2);
           int z = Character.getNumericValue(char3);

           System.out.println("The Unicode value of '" + char1 + "' is " + x);
           System.out.println("The Unicode value of '" + char2 + "' is " + y);
           System.out.println("The Unicode value of '" + char3 + "' is " + z);

       }
   }

అవుట్‌పుట్:

ParseInt()ని ఉపయోగించడం

ParseInt() అనేది చార్‌ను పూర్ణాంకానికి మార్చడానికి మరొక పద్ధతి. ఇది ఇతర సంఖ్యా డేటా రకాలతో పాటు ఫ్లోట్, డబుల్ మరియు లాంగ్ వంటి వాటి మధ్య క్రాస్ కన్వర్ట్ చేయడానికి కూడా విస్తృతంగా ఉపయోగించబడుతుంది. ParseInt() కి కనీసం ఒక ఆర్గ్యుమెంట్ మరియు గరిష్టంగా రెండు ఆర్గ్యుమెంట్‌లు అవసరం. మొదటి ఆర్గ్యుమెంట్ మనం మారుస్తున్న విలువ యొక్క వేరియబుల్ పేరు. రెండవ వాదన రాడిక్స్, ఇది దశాంశం, అష్టాంశం, హెక్సాడెసిమల్ మొదలైన వాటి మూల విలువను సూచిస్తుంది. ParseInt() యొక్క సామర్థ్యం కారణంగా సంఖ్యా వ్యవస్థను దృష్టిలో ఉంచుకుని డేటా రకాలను మార్చడానికి ఇది సరైన ఎంపిక. ” char to int జావాలో. మీరు ఈ పద్ధతిని ఉపయోగించాలనుకుంటే గుర్తుంచుకోవలసిన రెండు ముఖ్యమైన అంశాలు ఉన్నాయి. parseInt()పద్ధతి స్ట్రింగ్ ఆర్గ్యుమెంట్‌లను మాత్రమే అంగీకరిస్తుంది, కాబట్టి మీరు ముందుగా చార్‌ను స్ట్రింగ్‌గా మార్చాలి ( String.valueOf ఉపయోగించి ). చార్ డేటా రకంలో నిల్వ చేయబడిన సంఖ్యా విలువలు మినహా వర్ణమాలలు లేదా ఇతర చిహ్నాలను మార్చడానికి మీరు parseInt()ని ఉపయోగించలేరు . మీరు సంఖ్యేతర విలువలను ఇన్‌పుట్ చేస్తే, మీరు ఎర్రర్‌ను పొందుతారు. ఇక్కడ ఒక జావా ఉదాహరణ:

package charToInt;

public class ParseInt {
       public static void main(String args[]){
           char ch = '7';
           int n = Integer.parseInt(String.valueOf(ch));
           System.out.println(n);
       }
   }

అవుట్‌పుట్: parseInt టన్ను సంఖ్యేతర విలువను ఉపయోగించడానికి ప్రయత్నిద్దాం:

package charToInt;

public class ParseInt {
       public static void main(String args[]){
           char ch = 'q';
           int n = Integer.parseInt(String.valueOf(ch));
           System.out.println(n);
       }
   }

అవుట్‌పుట్:

'0' తీసివేస్తోంది

అక్షరాన్ని పూర్ణాంకానికి మార్చడానికి చాలా సులభమైన మార్గం ఉంది. దీన్ని చేయడానికి, అక్షరం నుండి "0" అక్షరం యొక్క ASCII విలువను తీసివేయండి. ఉదాహరణకు, "7" అక్షరం నుండి Int 7ని పొందడానికి:

int intValue = '7'-' 0 ';

పూర్ణాంకాల అక్షరాల కోసం ప్రత్యేకంగా పూర్ణాంక విలువలను పొందడానికి ఇది పని చేస్తుందని గమనించండి! మీరు '0' నుండి తీసివేస్తే, 'A' అని చెప్పండి, పద్ధతి కేవలం సున్నా యొక్క ASCII కోడ్‌లు మరియు అక్షరం A మధ్య వ్యత్యాసాన్ని అందిస్తుంది. ఇక్కడ ఒక ఉదాహరణ ఉంది.

package charToInt;

public class SubtractingZero {

   public static void main(String[] args) {
       char char1 = '7';
       char char2 = 'A';
       char char3 = '*';

       System.out.println(char1);
       System.out.println(char1 - '0');

       System.out.println(char2);
       System.out.println(char2 - '0');

       System.out.println(char3);
       System.out.println(char3 - '0');

   }

}

అవుట్‌పుట్:

ముగింపులు

మీరు జావాలో చార్‌ను పూర్ణాంకానికి మార్చాలనుకుంటే, పద్ధతుల్లో ఒకదాన్ని ఉపయోగించండి:

• అవ్యక్త రకం కాస్టింగ్ //ASCII విలువలను పొందడం
• Character.getNumericValue()
• Integer.parseInt() //String.valueOf()) తో జతగా
• '0' తీసివేయడం //పూర్ణాంకం సంఖ్యా విలువలకు మాత్రమే పని చేస్తుంది

మీరు స్పష్టమైన రకం కాస్టింగ్ కూడా చేయవచ్చు. అయితే, ఇది అనవసరమైన ఆపరేషన్: ఇది అవసరం లేదు, కానీ కేవలం జావాలో పనిచేస్తుంది.