விசைப்பலகை உள்ளீடு

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சொல்) உருவாக்கவும், அதன் வகை , புதிதாக உருவாக்கப்பட்ட பொருளுக்கான தரவு ஆதாரமாக அப்ஜெக்டை Scanner அனுப்புகிறது .System.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();

நிரலின் செயலாக்கம் இந்த வரியை அடையும் போது, ​​அது இடைநிறுத்தப்பட்டு பயனர் தரவை உள்ளிடுவதற்கு காத்திருக்கும் மற்றும் Enter ஐ அழுத்தவும். பின்னர் பயனர் உள்ளிட்ட அனைத்தும் மாறியில் சேமிக்கப்படும் str.

விசைப்பலகையில் ஒரு எண்ணைப் படிக்க , உங்களுக்கு இந்த கட்டளை தேவை:

int number = console.nextInt();

இங்கே எல்லாம் முந்தைய கட்டளையைப் போலவே உள்ளது. நிரலின் செயலாக்கம் இந்த வரியை அடையும் போது, ​​அது இடைநிறுத்தப்பட்டு பயனர் தரவை உள்ளிடுவதற்கு காத்திருக்கும் மற்றும் Enter ஐ அழுத்தவும். அதன் பிறகு, பயனர் உள்ளிட்ட அனைத்தும் எண்ணாக மாற்றப்பட்டு மாறியில் சேமிக்கப்படும் 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; 
// b == 20; 
திரை வெளியீடு இருக்கும்:30