כדי להשתמש במחלקת הסורק, יש לייבא אותו תחילה. לאחר מכן, יש לייצר ממנו אובייקט. לאחר השימוש באובייקט הסורק, יש לסגור אותו. אובייקט זרם הקלט המייצג את המקלדת הוא System.in. לסורק יש שיטות רבות. רק אלה הנפוצים יוסברו במאמר זה.
תוכן המאמר
- שימוש פשוט במחלקת הסורקים
- יריקת שורת קלט לערכים
- קריאה ואימות סוגי נתונים פרימיטיביים
- הקצאת אסימון קלט למשתנה
- סיכום
שימוש פשוט במחלקת הסורקים
הקוד הבא מבקש מהמשתמש להקליד משפט ולאחר מכן הוא מציג את המשפט:
יְבוּא java.util.Scanner;
פּוּמְבֵּי מעמדהכיתה{
פּוּמְבֵּי סטָטִי בָּטֵלרָאשִׁי( חוּט []טוען) {
סריקת סורק Obj= חָדָשׁסוֹרֵק( מערכת .ב);
מערכת .הַחוּצָה.println('הקלד משפט והקש Enter:');
חוּט משפט=scanObj.nextLine();
מערכת .הַחוּצָה.println(משפט);
scanObj.סגור();
}
}
השורה הראשונה מייבאת את מחלקת הסורקים. בפונקציה הראשית, השורה הראשונה יוצרת אובייקט סורק באמצעות אובייקט System.in עבור המקלדת. ברגע שנוצר אובייקט הסורק, הוא מתחיל לחכות לקלט. השורה הבאה מדפיסה משפט, ומבקשת מהמשתמש להקליד משפט. השורה הבאה בקוד משתמשת בשיטת nextLine () של אובייקט הסורק כדי לקרוא את משפט המשתמש לאחר שהוא לוחץ על Enter. השורה שאחריה, בקוד, מדפיסה מחדש את המשפט בחלון הטרמינל. השורה האחרונה סוגרת את אובייקט הסורק.
יריקת שורת קלט לערכים
הקוד הבא מפצל את שורת הקלט למילים (אסימונים), תוך שימוש ברווח כמפריד:
יְבוּא java.util.Scanner;פּוּמְבֵּי מעמדהכיתה{
פּוּמְבֵּי סטָטִי בָּטֵלרָאשִׁי( חוּט []טוען) {
סריקת סורק Obj= חָדָשׁסוֹרֵק( מערכת .ב);
מערכת .הַחוּצָה.println('הקלד שורה של אסימונים והקש Enter:');
בזמן(scanObj.hasNext()){
מערכת .הַחוּצָה.println(scanObj.הַבָּא());
}
scanObj.סגור();
}
}
hasNext () ו- next () הן שתי שיטות אחרות של אובייקט הסורק. כאשר אובייקט הסורק קורא שורה, הוא שומר אותה. next () ניגש לאסימון (המילה) הבא. hasNext () מחזירה true אם יש אסימון אחר שטרם ניגש אליו.
למרבה הצער, המשתמש עדיין צפוי להזין קלט לפיצול והצגה מחדש עם קוד זה. לסיום כל זה, הקש Ctrl+z, ועליך לחזור לשורת הפקודה.
בקוד לעיל, המפריד מפריד בין אסימונים במרחב. ניתן להשתמש בדמות נוספת. הקוד הבא משתמש בפסיק. אל תשכח ללחוץ על Ctrl+z כדי לסיים את הלולאה אם אתה בודק את הקוד.
יְבוּא java.util.Scanner;פּוּמְבֵּי מעמדהכיתה{
פּוּמְבֵּי סטָטִי בָּטֵלרָאשִׁי( חוּט []טוען) {
סריקת סורק Obj= חָדָשׁסוֹרֵק( מערכת .ב);
מערכת .הַחוּצָה.println('הקלד שורה של אסימונים והקש Enter:');
scanObj.useDelimiter(',');
בזמן(scanObj.hasNext()){
מערכת .הַחוּצָה.println(scanObj.הַבָּא());
}
scanObj.סגור();
}
}
אם היית בודק את הקוד, היית מבחין שחללים באסימונים נכללו כחלק מאסימונים (פלט). הביטוי, scanObj.useDelimiter (,); הוקלד לאחר קריאת שורת הקלט; זה מה שהופך את הפסיק למפריד.
קריאה ואימות סוגי נתונים פרימיטיביים
שיטת nextBoolean ()
בקוד הבא, המשתמש צפוי להקליד נכון או לא נכון ללא המרכאות ולאחר מכן ללחוץ על מקש Enter אם המשתמש מקליד משהו אחר, כגון כן או לא, תוצג הודעת שגיאה.
יְבוּא java.util.Scanner;פּוּמְבֵּי מעמדהכיתה{
פּוּמְבֵּי סטָטִי בָּטֵלרָאשִׁי( חוּט []טוען) {
מערכת .הַחוּצָה.הדפס('אתה מעל גיל 24? ');
סריקת סורק Obj= חָדָשׁסוֹרֵק( מערכת .ב);
בוליאניbl=scanObj.הבא בוליאני();
אם (bl== נָכוֹן) {
מערכת .הַחוּצָה.println('אתה מעל גיל 24');
}
אַחֵר אם (bl== שֶׁקֶר) {
מערכת .הַחוּצָה.println('אתה מתחת לגיל 24');
}
scanObj.סגור();
}
}
מכיוון ש- java יפרסם הודעת שגיאה כל עוד הקלט אינו נכון או לא מדויק, אחרת אם שימשה במקום אחר.
ההבדל בין השיטות, print ו- println, הוא שהדפסה מצפה לקלט בשורה הנוכחית, בעוד println מצפה לקלט בשורה הבאה.
שיטת nextByte ()
עם מערכת התווים ASCII, תו הוא בתים אחד. עם זאת, עם כמה מערכי תווים מזרחיים, דמות עשויה להיות מורכבת מיותר מבייט אחד. ללא קשר לערכת התווים, שיטת nextByte קוראת ומאמתת את הבייט הבא של הקלט. ניתן להשתמש בקוד הבא למטרה זו:
יְבוּא java.util.Scanner;פּוּמְבֵּי מעמדהכיתה{
פּוּמְבֵּי סטָטִי בָּטֵלרָאשִׁי( חוּט []טוען) {
מערכת .הַחוּצָה.הדפס('מספר מספר<128, press Enter: ');
סריקת סורק Obj= חָדָשׁסוֹרֵק( מערכת .ב);
בייטbt=scanObj.nextByte();
מערכת .הַחוּצָה.println(bt);
scanObj.סגור();
}
}
אם יוקלט מספר גדול מ -127 או תו אלפבית עבור קוד זה, תישלח הודעת שגיאה.
nextInt () שיטה
ניתן לאמת ולקבל את אסימון המספר השלם הבא כקלט. ניתן להשתמש בקוד הבא:
יְבוּא java.util.Scanner;פּוּמְבֵּי מעמדהכיתה{
פּוּמְבֵּי סטָטִי בָּטֵלרָאשִׁי( חוּט []טוען) {
מערכת .הַחוּצָה.הדפס('הזן מספר שלם:');
סריקת סורק Obj= חָדָשׁסוֹרֵק( מערכת .ב);
intעל אחד=scanObj.nextInt();
מערכת .הַחוּצָה.println(על אחד);
scanObj.סגור();
}
}
מרחבים מובילים או נגררים הוסרו. עבור קוד זה יתקבל כל ערך שלם, כולל ערכים העולים על 127. בשיטות nextXXX () אלה, לאחר שהאימות נכשל, נשלחת הודעת שגיאה.
שיטת nextBigInteger ()
נראה כי מהנדסי תוכנה לעולם לא יפסיקו להמציא דברים חדשים. מספר שלם גדול הוא מספר שלם שערכו גדול בהרבה מזה של מספר שלם. עם זאת, עם Java, ניתן לקרוא אותו באותו אופן כמו המספר השלם. הקוד הבא ממחיש זאת:
יְבוּא java.util.Scanner;יְבוּא java.math.BigInteger;
פּוּמְבֵּי מעמדהכיתה{
פּוּמְבֵּי סטָטִי בָּטֵלרָאשִׁי( חוּט []טוען) {
מערכת .הַחוּצָה.println('הזן מספר שלם עבור מספר שלם גדול:');
סריקת סורק Obj= חָדָשׁסוֹרֵק( מערכת .ב);
BigInteger על אחד=scanObj.nextBigInteger();
מערכת .הַחוּצָה.println(על אחד);
scanObj.סגור();
}
}
שים לב להצהרת הייבוא, ייבא java.math.BigInteger ;. כמו כן, שים לב כי סוג מספר שלם גדול מתחיל באות ב 'ולא באות ב'.
שיטת nextFloat ()
ניתן לאמת ולקבל גם את אסימון הצפה הבא כקלט. ניתן להשתמש בקוד הבא:
יְבוּא java.util.Scanner;פּוּמְבֵּי מעמדהכיתה{
פּוּמְבֵּי סטָטִי בָּטֵלרָאשִׁי( חוּט []טוען) {
מערכת .הַחוּצָה.הדפס('הזן כל מצוף:');
סריקת סורק Obj= חָדָשׁסוֹרֵק( מערכת .ב);
לָצוּףעל אחד=scanObj.צף הבא();
מערכת .הַחוּצָה.println(על אחד);
scanObj.סגור();
}
}
דוגמה למספר צף הוא 23.456. מרחבים מובילים או נגררים הוסרו.
כפולה הבאה ()
ניתן לאמת ולקבל גם את האסימון הכפול הבא כקלט. ניתן להשתמש בקוד הבא:
יְבוּא java.util.Scanner;פּוּמְבֵּי מעמדהכיתה{
פּוּמְבֵּי סטָטִי בָּטֵלרָאשִׁי( חוּט []טוען) {
מערכת .הַחוּצָה.הדפס('הזן כל כפול:');
סריקת סורק Obj= חָדָשׁסוֹרֵק( מערכת .ב);
לְהַכפִּילעל אחד=scanObj.כפול הבא();
מערכת .הַחוּצָה.println(על אחד);
scanObj.סגור();
}
}
דוגמה למספר כפול היא 23.456. מספר כפול שונה מצוף מכיוון שיש לו פחות שגיאת שגיאה. מרחבים מובילים או נגררים הוסרו.
שיטת nextLine ()
שיטת nextLine () מיועדת למחרוזת. אם המחרוזת היא שורת הקלט מהמקלדת לאחר הקשה על Enter, היא יכולה להיות בעלת תו קו חדש, ' n'. ניתן להשתמש בקוד הבא:
יְבוּא java.util.Scanner;פּוּמְבֵּי מעמדהכיתה{
פּוּמְבֵּי סטָטִי בָּטֵלרָאשִׁי( חוּט []טוען) {
מערכת .הַחוּצָה.println('הזן שורה עם\n: ');
סריקת סורק Obj= חָדָשׁסוֹרֵק( מערכת .ב);
חוּט עמ=scanObj.nextLine();
מערכת .הַחוּצָה.println(עמ);
scanObj.סגור();
}
}
שים לב שסוג המחרוזת מתחיל באותיות רישיות S ולא באותיות קטנות.
השיטות nextLine (), hasNext () ו- next () שימשו בעבר במאמר זה. לסורק יש שיטות אחרות ושיטות נתונים פרימיטיביות אחרות - ראה בהמשך.
הקצאת קלט למשתנה
ניתן להקצות קלט למשתנה, כפי שהקוד הבא מראה:
יְבוּא java.util.Scanner;פּוּמְבֵּי מעמדהכיתה{
פּוּמְבֵּי סטָטִי בָּטֵלרָאשִׁי( חוּט []טוען) {
סריקת סורק Obj= חָדָשׁסוֹרֵק( מערכת .ב);
מערכת .הַחוּצָה.הדפס('הכנס שם: ');
חוּט שֵׁם=scanObj.nextLine();
מערכת .הַחוּצָה.הדפס('הזן גיל:');
intגיל=scanObj.nextInt();
מערכת .הַחוּצָה.הדפס('הזן שכר:');
לְהַכפִּילשכר=scanObj.כפול הבא();
מערכת .הַחוּצָה.println('שם:' +שֵׁם+ ', גיל: ' +גיל+ ', שכר: ' +שכר);
scanObj.סגור();
}
}
סיכום
הסורק ב- Java הוא שיעור בחבילה java.util. שיעור זה נועד לקרוא קלט ממחרוזת, מקלדת, קובץ או שקע רשת. מאמר זה התרכז בעיקר בקריאת קלט מהמקלדת ובהצגת התוצאה בחלון הטרמינל. ניתן להשתמש ברעיונות דומים לקריאת קלט מהמחרוזת, מהקובץ או מערוץ הרשת.
כדי לקרוא את כל שורת קלט המקלדת, השתמש בשיטת nextLine (). ניתן לפצל את השורה כמחרוזת לאסימונים באמצעות השיטות hasNext () ו- next () ולולאת ה- while. תוחם ברירת המחדל לפיצול הוא המרחב, אך המתכנת יכול לבחור מפריד אחר. אל תשכח לעשות Ctrl+z כדי לעצור את לולאת ה- while, במידת הצורך. הסרת רווחים מובילים ונגררים יכולה להתבצע באמצעות תוכניות אחרות שאינן מטופלות במאמר זה. ניתן לאמת את האסימונים גם באמצעות תוכניות אחרות שאינן מטופלות במאמר זה.
ניתן לקרוא ערכים פרימיטיביים באמצעות nextBoolean (), nextByte (), nextInt () וכו '.
לסורק הג'אווה יש עוד הרבה שיטות. עם זאת, השימוש הבסיסי בסורק הוסבר במאמר זה. בחירת האסימון נעשית למעשה באמצעות טכניקות ביטוי רגילות. השימוש בטכניקות הבעה רגילות הוא דיון, למשך זמן אחר.