బూలియన్ విలువను అందించే పద్ధతులు చాలా తరచుగా "is" అనే పదంతో ప్రారంభమవుతాయి మరియు తనిఖీ చేయబడిన మూలకం ఒక నిర్దిష్ట స్థితికి సరిపోతుందో లేదో తనిఖీ చేయడం అని అర్థం. ఈ కథనంలో మనం చర్చించబోయే Character.isDigit() పద్ధతి, పేర్కొన్న చార్ విలువ అంకె కాదా అని నిర్ణయిస్తుంది .

Java isDigit పద్ధతి సింటాక్స్

java.lang.Character.isDigit(char ch) అనేది జావాలో అంతర్నిర్మిత పద్ధతి, ఇది పేర్కొన్న అక్షరం అంకెలా కాదా అని నిర్ణయిస్తుంది. జావా ప్రోగ్రామింగ్ సందర్భంలో "ఒక అంకె" అంటే ఏమిటి? Java డాక్‌లోని నిర్వచనం ప్రకారం, Character.getType(ch) పద్ధతి DECIMAL_DIGIT_NUMBER స్థిరాంకాన్ని అందిస్తే, అక్షరం ఒక అంకె. అంకెలను కలిగి ఉన్న కొన్ని యూనికోడ్ అక్షర పరిధులు క్రిందివి:

  • '\u0030' నుండి '\u0039' వరకు ISO-LATIN-1 అంకెలు ('0' నుండి '9' వరకు)

  • '\u0660' నుండి '\u0669' వరకు అరబిక్-ఇండిక్ అంకెలు ఉన్నాయి

  • '\u06F0' నుండి'\u06F9' వరకు విస్తరించిన అరబిక్-ఇండిక్ అంకెలు

  • '\u0966' నుండి '\u096F' వరకు దేవనాగరి అంకెలు

  • \uFF10' నుండి '\uFF19' వరకు పూర్తి వెడల్పు అంకెలు

అంకెలను కలిగి ఉన్న మరికొన్ని పరిధులు కూడా ఉన్నాయి. అయినప్పటికీ, చాలా తరచుగా మేము '\u0030' నుండి '\u0039' వరకు అంకెలను ఉపయోగించబోతున్నాము. Character.isDigit() యొక్క సింటాక్స్ ఇక్కడ ఉంది: 

public static boolean isDigit(char myChar)
ఇక్కడ myChar అనేది పరీక్షించాల్సిన పాత్ర. అక్షరం అంకె అయితే ఈ పద్ధతి ఒప్పు అని మరియు లేకపోతే తప్పు అని చూపుతుంది . జావా డాక్ isDigit(char myChar) పద్ధతి ప్రకారం అనుబంధ అక్షరాలను నిర్వహించలేదు. అనుబంధ అక్షరాలతో సహా అన్ని యూనికోడ్ అక్షరాలకు మద్దతు ఇవ్వడానికి, ప్రోగ్రామర్ isDigit(int) పద్ధతిని ఉపయోగించాలి. ఇది అదే విధంగా కనిపిస్తుంది, కానీ, OOP మరియు పాలిమార్ఫిజం మద్దతు కారణంగా కొద్దిగా భిన్నంగా పనిచేస్తుంది. పబ్లిక్ స్టాటిక్ బూలియన్ isDigit(int codePoint) పేర్కొన్న అక్షరం (యూనికోడ్ కోడ్ పాయింట్) అంకె అని నిర్ణయిస్తుంది. అక్షర ఎన్‌కోడింగ్ పరిభాషలో, కోడ్ పాయింట్ లేదా కోడ్ స్థానం అనేది నిర్దిష్ట అక్షరానికి అనుగుణంగా ఉండే సంఖ్యా విలువ.isDigit(int codePoint) కూడా అక్షరం అంకె అయితే true అని మరియు లేకపోతే తప్పు అని అందిస్తుంది .

Java isDigit పద్ధతి సాధారణ ఉదాహరణ

Java Characher.isDigit() పద్ధతితో పని చేయడానికి ప్రయత్నిద్దాం . అన్నింటిలో మొదటిది, మేము పద్ధతిని ప్రదర్శించడానికి ఒక సాధారణ ప్రోగ్రామ్‌ను వ్రాయబోతున్నాము. 

public class isDigitTest {
//isDigit(char ch) simple example
   public static void main(String[] args)
   {

       //characters to check using isDigit Java method
       char myChar1 = '5', myChar2 = 'u', myChar3 = '0';

       // Function to check if the character
       // is digit or not, using isDigit() method
       System.out.println("is char " + myChar1 + " a digit? "
                       + Character.isDigit(myChar1));
       System.out.println(
               "is char " + myChar2 + " a digit? "
                       + Character.isDigit(myChar2));

       System.out.println(
               "is char " + myChar3 + " a digit? "
                       + Character.isDigit(myChar3));
   }
}
అవుట్‌పుట్:
చార్ 5 అంకెనా? చార్ ఉవా అంకె నిజమా? అవాస్తవం చార్ యుఏ అంకెనా? నిజం

Java isDigit పద్ధతి, కొంచెం సంక్లిష్టమైన ఉదాహరణ

