కీబోర్డ్ ఇన్‌పుట్

1. ఉపయోగించి కన్సోల్ నుండి చదవడంSystem.in

మునుపటి పాఠాలలో, స్క్రీన్‌పై సమాచారాన్ని ప్రదర్శించడానికి మేము ఆదేశాలతో పరిచయం పొందాము. System.outదీన్ని చేయడానికి, మేము వస్తువు మరియు దాని print()మరియు println()పద్ధతులను ఉపయోగించాము . ఇది సాధారణ మరియు అనుకూలమైనది.

కానీ, మీరు బహుశా ఇప్పటికే ఊహించినట్లుగా, స్క్రీన్‌పై సమాచారాన్ని ప్రదర్శించడం మాకు సరిపోదు. చాలా ప్రోగ్రామ్‌ల ఉద్దేశ్యం వినియోగదారుకు ఉపయోగకరమైనది చేయడమే. అంటే వినియోగదారు కీబోర్డ్ నుండి డేటాను నమోదు చేయడం చాలా తరచుగా అవసరం.

అవుట్‌పుట్ విషయంలో మాదిరిగానే, డేటా ఇన్‌పుట్ కోసం కూడా మాకు ప్రత్యేక వస్తువు ఉంది — System.in. కానీ, దురదృష్టవశాత్తు మాకు, ఇది మేము కోరుకున్నంత సౌకర్యవంతంగా లేదు. ఇది కీబోర్డ్ నుండి డేటాను ఒకేసారి ఒక అక్షరాన్ని చదవడానికి అనుమతిస్తుంది .

దీన్ని మెరుగుపరచడానికి, మేము మరొక తరగతిని ఉపయోగిస్తాము, అది ఆబ్జెక్ట్‌తో జత చేసినప్పుడు System.in, మనకు అవసరమైన ప్రతిదాన్ని ఇస్తుంది. చాలా కాలంగా, జావాలో ప్రతి సందర్భానికి అనుగుణంగా తరగతులు ఉన్నాయి. మరియు వాటిలో ఒకదానిని మనం ఇప్పుడు తెలుసుకుందాం.

2. Scannerతరగతి

తరగతి Scanner(పూర్తి పేరు: java.util.Scanner) వివిధ మూలాల నుండి డేటాను చదవగలదు, ఉదా కన్సోల్, ఫైల్‌లు మరియు ఇంటర్నెట్. System.inమేము అది కీబోర్డ్ నుండి డేటాను చదవాలనుకుంటే, ఆబ్జెక్ట్‌ని తప్పనిసరిగా డేటా సోర్స్‌గా పనిచేసే ఆర్గ్యుమెంట్‌గా పాస్ చేయాలి . ఆపై స్కానర్ ఆబ్జెక్ట్ దానితో ఏమి చేయాలో కనుగొంటుంది.

వస్తువును ఉపయోగించి కీబోర్డ్ నుండి చదవడం Scannerఇలా కనిపిస్తుంది:

Scanner console = new Scanner(System.in);
String name = console.nextLine();
int age = console.nextInt();

ఇది తేలికగా కనిపిస్తుంది, కానీ ఇది నిజంగా అంత సులభమా?

మీరు తప్పనిసరిగా కొన్ని ప్రశ్నలను కలిగి ఉండాలని నేను భావిస్తున్నాను మరియు ఇప్పుడు మేము వాటికి సమాధానం ఇస్తాము.

అయితే ముందుగా, తరగతిని ఉపయోగించే పూర్తి ప్రోగ్రామ్ యొక్క ఉదాహరణను ప్రదర్శిస్తాము Scanner:

import java.util.Scanner;
public class Solution {
   public static void main(String[] args)
   {
      Scanner console = new Scanner(System.in);
      String name = console.nextLine();
      int age = console.nextInt();

      System.out.println("Name: " + name);
      System.out.println("Age: " + age);
   }
}

3. ఒక Scannerవస్తువును సృష్టించడం

మొదటి ప్రశ్న ఈ లైన్ ఏమిటి Scanner console = new Scanner (System.in);?

ఈ లైన్ గందరగోళంగా ఉండవచ్చు, కానీ మీరు ఎల్లప్పుడూ ఇలాంటి విషయాలను చూస్తారు. కాబట్టి ఇక్కడ ఏమి జరుగుతుందో వివరించడం ముఖ్యం అని మేము భావిస్తున్నాము.

