జావా స్కానర్ క్లాస్

హాయ్! ఈ రోజు మా పాఠం ప్రత్యేకంగా ఉంటుంది! నేటి పాఠంలో, మేము జావా స్కానర్ క్లాస్ గురించి మాట్లాడుతాము. ఇంతకుముందు, పనులను పూర్తి చేయడం మరియు ప్రోగ్రామ్‌లను వ్రాయడం చాలా సులభం: మేము కొంత కోడ్‌ను వ్రాస్తాము, ప్రధాన()ని అమలు చేస్తాముపద్ధతి, ప్రోగ్రామ్ అవసరమైనది చేస్తుంది మరియు మేము పూర్తి చేసాము. కానీ ఇప్పుడు ప్రతిదీ మారుతుంది! ఈ రోజు మనం ప్రోగ్రామ్‌తో నిజంగా ఎలా పరస్పర చర్య చేయాలో నేర్చుకుంటాము: మా చర్యలకు ఎలా ప్రతిస్పందించాలో మేము నేర్పుతాము! మేము కోడ్‌ని విశ్లేషించడం ప్రారంభించే ముందు, మీరు ఎప్పుడైనా స్కానర్ వంటి పరికరంతో వ్యవహరించాల్సి వచ్చిందా? బహుశా. స్కానర్ లోపలి భాగాలు చాలా క్లిష్టంగా ఉంటాయి, కానీ ఇది ఎలా పని చేస్తుందనే దాని ప్రాథమిక ఆలోచన చాలా సులభం: ఇది వినియోగదారు అందించే డేటాను (పాస్‌పోర్ట్ లేదా బీమా పాలసీ వంటివి) చదువుతుంది మరియు ఈ సమాచారాన్ని మెమరీలో నిల్వ చేస్తుంది (ఉదాహరణకు, చిత్రం వలె ) ఈరోజు మీరు మీ స్వంత స్కానర్‌ని సృష్టించబోతున్నారు! అయితే, ఇది కాగితపు పత్రాలను నిర్వహించదు, కానీ టెక్స్ట్ దానికి ఎటువంటి సమస్య ఉండదు :) వెళ్దాం!

జావా స్కానర్ క్లాస్

అన్నింటిలో మొదటిది, మనం తప్పనిసరిగా java.util.Scanner క్లాస్‌తో పరిచయం చేసుకోవాలి. దీని కార్యాచరణ చాలా సులభం. నిజమైన స్కానర్ వలె, ఇది మీరు పేర్కొన్న మూలం నుండి డేటాను చదువుతుంది. ఉదాహరణకు, స్ట్రింగ్, ఫైల్, కన్సోల్. తరువాత, ఇది సమాచారాన్ని గుర్తించి తగిన విధంగా ప్రాసెస్ చేస్తుంది. ఇక్కడ సరళమైన ఉదాహరణ:

public class Main {

   public static void main(String[] args) {

       Scanner scanner = new Scanner("It matters not how strait the gate,\n" +
               "How charged with punishments the scroll,\n" +
               "I am the master of my fate,\n" +
               "I am the captain of my soul");
       String s = scanner.nextLine();
       System.out.println(s);
   }
}

మేము స్కానర్ ఆబ్జెక్ట్‌ను సృష్టించాము మరియు దాని డేటా మూలాన్ని (టెక్స్ట్ స్ట్రింగ్) పేర్కొన్నాము. నెక్స్ట్‌లైన్ () పద్ధతి డేటా మూలాన్ని యాక్సెస్ చేస్తుంది (క్వాట్రైన్‌తో మా టెక్స్ట్), తదుపరి చదవని పంక్తిని (ఈ సందర్భంలో మొదటి పంక్తి) కనుగొని దానిని తిరిగి అందిస్తుంది. అప్పుడు మేము దానిని కన్సోల్‌లో ప్రదర్శిస్తాము: కన్సోల్ అవుట్‌పుట్:

It matters not how strait the gate,

మేము nextLine() పద్ధతిని చాలాసార్లు ఉపయోగించవచ్చు మరియు మొత్తం పద్యం సారాంశాన్ని ప్రదర్శించవచ్చు:

public class Main {

   public static void main(String[] args) {

       Scanner scanner = new Scanner("It matters not how strait the gate,\n" +
               "How charged with punishments the scroll,\n" +
               "I am the master of my fate,\n" +
               "I am the captain of my soul");
       String s = scanner.nextLine();
       System.out.println(s);
       s = scanner.nextLine();
       System.out.println(s);
       s = scanner.nextLine();
       System.out.println(s);
       s = scanner.nextLine();
       System.out.println(s);
   }
}

ప్రతిసారీ, మా స్కానర్ ఒక అడుగు ముందుకు వేసి తదుపరి పంక్తిని చదువుతుంది. ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ ప్రదర్శించబడుతుంది:

It matters not how strait the gate,
How charged with punishments the scroll,
I am the master of my fate,
I am the captain of my soul