Character.isDigit()ని ఉపయోగించడానికి ప్రయత్నిద్దాంమరింత ఆసక్తికరమైన మరియు నిజ జీవిత సమస్యలో. రన్ లెంగ్త్ ఎన్‌కోడింగ్ లేదా సంక్షిప్తంగా RLE అనే కంప్రెషన్ పద్ధతి ఉంది. రన్ లెంగ్త్ ఎన్‌కోడింగ్ అనేది డేటా కంప్రెషన్ అల్గోరిథం, ఇది పునరావృతమయ్యే అక్షరాలను (సిరీస్) ఒక అక్షరంతో మరియు దాని పునరావృతాల సంఖ్యతో భర్తీ చేస్తుంది. శ్రేణి అనేది అనేక సారూప్య పాత్రలతో కూడిన క్రమం. ఎన్‌కోడింగ్ చేసేటప్పుడు (ప్యాకింగ్, కంప్రెస్ చేయడం), శ్రేణిని రూపొందించే ఒకేలాంటి అక్షరాల స్ట్రింగ్ పునరావృతమయ్యే అక్షరం మరియు దాని పునరావృతాల సంఖ్యను కలిగి ఉన్న స్ట్రింగ్‌తో భర్తీ చేయబడుతుంది. కాబట్టి మీకు స్ట్రింగ్ “hhhhhorrribleeee” ఉంటే రన్ లెంగ్త్ ఎన్‌కోడింగ్ ఫలితాన్ని ఇస్తుంది: h5or3ible5. మీరు స్ట్రింగ్‌ను డీకోడ్ చేస్తే, మీరు అంకె లేదా అంకెలేతర అక్షరాన్ని కలిగి ఉన్నారో లేదో క్రమానుగతంగా తనిఖీ చేయాలి మరియు మీకు ఒక అంకె ఉంటే, అది అంకె ఏమిటో తెలుసుకోవడానికి సమయం ఆసన్నమైంది. మార్గం ద్వారా, మీ అందరికీ JPEG ఫైల్‌లు తెలుసు. ఈ ఫార్మాట్ పరిమాణాత్మక డేటాపై వికర్ణ నమూనాలో రన్-లెంగ్త్ ఎన్‌కోడింగ్ యొక్క వైవిధ్యాన్ని ఉపయోగిస్తుంది. వేరియంట్ ఏమిటంటే, సున్నా విలువల పరుగుల పొడవు మాత్రమే ఎన్‌కోడ్ చేయబడుతుంది మరియు అన్ని ఇతర విలువలు వాటిలాగే ఎన్‌కోడ్ చేయబడతాయి. దిగువ ఉదాహరణలో, మేము దీనిని ఉపయోగిస్తామురన్-లెంగ్త్ ఎన్‌కోడింగ్‌తో ఎన్‌కోడ్ చేయబడిన స్ట్రింగ్‌ను డీకోడ్ చేయడానికి Character.isDigit(char ch) పద్ధతి. మీకు ఆసక్తి ఉంటే, ప్రోగ్రామ్‌ను పూర్తి చేయడానికి ప్రయత్నించండి, లేదా దాని మొదటి భాగాన్ని సృష్టించండి మరియు RLE స్ట్రింగ్‌ను ఎన్‌కోడింగ్ చేయడానికి ఒక పద్ధతిని వ్రాయండి, అలాగే ఫైల్ నుండి స్ట్రింగ్‌ను చదవండి. లేదా ఇన్‌పుట్ యొక్క ఖచ్చితత్వాన్ని తనిఖీ చేస్తున్నప్పుడు కన్సోల్ నుండి మాన్యువల్‌గా స్ట్రింగ్‌ను నమోదు చేయండి. ఇక్కడ RLE డీకోడింగ్ యొక్క ఉదాహరణ: 

public class RleTest {

   //the method to decode String using run-length encoding and 
//isDigit() method 
   private static String decodeRle(String encoded) {
       if (encoded.isBlank()) return "";
       StringBuilder result = new StringBuilder();
       int count = 0;
       char baseChar = encoded.charAt(0);
       for (int i = 1; i <= encoded.length(); i++) {
           char c = i == encoded.length() ? '$' : encoded.charAt(i);
//checking using isDigit() method           
if (Character.isDigit(c)) {
               count = count * 10 + Character.digit(c, 10);
           } else {
               do {
                   result.append(baseChar);
                   count--;
               } while (count > 0);
               count = 0;
               baseChar = c;
           }
       }
       return result.toString();
   }
   
public static void main(String[] args) {
//here we are going to decode an RLE-encoded string 
       System.out.println(decodeRle("C3ecddf8"));
   }
}
అవుట్‌పుట్:
CCCecddffffff
మేము స్ట్రింగ్‌ని ఉపయోగించడం లేదని , స్ట్రింగ్‌బిల్డర్‌ని ఉపయోగిస్తున్నామని మీరు గమనించి ఉండవచ్చు . ఎందుకు? వాస్తవం ఏమిటంటే స్ట్రింగ్ మార్పులేనిది, మరియు మేము కౌంటర్‌ను పెంచుతాము మరియు ప్రతిసారీ కొత్త స్ట్రింగ్ సృష్టించబడుతుంది. మేము ప్రోగ్రామ్‌లో Character.digit పద్ధతిని కూడా ఉపయోగించాము . java.lang.Character.digit() అనేది పేర్కొన్న నంబర్ సిస్టమ్‌లో ch అక్షరం యొక్క సంఖ్యా విలువను అందించే పద్ధతి . బేస్ MIN_RADIX <= బేస్ <= MAX_RADIX పరిధిలో లేకుంటే లేదా పేర్కొన్న బేస్‌లో ch చెల్లుబాటు అయ్యే అంకె కాకపోతే, పద్ధతి -1ని అందిస్తుంది.