Upang magamit ang klase ng Scanner, kailangan muna itong mai-import. Pagkatapos nito, ang isang bagay ay dapat na instantiate mula dito. Matapos magamit ang bagay na Scanner, dapat itong sarado. Ang object ng input stream na kumakatawan sa keyboard ay System.in. Maraming mga pamamaraan ang scanner. Ang mga karaniwang ginagamit lamang ang ipapaliwanag sa artikulong ito.
Nilalaman ng Artikulo
- Simpleng paggamit ng Scanner Class
- Paglaway ng Input Line sa Mga Halaga
- Pagbabasa at Pagpapatunay ng Mga Karaniwang Uri ng Data
- Pagtatalaga ng Input Token sa isang Variable
- Konklusyon
Simpleng paggamit ng Scanner Class
Hinihiling ng sumusunod na code ang gumagamit na mag-type ng isang pangungusap, at pagkatapos ay ipinapakita nito ang pangungusap:
angkat java.util.Scanner;
pampubliko klaseAng klase{
pampubliko static walang bisapangunahing( String []mga argumento) {
Scanner scanObj= bagoScanner( Sistema .sa);
Sistema .palabas.println('Mag-type ng pangungusap at pindutin ang Enter:');
String pangungusap=scanObj.susunod na Linya();
Sistema .palabas.println(pangungusap);
scanObj.malapit na();
}
}
Ang unang linya ay nag-import ng klase ng Scanner. Sa pangunahing pagpapaandar, ang unang linya ay lumilikha ng isang object ng scanner gamit ang System.in na bagay para sa keyboard. Sa sandaling nilikha ang bagay ng scanner, nagsisimula itong maghintay para sa pag-input. Ang susunod na linya ay naglilimbag ng isang pahayag, na hinihiling sa gumagamit na mag-type sa isang pangungusap. Ang sumusunod na linya sa code ay gumagamit ng susunod naLine () na paraan ng object ng scanner upang mabasa ang pangungusap ng gumagamit pagkatapos niyang pindutin ang Enter. Ang linya pagkatapos, sa code, muling nai-print ang pangungusap sa window ng terminal. Isinasara ng huling linya ang object ng scanner.
Paglaway ng Input Line sa Mga Halaga
Hinahati ng sumusunod na code ang linya ng pag-input sa mga salita (token), gamit ang puwang bilang delimiter:
angkat java.util.Scanner;pampubliko klaseAng klase{
pampubliko static walang bisapangunahing( String []mga argumento) {
Scanner scanObj= bagoScanner( Sistema .sa);
Sistema .palabas.println('Mag-type ng isang linya ng mga token, at pindutin ang Enter:');
habang(scanObj.hasNext()){
Sistema .palabas.println(scanObj.susunod na());
}
scanObj.malapit na();
}
}
Ang hasNext () at ang susunod () ay dalawa pang pamamaraan ng scanner object. Kapag nagbasa ang bagay ng scanner ng isang linya, pinapanatili nito. susunod () ina-access ang susunod na token (salita). ang hasNext () ay nagbabalik totoo kung mayroong anumang iba pang token na hindi pa na-access.
Sa kasamaang palad, inaasahan pa ring mag-type ang gumagamit ng pag-input para sa paghahati at muling pagpapakita sa code na ito. Upang wakasan ang lahat ng iyon, pindutin ang Ctrl + z, at dapat kang bumalik sa prompt ng utos.
Sa code sa itaas, pinaghiwalay ng delimiter ang mga token sa puwang. Maaaring magamit ang ibang karakter. Ang sumusunod na code ay gumagamit ng kuwit. Huwag kalimutang pindutin ang Ctrl + z upang wakasan ang loop kung susubukan mo ang code.
angkat java.util.Scanner;pampubliko klaseAng klase{
pampubliko static walang bisapangunahing( String []mga argumento) {
Scanner scanObj= bagoScanner( Sistema .sa);
Sistema .palabas.println('Mag-type ng isang linya ng mga token, at pindutin ang Enter:');
scanObj.useDelimiter(',');
habang(scanObj.hasNext()){
Sistema .palabas.println(scanObj.susunod na());
}
scanObj.malapit na();
}
}
Kung nasubukan mo ang code, mapapansin mo na ang mga puwang sa mga token ay isinama bilang bahagi ng mga token (output). Ang expression, scanObj.useDelimiter (,); na-type pagkatapos mabasa ang linya ng pag-input; ito ang gumagawa ng kuwit, ang delimiter.
Pagbabasa at Pagpapatunay ng Mga Karaniwang Uri ng Data
pamamaraan ng susunod naBoolean ()
Sa sumusunod na code, inaasahan na mag-type ang gumagamit ng alinman sa totoo o mali nang walang mga quote at pagkatapos ay pindutin ang Enter key kung ang iba ay nagta-type ng iba pa, tulad ng oo o hindi, isang mensahe ng error ang ipapakita.
angkat java.util.Scanner;pampubliko klaseAng klase{
pampubliko static walang bisapangunahing( String []mga argumento) {
Sistema .palabas.mag-print('Nasa itaas ka ba ng 24? ');
Scanner scanObj= bagoScanner( Sistema .sa);
booleanbl=scanObj.susunodBoolean();
kung (bl== totoo) {
Sistema .palabas.println('Mahigit ka na sa 24');
}
iba pa kung (bl== hindi totoo) {
Sistema .palabas.println('Wala kang 24 taong gulang');
}
scanObj.malapit na();
}
}
Dahil ang java ay maglalabas ng isang mensahe ng error hangga't ang input ay hindi totoo o maling eksakto, ang iba pa kung nagamit sa halip na iba.
Ang pagkakaiba sa pagitan ng mga pamamaraan, print at println, ay inaasahan ng pag-print ang input sa kasalukuyang linya, habang inaasahan ng println ang input sa susunod na linya.
susunod na pamamaraan ng (BB) ()
Sa itinakdang character na ASCII, ang isang character ay isang byte. Gayunpaman, sa ilang mga hanay ng character sa Silangan, ang isang character ay maaaring binubuo ng higit sa isang byte. Malaya sa hanay ng character, binabasa at pinatutunayan ng pamamaraan ng susunod naByte ang susunod na byte ng pag-input. Ang sumusunod na code ay maaaring magamit para sa hangaring ito:
angkat java.util.Scanner;pampubliko klaseAng klase{
pampubliko static walang bisapangunahing( String []mga argumento) {
Sistema .palabas.mag-print('I-type ang numero<128, press Enter: ');
Scanner scanObj= bagoScanner( Sistema .sa);
bytebt=scanObj.susunodByte();
Sistema .palabas.println(bt);
scanObj.malapit na();
}
}
Kung ang isang bilang na mas malaki sa 127 o isang character na alpabeto ay nai-input para sa code na ito, isang mensahe ng error ang bibigyan.
susunodInt () Paraan
Ang susunod na integer token bilang isang input ay maaari ring mapatunayan at tanggapin. Maaaring gamitin ang sumusunod na code:
angkat java.util.Scanner;pampubliko klaseAng klase{
pampubliko static walang bisapangunahing( String []mga argumento) {
Sistema .palabas.mag-print('Ipasok ang anumang Integer:');
Scanner scanObj= bagoScanner( Sistema .sa);
intsa isa=scanObj.susunodInt();
Sistema .palabas.println(sa isa);
scanObj.malapit na();
}
}
Ang mga nangungunang o sumusunod na puwang ay tinanggal. Para sa code na ito, ang anumang halaga ng integer, kasama ang mga halagang higit sa 127, ay tatanggapin. Sa mga susunod na pamamaraangXXXX () na ito, kapag nabigo ang pagpapatunay, isang mensahe ng error ang inilabas.
susunodBigInteger () Paraan
Tila hindi hihinto ang mga inhinyero ng software na magkaroon ng mga bagong bagay. Ang isang malaking integer ay isang integer na ang halaga ay mas malaki kaysa sa isang integer. Gayunpaman, sa Java, mababasa ito sa parehong paraan tulad ng integer. Ang sumusunod na code ay naglalarawan nito:
angkat java.util.Scanner;angkat java.math.BigInteger;
pampubliko klaseAng klase{
pampubliko static walang bisapangunahing( String []mga argumento) {
Sistema .palabas.println('Ipasok ang anumang Integer para sa Big Integer:');
Scanner scanObj= bagoScanner( Sistema .sa);
BigInteger sa isa=scanObj.susunodBigInteger();
Sistema .palabas.println(sa isa);
scanObj.malapit na();
}
}
Tandaan ang pahayag sa pag-import, i-import ang java.math.BigInteger ;. Gayundin, tandaan na ang malaking uri ng integer ay nagsimula sa isang malaking B at hindi isang maliit na b.
susunodFloat () Paraan
Ang susunod na token ng float bilang isang input ay maaari ring mapatunayan at tanggapin. Maaaring gamitin ang sumusunod na code:
angkat java.util.Scanner;pampubliko klaseAng klase{
pampubliko static walang bisapangunahing( String []mga argumento) {
Sistema .palabas.mag-print('Ipasok ang anumang Float:');
Scanner scanObj= bagoScanner( Sistema .sa);
lumutangsa isa=scanObj.susunodFloat();
Sistema .palabas.println(sa isa);
scanObj.malapit na();
}
}
Ang isang halimbawa ng isang float number ay 23.456. Ang mga nangungunang o sumusunod na puwang ay tinanggal.
susunodDoble ()
Ang susunod na dobleng token bilang isang input ay maaari ding mapatunayan at tanggapin. Maaaring gamitin ang sumusunod na code:
angkat java.util.Scanner;pampubliko klaseAng klase{
pampubliko static walang bisapangunahing( String []mga argumento) {
Sistema .palabas.mag-print('Ipasok ang anumang Dobleng:');
Scanner scanObj= bagoScanner( Sistema .sa);
doblesa isa=scanObj.susunodDobleng();
Sistema .palabas.println(sa isa);
scanObj.malapit na();
}
}
Ang isang halimbawa ng dobel na numero ay 23.456. Ang isang dobleng numero ay naiiba mula sa isang float dahil mayroon itong mas kaunting margin of error. Ang mga nangungunang o sumusunod na puwang ay tinanggal.
pamamaraan ng susunod naLinya ()
Ang pamamaraan ng susunod naLinya () ay para sa isang string. Kung ang string ay ang linya ng pag-input mula sa keyboard pagkatapos ng pagpindot sa Enter, maaari itong magkaroon ng newline character, ‘ n’. Maaaring gamitin ang sumusunod na code:
angkat java.util.Scanner;pampubliko klaseAng klase{
pampubliko static walang bisapangunahing( String []mga argumento) {
Sistema .palabas.println('Magpasok ng isang linya na mayroon\n: ');
Scanner scanObj= bagoScanner( Sistema .sa);
String p=scanObj.susunod na Linya();
Sistema .palabas.println(p);
scanObj.malapit na();
}
}
Pansinin na ang uri ng string ay nagsimula sa malalaking S at hindi ang maliit na s.
Ang susunod naLine (), mayNext () at susunod () na pamamaraan ay ginamit dati, sa artikulong ito. Ang scanner ay may iba pang mga pamamaraan at iba pang mga primitive na pamamaraan ng data - tingnan sa paglaon.
Pagtatalaga ng Input sa isang Variable
Maaaring italaga ang input sa isang variable, tulad ng ipinapakita ng sumusunod na code:
angkat java.util.Scanner;pampubliko klaseAng klase{
pampubliko static walang bisapangunahing( String []mga argumento) {
Scanner scanObj= bagoScanner( Sistema .sa);
Sistema .palabas.mag-print('Ilagay ang pangalan: ');
String pangalan=scanObj.susunod na Linya();
Sistema .palabas.mag-print('Enter Age:');
intedad=scanObj.susunodInt();
Sistema .palabas.mag-print('Pumasok sa Suweldo:');
doblesuweldo=scanObj.susunodDobleng();
Sistema .palabas.println('Pangalan:' +pangalan+ ', Edad:' +edad+ ', Suweldo:' +suweldo);
scanObj.malapit na();
}
}
Konklusyon
Ang Scanner sa Java ay isang klase sa java.util package. Nilalayon ng klase na ito na basahin ang input mula sa isang string, keyboard, file, o network socket. Pangunahing nakatuon ang artikulong ito sa input ng pagbabasa mula sa keyboard at ipinapakita ang resulta sa window ng terminal. Maaaring gamitin ang mga katulad na ideya upang mabasa ang input mula sa string, file, o network channel.
Upang mabasa ang buong linya ng pag-input ng keyboard, gamitin ang susunod naLine () na pamamaraan. Ang linya bilang isang string ay maaaring hatiin sa mga token, gamit ang hasNext () at mga susunod na () pamamaraan, at ang habang loop. Ang default na delimiter para sa paghahati ay ang puwang, ngunit ang programmer ay maaaring pumili ng ilang iba pang delimiter. Huwag kalimutang gawin ang Ctrl + z upang ihinto ang habang loop, kung kinakailangan. Ang pag-alis ng mga nangungunang at sumunod na puwang ay maaaring gawin gamit ang iba pang mga iskema na hindi naipunan sa artikulong ito. Ang pagpapatunay ng mga token ay maaari ding gawin gamit ang iba pang mga scheme na hindi natugunan sa artikulong ito.
Maaaring basahin ang mga primitive na halaga gamit ang susunod naBoolean (), nextByte (), nextInt (), atbp. Ang mga pamamaraang susunodXXX () na ito ay nagpapatunay, at inaalis din ang mga humahantong at sumusunod na mga puwang.
Ang Java Scanner ay may maraming mga pamamaraan. Gayunpaman, ang pangunahing paggamit ng Scanner ay naipaliwanag sa artikulong ito. Ang pagpili ng isang token ay talagang ginagawa gamit ang mga regular na diskarte sa pagpapahayag. Ang paggamit ng regular na mga diskarte sa pagpapahayag ay talakayan, para sa ilang ibang oras.