మేము ఇప్పటికే చెప్పినట్లుగా, స్కానర్ యొక్క డేటా మూలం స్ట్రింగ్ కానవసరం లేదు. ఉదాహరణకు, ఇది కన్సోల్ కావచ్చు. మీ కోసం కొన్ని ఉత్తేజకరమైన వార్తలు: మునుపు, మేము అక్కడ డేటాను ప్రదర్శించాము, కానీ ఇప్పుడు మేము కీబోర్డ్ నుండి డేటాను చదువుతాము! స్కానర్ క్లాస్ ఇంకా ఏమి చేస్తుందో చూద్దాం :

public class Main {

   public static void main(String[] args) {

       Scanner sc = new Scanner(System.in);
       System.out.println("Enter a number:");

       int number = sc.nextInt();

       System.out.println("Thanks! You entered the number " + number);

   }
}

nextInt () మెథడ్ ఎంటర్ చేసిన నంబర్‌ని రీడ్ చేస్తుంది మరియు అందిస్తుంది. మా ప్రోగ్రామ్‌లో, వేరియబుల్ నంబర్‌కు విలువను కేటాయించడానికి మేము దీన్ని ఉపయోగిస్తాము . ఇది ఇప్పటికే నిజమైన స్కానర్ లాగా ఉంది! ప్రోగ్రామ్ ఏదైనా నంబర్‌ను నమోదు చేయమని వినియోగదారుని అడుగుతుంది. వినియోగదారు దీన్ని పూర్తి చేసిన తర్వాత, ప్రోగ్రామ్ వినియోగదారుకు ధన్యవాదాలు తెలియజేస్తుంది, ఫలితాన్ని ప్రదర్శిస్తుంది మరియు పూర్తి చేస్తుంది. కానీ మాకు ఇంకా తీవ్రమైన సమస్య ఉంది. వినియోగదారు పొరపాటు చేసి, తప్పుగా నమోదు చేయవచ్చు. మా ప్రస్తుత ప్రోగ్రామ్ పని చేయడం ఆగిపోయే ఉదాహరణ ఇక్కడ ఉంది:

public class Main {

   public static void main(String[] args) {

       Scanner sc = new Scanner(System.in);
       System.out.println("Enter a number:");

       int number = sc.nextInt();

       System.out.println("Thanks! You entered the number " + number);

   }
}

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

Enter a number:
CodeGym
Exception in thread "main" java.util.InputMismatchException
at java.util.Scanner.throwFor(Scanner.java:864)
at java.util.Scanner.next(Scanner.java:1485)
at java.util.Scanner.nextInt(Scanner.java:2117)
at java.util.Scanner.nextInt(Scanner.java:2076)
at Main.main(Main.java:10) Process finished with exit code 1

ఓ హో. మేము పెద్ద సమస్యలో ఉన్నాము -_- అటువంటి పరిస్థితులను నివారించడానికి, వినియోగదారు నమోదు చేసిన డేటాను ధృవీకరించడానికి మేము ఒక మార్గాన్ని రూపొందించాలి. ఉదాహరణకు, వినియోగదారు సంఖ్య కాకుండా ఏదైనా నమోదు చేస్తే, నమోదు చేసిన సమాచారం సంఖ్య కాదని హెచ్చరికను ప్రదర్శించడం మంచిది. మరియు సమాచారం ఓకే అయితే, మేము నిర్ధారణ చేయవచ్చు. కానీ ఇది మా స్ట్రీమ్‌లో ఏమి వస్తుందో చూడటానికి "భవిష్యత్తులోకి చూడటం" అవసరం. స్కానర్ దీన్ని చేయగలదా ? మరి ఎలా! మరియు దీన్ని చేయడానికి ఇది అనేక పద్ధతులను కలిగి ఉంది: hasNextInt() — ఈ పద్ధతి ఇన్‌పుట్ డేటా యొక్క తదుపరి భాగం సంఖ్యా కాదా అని తనిఖీ చేస్తుంది (సముచితంగా ఒప్పు లేదా తప్పును అందిస్తుంది). hasNextLine() — ఈ పద్ధతి ఇన్‌పుట్ యొక్క తదుపరి భాగం స్ట్రింగ్ కాదా అని తనిఖీ చేస్తుంది. ఉందిNextByte() ,hasNextShort() , hasNextLong() , hasNextFloat() , hasNextDouble() — ఈ పద్ధతులన్నీ మిగిలిన డేటా రకాలకు ఒకే విధమైన తనిఖీలను నిర్వహిస్తాయి. మన నంబర్ రీడింగ్ ప్రోగ్రామ్‌ని మార్చడానికి ప్రయత్నిద్దాం:

public class Main {