మనం సాధారణంగా టెక్స్ట్‌తో వేరియబుల్‌ని ఎలా క్రియేట్ చేస్తామో గుర్తు చేసుకోండి:

String str = "text";

మొదట, మేము వేరియబుల్ రకం ( String), దాని పేరు ( str) వ్రాస్తాము మరియు చివరగా, సమానం గుర్తు తర్వాత, మేము విలువను వ్రాస్తాము.

మా దిగ్భ్రాంతికరమైన లైన్ నిజానికి అదే:

Scanner console = new Scanner(System.in);

సమాన గుర్తుకు ఎడమ వైపున ఉన్న ప్రతిదీ consoleదాని రకం అనే పేరు గల వేరియబుల్ యొక్క డిక్లరేషన్ Scanner. మీరు బదులుగా కాల్ చేయవచ్చు s లేదా scannerలేదా keyboard. అప్పుడు కోడ్ ఇలా కనిపిస్తుంది:

Scanner s = new Scanner(System.in);
String name = s.nextLine();
int age = s.nextInt();

Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
int age = scanner.nextInt();

Scanner keyboard = new Scanner(System.in);
String name = keyboard.nextLine();
int age = keyboard.nextInt();

ఇది ప్రతిదీ చాలా స్పష్టంగా చేస్తుందని నేను భావిస్తున్నాను.

కానీ సమాన గుర్తుకు కుడి వైపున ఉన్న కోడ్ కొంచెం క్లిష్టంగా ఉంటుంది. నేను ఇప్పుడు ప్రస్తావిస్తున్నాను new Scanner(System.in); , ఇక్కడ కూడా అతీంద్రియ ఏమీ జరగలేదు.

ఈ కోడ్‌లో, మేము జావా మెషీన్‌కు చెబుతాము: కొత్తగా సృష్టించిన వస్తువు కోసం ఆబ్జెక్ట్‌ని డేటా సోర్స్‌గా  పంపే కొత్త వస్తువు (కీవర్డ్ new) దాని రకం .ScannerSystem.inScanner

 ఈ మొత్తం పంక్తిని అమలు చేసిన తర్వాత, కీబోర్డ్ నుండి డేటాను చదవడానికి మా ప్రోగ్రామ్ ఉపయోగించే Scannerవేరియబుల్ ఉంటుంది .console

4. పద్ధతుల జాబితా

పై ఉదాహరణలో, మా Scanner consoleవేరియబుల్ ఒక వస్తువుకు సూచనను నిల్వ చేస్తుంది Scanner.

వేరియబుల్ ద్వారా సూచించబడిన ఆబ్జెక్ట్‌పై పద్ధతులను కాల్ చేయడానికి, మీరు వేరియబుల్ పేరు తర్వాత వ్యవధిని వ్రాస్తారు, దాని తర్వాత పద్ధతి పేరు మరియు ఏవైనా వాదనలు ఉంటాయి. కమాండ్ యొక్క సాధారణ రూపం క్రింది విధంగా ఉంటుంది:

variable.method(arguments);

ఉదాహరణలు:

System.out.println("Hello");

System.out.println(1);

మీరు ఒక ఫంక్షన్‌కి ఆర్గ్యుమెంట్‌లను పాస్ చేయడానికి ప్లాన్ చేయకపోతే, మీరు ఖాళీ కుండలీకరణాలను వ్రాయండి:

variable.method();

ఉదాహరణ:

System.out.println();

5. కన్సోల్ ఇన్‌పుట్

మన దగ్గర వస్తువు ఉన్నప్పుడు Scanner, కీబోర్డ్ నుండి డేటాను పొందడం సులభం.

కీబోర్డ్ నుండి పంక్తిని చదవడానికి , మీకు ఈ ఆదేశం అవసరం:

String str = console.nextLine();

ప్రోగ్రామ్ యొక్క ఎగ్జిక్యూషన్ ఈ లైన్‌కు చేరుకున్నప్పుడు, అది పాజ్ అవుతుంది మరియు వినియోగదారు డేటాను నమోదు చేయడానికి వేచి ఉండి ఎంటర్ నొక్కండి. అప్పుడు వినియోగదారు నమోదు చేసిన ప్రతిదీ వేరియబుల్‌లో నిల్వ చేయబడుతుంది str.

