Java aporta diversos fluxos amb el seu paquet d'E/S que ajuda l'usuari a realitzar totes les operacions d'entrada-sortida de Java. Aquests fluxos admeten tot tipus d'objectes, tipus de dades, caràcters, fitxers, etc. per executar completament les operacions d'E/S. L'entrada a Java es pot fer amb determinats mètodes esmentats a continuació a l'article.
Mètodes per prendre entrada en Java
N'hi ha dues maneres mitjançant el qual podem prendre l'entrada de Java de l'usuari o d'un fitxer
- Classe BufferedReader
- Classe d'escàner
1. Ús de la classe BufferedReader per a l'entrada de cadena a Java
És una classe senzilla que s'utilitza per llegir una seqüència de caràcters. Té una funció senzilla de lectura que llegeix un caràcter, una altra de lectura que llegeix una matriu de caràcters i una funció readLine() que llegeix una línia.
InputStreamReader() és una funció que converteix el flux d'entrada de bytes en un flux de caràcters perquè es pugui llegir com BufferedReader espera un corrent de personatges. BufferedReader pot llançar excepcions marcades.
A continuació es mostra la implementació de l'enfocament anterior:
Java
// Java Program for taking user // input using BufferedReader Class import java.io.*; class GFG { // Main Method public static void main(String[] args) throws IOException { // Creating BufferedReader Object // InputStreamReader converts bytes to // stream of character BufferedReader bfn = new BufferedReader( new InputStreamReader(System.in)); // String reading internally String str = bfn.readLine(); // Integer reading internally int it = Integer.parseInt(bfn.readLine()); // Printing String System.out.println('Entered String : ' + str); // Printing Integer System.out.println('Entered Integer : ' + it); } }> Sortida
Mayank Solanki 888 Entered String : Mayank Solanki Entered Integer : 888>
Ús de la classe de lector de memòria intermèdia per llegir l'entrada
A continuació es mostra la implementació de l'enfocament anterior:
Java /*package whatever //do not write package name here */ import java.io.*; import java.io.BufferedReader; import java.io.InputStreamReader; class Easy { public static void main(String[] args) { // creating the instance of class BufferedReader BufferedReader reader = new BufferedReader( new InputStreamReader(System.in)); String name; try { System.out.println('Enter your name'); name = reader.readLine(); // taking string input System.out.println('Name=' + name); } catch (Exception e) { } } }> Sortida:
Enter your name: Geeks Name=Geeks>
2. Ús de la classe d'escàner per prendre entrada en Java
És una versió avançada de BufferedReader que es va afegir en versions posteriors de Java. L'escàner pot llegir l'entrada formatada. Té diferents funcions per a diferents tipus de dades.
reaccionar a l'estil en línia
- L'escàner és molt més fàcil de llegir, ja que no hem d'escriure llançaments, ja que no hi ha cap excepció.
- Es va afegir en versions posteriors de Java
- Conté funcions predefinides per llegir un nombre enter, un caràcter i altres tipus de dades també.
Sintaxi de la classe Scanner
Scanner scn = new Scanner(System.in);>
Importació de classe d'escàner
‘ Per utilitzar l'escàner hem d'importar la classe d'escàner del paquet d'utilitat com a
import java.util.Scanner;>
Les funcions de l'escàner integrat són les següents:
- Enter: nextInt()
- Flotador: nextFloat()
- Cadena: next() i nextLine()
Per tant, en el cas d'Integer i String a Scanner, no necessitem l'anàlisi com ho vam fer a BufferedReader.
Java // Java Program to show how to take // input from user using Scanner Class import java.util.*; class GFG { public static void main(String[] args) { // Scanner definition Scanner scn = new Scanner(System.in); // input is a string ( one word ) // read by next() function String str1 = scn.next(); // print String System.out.println('Entered String str1 : ' + str1); // input is a String ( complete Sentence ) // read by nextLine()function String str2 = scn.nextLine(); // print string System.out.println('Entered String str2 : ' + str2); // input is an Integer // read by nextInt() function int x = scn.nextInt(); // print integer System.out.println('Entered Integer : ' + x); // input is a floatingValue // read by nextFloat() function float f = scn.nextFloat(); // print floating value System.out.println('Entered FloatValue : ' + f); } }> Sortida:
Entered String str1 : Geeks Entered String str2 : Geeks For Geeks Entered Integer : 123 Entered FloatValue : 123.090>
Exemple 2:
Java // Java Program to implement // Scanner Class to take input import java.io.*; import java.util.Scanner; // Driver Class class Easy { // main function public static void main(String[] args) { // creating the instance of class Scanner Scanner obj = new Scanner(System.in); String name; int rollno; float marks; System.out.println('Enter your name'); // taking string input name = obj.nextLine(); System.out.println('Enter your rollno'); // taking integer input rollno = obj.nextInt(); System.out.println('Enter your marks'); // taking float input marks = obj.nextFloat(); // printing the output System.out.println('Name=' + name); System.out.println('Rollno=' + rollno); System.out.println('Marks=' + marks); } }> Sortida
Enter your name Geeks Enter your rollno 5 Enter your marks 84.60 Name=Geeks Rollno=5 Marks=84.60>
Diferències entre BufferedReader i Scanner
- BufferedReader és una manera molt bàsica de llegir l'entrada que s'utilitza generalment per llegir el flux de caràcters. Dóna un avantatge sobre Scanner, ja que és més ràpid que Scanner perquè Scanner fa molt postprocessament per analitzar l'entrada; com es veu a nextInt(), nextFloat()
- BufferedReader és més flexible, ja que podem especificar la mida de l'entrada del flux a llegir. (En general, és allà on BufferedReader llegeix una entrada més gran que Scanner)
- Aquests dos factors entren en joc quan llegim una entrada més gran. En general, la classe d'escàner serveix l'entrada.
- Es prefereix BufferedReader ja que està sincronitzat. Quan es tracta de diversos fils, és preferible.
- Per a una entrada decent i una lectura fàcil. Es prefereix l'escàner sobre BufferedReader.