   public static void main(String[] args) {

       Scanner sc = new Scanner(System.in);
       System.out.println("Enter a number:");

       if (sc.hasNextInt()) {
           int number = sc.nextInt();
           System.out.println("Thanks! You entered the number " + number);
       } else {
           System.out.println("Sorry, but this is clearly not a number. Restart the program and try again!");
       }

   }
}

ఇప్పుడు మా ప్రోగ్రామ్ నమోదు చేసిన తదుపరి అక్షరం సంఖ్యా కాదా అని తనిఖీ చేస్తుంది. మరియు అది నిర్ధారణ అయితే మాత్రమే ప్రదర్శిస్తుంది. ఇన్‌పుట్ చెక్‌లో ఉత్తీర్ణత సాధించకపోతే, ప్రోగ్రామ్ గమనించి, మళ్లీ ప్రయత్నించమని వినియోగదారుని అడుగుతుంది. ప్రాథమికంగా, మీరు స్కానర్ ఆబ్జెక్ట్‌తో కమ్యూనికేట్ చేయవచ్చు మరియు మీకు ఏ డేటా రకం ఎదురుచూస్తుందో ముందుగానే తెలుసుకోవచ్చు . సంఖ్య, స్ట్రింగ్ లేదా మరేదైనా ఉందా? ఒక సంఖ్య? మరియు ఏ రకమైన? ఒక int , short , long ?" ఈ వశ్యత వినియోగదారు ప్రవర్తనపై ఆధారపడి ప్రోగ్రామ్ లాజిక్‌ను రూపొందించడానికి మీకు అవకాశాన్ని ఇస్తుంది. మేము మరొక ముఖ్యమైన పద్ధతిని గమనించాలి: useDelimiter() . మీరు ఈ పద్ధతికి స్ట్రింగ్‌ను పాస్ చేస్తారు. స్ట్రింగ్‌లో ఉన్నాయి మీరు సెపరేటర్‌లు లేదా డీలిమిటర్‌లుగా ఉపయోగించాలనుకుంటున్న అక్షరాలు. ఉదాహరణకు, మనకు అకస్మాత్తుగా జపనీస్ కవిత్వంపై ఆసక్తి కలిగిందని అనుకుందాం మరియు గొప్ప కవి మాట్సువో బాషో రాసిన కొన్ని హైకూలను చదవడానికి మా స్కానర్‌ని ఉపయోగించాలని నిర్ణయించుకున్నాము. మూడు వేర్వేరు శ్లోకాలు మనకు ఒక ఇబ్బందికరమైన స్ట్రింగ్‌గా పంపబడినప్పటికీ, మనం వాటిని సులభంగా విభజించవచ్చు మరియు వాటిని అందంగా అందించవచ్చు:

public class Main {
   public static void main(String[] args) {
       Scanner scan = new Scanner("On a withered branch'" +
               "A crow has alighted.'" +
               "Nightfall in autumn." +
               "''***''" +
               "Such a moon above,'" +
               "Like a tree cut at the root:'" +
               "he fresh cut is white." +
               "''***''" +
               "How the river floods!'" +
               "A heron wanders on short legs,'" +
               "Knee-deep in the water.");

       scan.useDelimiter("'");

       while (scan.hasNext()) {
           System.out.println(scan.next());
       }

       scan.close();
   }
}

మేము మా డీలిమిటర్‌గా "\ n /*/*/*" (కొత్త పంక్తి అక్షరం మరియు మూడు నక్షత్రాలు) ఉపయోగిస్తాము. ఫలితంగా, మేము పుస్తకాలలో వలె అందమైన కన్సోల్ అవుట్‌పుట్‌ని కలిగి ఉన్నాము:

On a withered branch
A crow has alighted.
Nightfall in autumn.

***

Such a moon above,
Like a tree cut at the root:
The fresh cut is white.

***

How the river floods!
A heron wanders on short legs,
Knee-deep in the water.

ఈ ఉదాహరణలో మనం ఖచ్చితంగా సూచించాల్సిన మరో పద్ధతి ఉంది: క్లోజ్() . I/O స్ట్రీమ్‌లతో పని చేసే ఏదైనా వస్తువు వలె, స్కానర్ పూర్తయినప్పుడు తప్పనిసరిగా మూసివేయబడాలి, కనుక ఇది కంప్యూటర్ వనరులను వినియోగించడాన్ని ఆపివేస్తుంది. క్లోజ్() పద్ధతిని ఎప్పటికీ మర్చిపోకండి !

public class Main {

   public static void main(String[] args) {

       Scanner sc = new Scanner(System.in);
       System.out.println("Enter a number:");

       int number = sc.nextInt();

       System.out.println("Thanks! You entered the number " + number);

       sc.close(); // Now we've done everything right!

   }
}

అంతే! మీరు చూడగలిగినట్లుగా, ఇది ఎంత ఉపయోగకరంగా ఉందో, స్కానర్ తరగతిని ఉపయోగించడం చాలా సులభం! :) మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మీరు మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడాలని మేము సూచిస్తున్నాము