కీబోర్డ్ నుండి సంఖ్యను చదవడానికి , మీకు ఈ ఆదేశం అవసరం:

int number = console.nextInt();

ఇక్కడ ప్రతిదీ మునుపటి ఆదేశం వలె ఉంటుంది. ప్రోగ్రామ్ యొక్క ఎగ్జిక్యూషన్ ఈ లైన్‌కు చేరుకున్నప్పుడు, అది పాజ్ అవుతుంది మరియు వినియోగదారు డేటాను నమోదు చేయడానికి వేచి ఉండి ఎంటర్ నొక్కండి. ఆ తరువాత, వినియోగదారు నమోదు చేసిన ప్రతిదీ సంఖ్యగా మార్చబడుతుంది మరియు numberవేరియబుల్‌లో నిల్వ చేయబడుతుంది.

వినియోగదారు పూర్ణాంకానికి మార్చలేని డేటాను నమోదు చేస్తే, ప్రోగ్రామ్ లోపాన్ని సృష్టించి నిష్క్రమిస్తుంది.

కీబోర్డ్ నుండి పాక్షిక సంఖ్యను చదవడానికి , మీకు ఈ ఆదేశం అవసరం:

double number = console.nextDouble();

ఈ స్టేట్‌మెంట్ పద్ధతికి చాలా పోలి ఉంటుంది nextInt(), నమోదు చేసిన డేటా సంఖ్యగా మార్చబడుతుందా అని మాత్రమే ఇది తనిఖీ చేస్తుంది double.

కీబోర్డ్ నుండి రెండు సంఖ్యలను చదివి వాటి మొత్తాన్ని స్క్రీన్‌పై ప్రదర్శించే ప్రోగ్రామ్ యొక్క ఉదాహరణ:

import java.util.Scanner;
public class Solution {
   public static void main(String[] args)
   {
      Scanner console = new Scanner(System.in);
      int a = console.nextInt();
      int b = console.nextInt();

      System.out.println(a + b);
   }
}

6. Scannerతరగతి యొక్క ఇతర పద్ధతులు

Scannerమార్గం ద్వారా, పైన ఉన్న పద్ధతులు తరగతి అందించేవన్నీ కావు . పద్ధతుల పూర్తి జాబితా ఇలా కనిపిస్తుంది:

nextByte()

nextShort()

nextInt()

nextLong()

nextFloat()

nextDouble()

nextBoolean()

next()

nextLine()

ఇన్‌పుట్‌లోని తదుపరి టోకెన్‌ను వాస్తవంగా పొందకుండానే తనిఖీ చేయడానికి మిమ్మల్ని అనుమతించే పద్ధతులు కూడా ఉన్నాయి (దీనిని చదవడానికి ఏ పద్ధతిని ఉపయోగించాలో తెలుసుకోవడం కోసం).

hasNextByte()

hasNextShort()

hasNextInt()

hasNextLong()

hasNextFloat()

hasNextDouble()

hasNextBoolean()

hasNext()

hasNextLine()

7. స్ట్రింగ్ నుండి డేటాను చదవడం

Scannerతరగతి వివిధ మూలాధారాల నుండి డేటాను చదవగలదని మేము ఇంతకు ముందు పేర్కొన్నాము . ఆ మూలాలలో ఒకటి టెక్స్ట్ స్ట్రింగ్ .

ఇది ఇలా కనిపిస్తుంది:

String str = "text";
Scanner scanner = new Scanner(str);

వస్తువును సృష్టించేటప్పుడు , వస్తువుకు బదులుగా Scannerస్ట్రింగ్‌లో పాస్ చేస్తాము . మరియు ఇప్పుడు వస్తువు స్ట్రింగ్ నుండి డేటాను చదువుతుంది. ఉదాహరణ:strSystem.inscanner

import java.util.Scanner;
public class Solution {
   public static void main(String[] args)
   {
      String str = "10 20 40 60";
      Scanner scanner = new Scanner(str);
      int a = scanner.nextInt();
      int b = scanner.nextInt();

      System.out.println(a + b);
   }
}

// a == 10; 
// బి == 20; 
స్క్రీన్ అవుట్‌పుట్ ఇలా ఉంటుంది:30