ది ' nextInt() ఇన్‌పుట్ డేటా యొక్క తదుపరి టోకెన్‌ను స్కాన్ చేయడానికి మరియు అన్వయించడానికి 'పద్ధతి ఉపయోగించబడుతుంది' int ”. ఇది ఇన్‌పుట్ ఆవిరి సహాయంతో అక్షరాలను స్కాన్ చేస్తుంది. ఇన్‌పుట్‌ను స్ట్రింగ్ రూపంలో సేకరించి నిల్వ చేయవచ్చు, నిర్దిష్ట ఫైల్, నిజ-సమయ సమాచారం/డేటా లేదా వినియోగదారు ఏదైనా సిస్టమ్ ఇన్‌పుట్ నుండి చదవవచ్చు.
ఈ పోస్ట్ క్రింది వాటిని ప్రదర్శిస్తుంది:
జావాలో స్కానర్ నెక్స్ట్ఇంట్() విధానం అంటే ఏమిటి?
ది ' nextInt() ” అనేది జావాలోని స్కానర్ ఆబ్జెక్ట్ యొక్క అంతర్నిర్మిత పద్ధతి, ఇది అక్షరాలను ఒక్కొక్కటిగా చదవడానికి మరియు వాటిని పూర్ణాంక రకంలో సవరించడానికి ఉపయోగించబడుతుంది. స్కానర్ ఆబ్జెక్ట్ అన్ని పూర్ణాంక విలువలను సేకరించే వరకు అంకెలను ఒక్కొక్కటిగా చదువుతుంది. అప్పుడు, అది వాటిని 32-బిట్ సంఖ్యా విలువగా మారుస్తుంది. సాధారణంగా, ఆ విలువ ఒక లో నిల్వ చేయబడుతుంది int వేరియబుల్.
జావాలో స్కానర్ nextInt() పద్ధతిని ఎలా ఉపయోగించాలి?
జావాలో స్కానర్ nextInt() పద్ధతి యొక్క సింటాక్స్ క్రింద పేర్కొనబడింది:
పబ్లిక్ Int nextInt ( )
ఉదాహరణ 1: లూప్‌లో స్కానర్ nextInt() పద్ధతి
ఉపయోగించుకోవడానికి ' nextInt() ” while లూప్ లోపల పద్ధతి, మొదటగా, ఒక నిర్దిష్ట పేరుతో స్ట్రింగ్‌ని తయారు చేసి, ఆ స్ట్రింగ్‌కు విలువను పాస్ చేయండి:
స్ట్రింగ్ s = 'Linuxin 12 - 5 = 7.0' ;
'ని ఉపయోగించి నిర్దిష్ట స్ట్రింగ్ వస్తువుతో కొత్త స్కానర్‌ను సృష్టించండి స్కానర్() 'పద్ధతి:
స్కానర్ abc = కొత్త స్కానర్ ( లు ) ;
దిగువ కోడ్ స్నిప్పెట్‌లో, మేము మొత్తం లూప్ చేస్తున్నాము ' abc ” కాసేపు లూప్ ఉపయోగించి స్కానర్ ఆబ్జెక్ట్. ఇప్పుడు, అయితే లూప్ లోపల, తదుపరి మూలకం ఉంటే int , ఇది ఇలా ప్రింట్ చేయబడుతుంది “ Int విలువ ”; లేకపోతే, తదుపరి మూలకం ''గా ముద్రించబడుతుంది. ఇతర విలువ ”:
అయితే ( abc.hasNext ( ) ) {ఉంటే ( abc.hasNextInt ( ) ) {
System.out.println ( 'పూర్ణాంక విలువ :' + abc.nextInt ( ) ) ;
}
లేకపోతే {
System.out.println ( 'ఇతర విలువ:' +abc.తదుపరి ( ) ) ;
}
}
కాల్ చేయండి' దగ్గరగా() 'ఫలితాన్ని స్క్రీన్‌పై ప్రదర్శించడానికి స్కానర్‌తో పాటు ఫంక్షన్:
abc.close ( ) ;
అవుట్‌పుట్
ఈ ఉదాహరణలో, “ని ఉపయోగించి ఉందిNextInt() ” పద్ధతిలో, మేము తదుపరి పూర్ణాంకం పూర్ణాంకమా కాదా అని నిర్ధారించి, తదనుగుణంగా ముద్రించగలుగుతాము. కానీ, మనం ఈ చెక్‌ను భర్తీ చేస్తే ఏమి చేయాలి మరియు ఏమి చూడండి ' nextInt() ” పద్ధతి తిరిగి వస్తుందా?
if/else బ్లాక్ లేకుండా కోడ్‌ని మళ్లీ అమలు చేద్దాం:
స్ట్రింగ్ s = 'Linuxin 12 - 5 = 7.0' ;స్కానర్ abc = కొత్త స్కానర్ ( లు ) ;
అయితే ( abc.hasNext ( ) ) {
System.out.println ( 'పూర్ణాంక విలువ :' + abc.nextInt ( ) ) ;
}
abc.close ( ) ;
ఇది అవుట్‌పుట్‌లో చూడగలిగినట్లుగా, ఇది ' ఇన్‌పుట్ అసమతుల్యత మినహాయింపు ”.
ఉదాహరణ 2: InputMismatchExceptionను నిర్వహించడానికి స్కానర్ nextInt() పద్ధతి
నిర్వహించడానికి ' inputMismatchException ”, ట్రై/క్యాచ్ స్టేట్‌మెంట్‌ని ఉపయోగించవచ్చు. లోపల ' ప్రయత్నించండి ” స్టేట్‌మెంట్ నిర్దిష్ట పేరుతో స్ట్రింగ్‌ను తయారు చేసి, నిర్వచించిన స్ట్రింగ్ ఆబ్జెక్ట్‌తో స్కానర్‌ను సృష్టించండి. అయితే ఇటరేటర్‌ని ఉపయోగించుకోండి మరియు పాస్ చేయండి ' ఉంది. తదుపరి() 'పద్ధతి:
ప్రయత్నించండి {స్ట్రింగ్ s = '2+5+5 Linuxhint= 12.0' ;
స్కానర్ abc = కొత్త స్కానర్ ( లు ) ;
అయితే ( abc.hasNext ( ) ) {
System.out.println ( 'పూర్ణాంక విలువ:' + abc.nextInt ( ) ) ;
}
abc.close ( ) ;
}
'ని పిలవండి క్యాచ్ ” ప్రకటన లోపాన్ని పట్టుకోవడానికి (అది ఉన్నట్లయితే) మరియు కన్సోల్‌లో అవుట్‌పుట్‌ను ప్రింట్ చేయండి:
క్యాచ్ ( మినహాయింపు ఇ ) {System.out.println ( 'మినహాయింపు: ' + మరియు ) ;
}
ఫలితంగా, మీరు చూడవచ్చు ' ఇన్‌పుట్ అసమతుల్యత మినహాయింపు కన్సోల్‌లో లైబ్రరీ:
జావాలోని స్కానర్ nextInt() పద్ధతి గురించి అంతే.
ముగింపు
ది ' nextInt() ” అనేది జావాలోని స్కానర్ ఆబ్జెక్ట్ యొక్క అంతర్నిర్మిత పద్ధతి, ఇది అక్షరాలను ఒక్కొక్కటిగా చదవడానికి మరియు వాటిని పూర్ణాంక రకంలో సవరించడానికి ఉపయోగించబడుతుంది. పేర్కొన్న స్కానర్ ఆబ్జెక్ట్ అన్ని పూర్ణాంకాల విలువలను సేకరించే వరకు అంకెలను వరుసగా చదువుతుంది. ఈ పోస్ట్ జావాలో nextInt() పద్ధతిని పేర్కొంది.