స్కానర్ క్లాస్‌ని ఉపయోగించడానికి, దాన్ని ముందుగా దిగుమతి చేసుకోవాలి. ఆ తరువాత, ఒక వస్తువు దాని నుండి తక్షణం చేయవలసి ఉంటుంది. స్కానర్ వస్తువును ఉపయోగించిన తర్వాత, దాన్ని మూసివేయాలి. కీబోర్డ్‌ను సూచించే ఇన్‌పుట్ స్ట్రీమ్ ఆబ్జెక్ట్ System.in. స్కానర్‌లో అనేక పద్ధతులు ఉన్నాయి. ఈ వ్యాసంలో సాధారణంగా ఉపయోగించే వాటిని మాత్రమే వివరిస్తారు.
వ్యాసం కంటెంట్
- స్కానర్ క్లాస్ యొక్క సాధారణ ఉపయోగం
- విలువలలోకి ఇన్‌పుట్ లైన్ ఉమ్మివేయడం
- ఆదిమ డేటా రకాలను చదవడం మరియు ధృవీకరించడం
- ఇన్‌పుట్ టోకెన్‌ను వేరియబుల్‌కు కేటాయించడం
- ముగింపు
స్కానర్ క్లాస్ యొక్క సాధారణ ఉపయోగం
కింది కోడ్ వినియోగదారుని వాక్యంలో టైప్ చేయమని అడుగుతుంది, ఆపై అది వాక్యాన్ని ప్రదర్శిస్తుంది:
దిగుమతి java.util.Scanner;
ప్రజా తరగతితరగతి{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
స్కానర్ స్కాన్ ఓబ్జె= కొత్తస్కానర్( వ్యవస్థ .లో);
వ్యవస్థ .బయటకు.println('వాక్యాన్ని టైప్ చేసి ఎంటర్ నొక్కండి:');
స్ట్రింగ్ వాక్యం=scanObj.తదుపరి లైన్();
వ్యవస్థ .బయటకు.println(వాక్యం);
scanObj.దగ్గరగా();
}
}
మొదటి లైన్ స్కానర్ క్లాస్‌ని దిగుమతి చేస్తుంది. ప్రధాన ఫంక్షన్‌లో, మొదటి పంక్తి కీబోర్డ్ కోసం System.in ఆబ్జెక్ట్‌ను ఉపయోగించి స్కానర్ వస్తువును సృష్టిస్తుంది. స్కానర్ వస్తువు సృష్టించబడిన వెంటనే, అది ఇన్‌పుట్ కోసం వేచి ఉండటం ప్రారంభిస్తుంది. తదుపరి పంక్తి ఒక వాక్యాన్ని టైప్ చేయమని వినియోగదారుని కోరుతూ ఒక స్టేట్‌మెంట్‌ను ముద్రించింది. కోడ్‌ని అనుసరించే లైన్ వినియోగదారుని నొక్కిన తర్వాత స్కానర్ ఆబ్జెక్ట్ యొక్క తదుపరి లైన్ () పద్ధతిని ఉపయోగిస్తుంది. కోడ్‌లోని లైన్ తర్వాత, వాక్యాన్ని టెర్మినల్ విండో వద్ద తిరిగి ముద్రించింది. చివరి పంక్తి స్కానర్ వస్తువును మూసివేస్తుంది.
విలువలలోకి ఇన్‌పుట్ లైన్ ఉమ్మివేయడం
కింది కోడ్ ఇన్‌పుట్ లైన్‌ని పదాలుగా (టోకెన్‌లు) విభజించి, స్పేస్‌ని డీలిమిటర్‌గా ఉపయోగిస్తుంది:
దిగుమతి java.util.Scanner;ప్రజా తరగతితరగతి{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
స్కానర్ స్కాన్ ఓబ్జె= కొత్తస్కానర్( వ్యవస్థ .లో);
వ్యవస్థ .బయటకు.println('టోకెన్‌ల పంక్తిని టైప్ చేయండి మరియు ఎంటర్ నొక్కండి:');
అయితే(scanObj.తదుపరి ఉంది()){
వ్యవస్థ .బయటకు.println(scanObj.తరువాత());
}
scanObj.దగ్గరగా();
}
}
hasNext () మరియు తదుపరి () స్కానర్ వస్తువు యొక్క రెండు ఇతర పద్ధతులు. స్కానర్ వస్తువు ఒక పంక్తిని చదివినప్పుడు, అది దానిని ఉంచుతుంది. తదుపరి () తదుపరి టోకెన్ (పదం) ని యాక్సెస్ చేస్తుంది. hasNext () ఇంకా యాక్సెస్ చేయబడని ఏదైనా ఇతర టోకెన్ ఉన్నట్లయితే అది నిజం అవుతుంది.
దురదృష్టవశాత్తు, ఈ కోడ్‌తో విడిపోవడానికి మరియు తిరిగి ప్రదర్శించడానికి వినియోగదారు ఇప్పటికీ ఇన్‌పుట్‌ను టైప్ చేయాలని భావిస్తున్నారు. అన్నింటినీ ముగించడానికి, Ctrl+z నొక్కండి మరియు మీరు కమాండ్ ప్రాంప్ట్ వద్దకు తిరిగి రావాలి.
పై కోడ్‌లో, డీలిమిటర్ స్పేస్‌లోని టోకెన్‌లను వేరు చేస్తుంది. మరొక అక్షరాన్ని ఉపయోగించవచ్చు. కింది కోడ్ కామాను ఉపయోగిస్తుంది. మీరు కోడ్‌ని పరీక్షిస్తే లూప్‌ను ముగించడానికి Ctrl+z నొక్కడం మర్చిపోవద్దు.
దిగుమతి java.util.Scanner;ప్రజా తరగతితరగతి{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
స్కానర్ స్కాన్ ఓబ్జె= కొత్తస్కానర్( వ్యవస్థ .లో);
వ్యవస్థ .బయటకు.println('టోకెన్‌ల పంక్తిని టైప్ చేయండి మరియు ఎంటర్ నొక్కండి:');
scanObj.డెలిమిటర్ ఉపయోగించండి(',');
అయితే(scanObj.తదుపరి ఉంది()){
వ్యవస్థ .బయటకు.println(scanObj.తరువాత());
}
scanObj.దగ్గరగా();
}
}
మీరు కోడ్‌ని పరీక్షిస్తే, టోకెన్‌లలో (అవుట్‌పుట్) భాగంగా టోకెన్‌లలోని ఖాళీలు చేర్చబడ్డాయని మీరు గమనించవచ్చు. వ్యక్తీకరణ, scanObj.useDelimiter (,); ఇన్‌పుట్ లైన్ చదివిన తర్వాత టైప్ చేయండి; ఇది కామా, డీలిమిటర్‌ని చేస్తుంది.
ఆదిమ డేటా రకాలను చదవడం మరియు ధృవీకరించడం
తదుపరి బూలియన్ () పద్ధతి
కింది కోడ్‌లో, యూజర్ కోట్స్ లేకుండా నిజం లేదా తప్పు అని టైప్ చేసి, అవును లేదా కాదు వంటి ఏదైనా టైప్ చేస్తే ఎంటర్ కీని నొక్కండి, దోష సందేశం ప్రదర్శించబడుతుంది.
దిగుమతి java.util.Scanner;ప్రజా తరగతితరగతి{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
వ్యవస్థ .బయటకు.ముద్రణ('నువ్వు 24 పైన ఉన్నావా? ');
స్కానర్ స్కాన్ ఓబ్జె= కొత్తస్కానర్( వ్యవస్థ .లో);
బూలియన్bl=scanObj.తదుపరి బూలియన్();
ఉంటే (bl== నిజం) {
వ్యవస్థ .బయటకు.println('నీ వయసు 24 దాటింది');
}
లేకపోతే ఉంటే (bl== తప్పుడు) {
వ్యవస్థ .బయటకు.println('మీరు 24 ఏళ్లలోపు వారు');
}
scanObj.దగ్గరగా();
}
}
ఇన్‌పుట్ సరిగ్గా లేదా తప్పుగా ఉన్నంత వరకు జావా ఒక దోష సందేశాన్ని జారీ చేస్తుంది కాబట్టి, మిగతా వాటికి బదులుగా ఉపయోగించినట్లయితే.
ప్రింట్ మరియు ప్రింట్‌ఎల్‌ఎన్ అనే పద్ధతుల మధ్య వ్యత్యాసం ఏమిటంటే, ప్రింట్ ప్రస్తుత లైన్‌లో ఇన్‌పుట్‌ను ఆశిస్తుంది, అయితే ప్రింట్‌లైన్ తదుపరి లైన్‌లో ఇన్‌పుట్‌ను ఆశిస్తుంది.
nextByte () పద్ధతి
ASCII అక్షర సమితితో, ఒక అక్షరం ఒక బైట్. అయితే, కొన్ని తూర్పు అక్షరాల సెట్‌లతో, ఒక పాత్ర ఒకటి కంటే ఎక్కువ బైట్‌లను కలిగి ఉండవచ్చు. అక్షర సమితి నుండి స్వతంత్రంగా, తదుపరి బైట్ పద్ధతి ఇన్‌పుట్ యొక్క తదుపరి బైట్‌ని చదివి ధృవీకరిస్తుంది. ఈ ప్రయోజనం కోసం కింది కోడ్‌ని ఉపయోగించవచ్చు:
దిగుమతి java.util.Scanner;ప్రజా తరగతితరగతి{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
వ్యవస్థ .బయటకు.ముద్రణ('రకం సంఖ్య<128, press Enter: ');
స్కానర్ స్కాన్ ఓబ్జె= కొత్తస్కానర్( వ్యవస్థ .లో);
బైట్bt=scanObj.తదుపరి బైట్();
వ్యవస్థ .బయటకు.println(bt);
scanObj.దగ్గరగా();
}
}
ఈ కోడ్ కోసం 127 కంటే ఎక్కువ సంఖ్య లేదా అక్షర అక్షరం ఇన్‌పుట్ చేయబడితే, ఒక దోష సందేశం జారీ చేయబడుతుంది.
nextInt () పద్ధతి
ఇన్‌పుట్‌గా తదుపరి పూర్ణాంక టోకెన్ కూడా ధృవీకరించబడుతుంది మరియు ఆమోదించబడుతుంది. కింది కోడ్‌ని ఉపయోగించవచ్చు:
దిగుమతి java.util.Scanner;ప్రజా తరగతితరగతి{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
వ్యవస్థ .బయటకు.ముద్రణ('ఏదైనా పూర్ణాంకం నమోదు చేయండి:');
స్కానర్ స్కాన్ ఓబ్జె= కొత్తస్కానర్( వ్యవస్థ .లో);
intఒకదానిపై=scanObj.తదుపరిది();
వ్యవస్థ .బయటకు.println(ఒకదానిపై);
scanObj.దగ్గరగా();
}
}
లీడింగ్ లేదా ట్రెయిలింగ్ ఖాళీలు తీసివేయబడ్డాయి. ఈ కోడ్ కోసం, 127 కంటే ఎక్కువ విలువలతో సహా ఏదైనా పూర్ణాంక విలువ అంగీకరించబడుతుంది. ఈ తదుపరి XXX () పద్ధతులతో, ధ్రువీకరణ విఫలమైన తర్వాత, ఒక దోష సందేశం జారీ చేయబడుతుంది.
nextBigInteger () పద్ధతి
సాఫ్ట్‌వేర్ ఇంజనీర్లు కొత్త విషయాలతో రావడం ఎప్పటికీ ఆపలేరని అనిపిస్తుంది. ఒక పెద్ద పూర్ణాంకం ఒక పూర్ణాంకం కంటే దాని విలువ చాలా పెద్దది. అయితే, జావాతో, దాన్ని పూర్ణాంకం వలె చదవవచ్చు. కింది కోడ్ దీనిని వివరిస్తుంది:
దిగుమతి java.util.Scanner;దిగుమతి java.math.BigInteger;
ప్రజా తరగతితరగతి{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
వ్యవస్థ .బయటకు.println('పెద్ద పూర్ణాంకం కోసం ఏదైనా పూర్ణాంకాన్ని నమోదు చేయండి:');
స్కానర్ స్కాన్ ఓబ్జె= కొత్తస్కానర్( వ్యవస్థ .లో);
బిగ్‌ఇంటెగర్ ఒకదానిపై=scanObj.nextBigInteger();
వ్యవస్థ .బయటకు.println(ఒకదానిపై);
scanObj.దగ్గరగా();
}
}
దిగుమతి ప్రకటన గమనించండి, దిగుమతి java.math.BigInteger ;. అలాగే, పెద్ద పూర్ణాంక రకం పెద్ద అక్షరం B తో మొదలవుతుందని గమనించండి మరియు చిన్న బి కాదు.
తదుపరి ఫ్లోట్ () పద్ధతి
ఇన్‌పుట్‌గా తదుపరి ఫ్లోట్ టోకెన్ కూడా ధృవీకరించబడుతుంది మరియు ఆమోదించబడుతుంది. కింది కోడ్‌ని ఉపయోగించవచ్చు:
దిగుమతి java.util.Scanner;ప్రజా తరగతితరగతి{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
వ్యవస్థ .బయటకు.ముద్రణ('ఏదైనా ఫ్లోట్‌ను నమోదు చేయండి:');
స్కానర్ స్కాన్ ఓబ్జె= కొత్తస్కానర్( వ్యవస్థ .లో);
తేలుతాయిఒకదానిపై=scanObj.తదుపరి ఫ్లోట్();
వ్యవస్థ .బయటకు.println(ఒకదానిపై);
scanObj.దగ్గరగా();
}
}
ఫ్లోట్ నంబర్ యొక్క ఉదాహరణ 23.456. లీడింగ్ లేదా ట్రెయిలింగ్ ఖాళీలు తీసివేయబడ్డాయి.
తదుపరి డబుల్ ()
ఇన్‌పుట్‌గా తదుపరి డబుల్ టోకెన్ కూడా ధృవీకరించబడుతుంది మరియు ఆమోదించబడుతుంది. కింది కోడ్‌ని ఉపయోగించవచ్చు:
దిగుమతి java.util.Scanner;ప్రజా తరగతితరగతి{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
వ్యవస్థ .బయటకు.ముద్రణ('ఏదైనా డబుల్ నమోదు చేయండి:');
స్కానర్ స్కాన్ ఓబ్జె= కొత్తస్కానర్( వ్యవస్థ .లో);
రెట్టింపుఒకదానిపై=scanObj.తదుపరి డబుల్();
వ్యవస్థ .బయటకు.println(ఒకదానిపై);
scanObj.దగ్గరగా();
}
}
డబుల్ నంబర్ యొక్క ఉదాహరణ 23.456. ఫ్లోట్ నుండి డబుల్ నంబర్ భిన్నంగా ఉంటుంది ఎందుకంటే దీనికి తక్కువ మార్జిన్ లోపం ఉంది. లీడింగ్ లేదా ట్రెయిలింగ్ ఖాళీలు తీసివేయబడ్డాయి.
తదుపరి లైన్ () పద్ధతి
తదుపరి లైన్ () పద్ధతి స్ట్రింగ్ కోసం. ఎంటర్ నొక్కిన తర్వాత స్ట్రింగ్ కీబోర్డ్ నుండి ఇన్‌పుట్ లైన్ అయితే, అది ‘ n’ అనే కొత్త లైన్ అక్షరాన్ని కలిగి ఉంటుంది. కింది కోడ్‌ని ఉపయోగించవచ్చు:
దిగుమతి java.util.Scanner;ప్రజా తరగతితరగతి{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
వ్యవస్థ .బయటకు.println(కలిగి ఉన్న పంక్తిని నమోదు చేయండి\n: ');
స్కానర్ స్కాన్ ఓబ్జె= కొత్తస్కానర్( వ్యవస్థ .లో);
స్ట్రింగ్ p=scanObj.తదుపరి లైన్();
వ్యవస్థ .బయటకు.println(p);
scanObj.దగ్గరగా();
}
}
స్ట్రింగ్ రకం పెద్ద అక్షరం S తో ప్రారంభమైందని గమనించండి మరియు చిన్న అక్షరాలు కాదు.
తదుపరి లైన్ (), hasNext () మరియు తదుపరి () పద్ధతులు ఈ వ్యాసంలో గతంలో ఉపయోగించబడ్డాయి. స్కానర్‌లో ఇతర పద్ధతులు మరియు ఇతర ప్రాచీన డేటా పద్ధతులు ఉన్నాయి - తర్వాత చూడండి.
వేరియబుల్‌కు ఇన్‌పుట్‌ను కేటాయించడం
కింది కోడ్ చూపినట్లుగా, వేరియబుల్‌కు ఇన్‌పుట్‌ను కేటాయించవచ్చు:
దిగుమతి java.util.Scanner;ప్రజా తరగతితరగతి{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
స్కానర్ స్కాన్ ఓబ్జె= కొత్తస్కానర్( వ్యవస్థ .లో);
వ్యవస్థ .బయటకు.ముద్రణ('పేరు నమోదు చేయండి: ');
స్ట్రింగ్ పేరు=scanObj.తదుపరి లైన్();
వ్యవస్థ .బయటకు.ముద్రణ('వయస్సును నమోదు చేయండి:');
intవయస్సు=scanObj.తదుపరిది();
వ్యవస్థ .బయటకు.ముద్రణ('జీతం నమోదు చేయండి:');
రెట్టింపుజీతం=scanObj.తదుపరి డబుల్();
వ్యవస్థ .బయటకు.println('పేరు:' +పేరు+ ', వయస్సు:' +వయస్సు+ 'జీతం:' +జీతం);
scanObj.దగ్గరగా();
}
}
ముగింపు
జావాలోని స్కానర్ అనేది java.util ప్యాకేజీలో ఒక తరగతి. ఈ తరగతి స్ట్రింగ్, కీబోర్డ్, ఫైల్ లేదా నెట్‌వర్క్ సాకెట్ నుండి ఇన్‌పుట్ చదవడం లక్ష్యంగా పెట్టుకుంది. ఈ వ్యాసం ప్రధానంగా కీబోర్డ్ నుండి ఇన్‌పుట్ చదవడం మరియు టెర్మినల్ విండోలో ఫలితాన్ని ప్రదర్శించడంపై దృష్టి పెట్టింది. స్ట్రింగ్, ఫైల్ లేదా నెట్‌వర్క్ ఛానెల్ నుండి ఇన్‌పుట్ చదవడానికి ఇలాంటి ఆలోచనలు ఉపయోగించవచ్చు.
కీబోర్డ్ ఇన్‌పుట్ యొక్క మొత్తం పంక్తిని చదవడానికి, తదుపరి లైన్ () పద్ధతిని ఉపయోగించండి. హేస్‌నెక్స్ట్ () మరియు తదుపరి () పద్ధతులు మరియు వైల్ లూప్ ఉపయోగించి లైన్‌ను స్ట్రింగ్‌గా టోకెన్‌లుగా విభజించవచ్చు. విభజన కోసం డిఫాల్ట్ డీలిమిటర్ స్పేస్, కానీ ప్రోగ్రామర్ వేరే డిలిమిటర్‌ను ఎంచుకోవచ్చు. అవసరమైతే, అయితే లూప్‌ను ఆపడానికి Ctrl+z చేయడం మర్చిపోవద్దు. ఈ వ్యాసంలో ప్రస్తావించని ఇతర పథకాలను ఉపయోగించి ప్రముఖ మరియు వెనుకంజలో ఉన్న ఖాళీలను తొలగించవచ్చు. టోకెన్‌ల ధ్రువీకరణ ఈ ఆర్టికల్‌లో ప్రస్తావించని ఇతర పథకాలను ఉపయోగించి కూడా చేయవచ్చు.
ఆదిమ విలువలను nextBolean (), nextByte (), nextInt (), మొదలైనవి ఉపయోగించి చదవవచ్చు.
జావా స్కానర్‌లో ఇంకా చాలా పద్ధతులు ఉన్నాయి. అయితే, స్కానర్ యొక్క ప్రాథమిక ఉపయోగం ఈ వ్యాసంలో వివరించబడింది. టోకెన్ ఎంపిక వాస్తవానికి సాధారణ వ్యక్తీకరణ పద్ధతులను ఉపయోగించి జరుగుతుంది. రెగ్యులర్ ఎక్స్‌ప్రెషన్ టెక్నిక్‌లను ఉపయోగించడం చర్చ, కొంత సమయం వరకు.