Java bringt mit seinem I/O-Paket verschiedene Streams mit, die dem Benutzer bei der Durchführung aller Java-Eingabe-/Ausgabevorgänge helfen. Diese Streams unterstützen alle Arten von Objekten, Datentypen, Zeichen, Dateien usw., um die E/A-Vorgänge vollständig auszuführen. Die Eingabe in Java kann mit bestimmten Methoden erfolgen, die unten im Artikel erwähnt werden.

Methoden zur Eingabe in Java

Es gibt zwei Wege Dadurch können wir Java-Eingaben vom Benutzer oder aus einer Datei übernehmen

• BufferedReader-Klasse
• Scannerklasse

1. Verwenden der BufferedReader-Klasse für die Zeichenfolgeneingabe in Java

Es handelt sich um eine einfache Klasse, die zum Lesen einer Zeichenfolge verwendet wird. Es gibt eine einfache Lesefunktion, die ein Zeichen liest, eine weitere Lesefunktion, die ein Array von Zeichen liest, und eine readLine()-Funktion, die eine Zeile liest.

InputStreamReader() ist eine Funktion, die den Eingabe-Byte-Stream in einen Zeichen-Stream umwandelt, sodass er wie von BufferedReader erwartet gelesen werden kann Strom von Charakteren. BufferedReader kann geprüfte Ausnahmen auslösen.

Nachfolgend finden Sie die Umsetzung des oben genannten Ansatzes:

// 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);  } }>

Ausgabe

Mayank Solanki 888 Entered String : Mayank Solanki Entered Integer : 888>

Verwenden der Buffer Reader-Klasse zum Lesen der Eingabe

Nachfolgend finden Sie die Umsetzung des oben genannten Ansatzes:

/*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) {  }  } }>

Ausgabe:

Enter your name: Geeks Name=Geeks>

2. Verwenden der Scanner-Klasse zum Erfassen von Eingaben in Java

Es handelt sich um eine erweiterte Version von BufferedReader, die in späteren Java-Versionen hinzugefügt wurde. Der Scanner kann formatierte Eingaben lesen. Es verfügt über unterschiedliche Funktionen für unterschiedliche Datentypen.

• Der Scanner ist viel einfacher zu lesen, da wir keine Würfe schreiben müssen, da er keine Ausnahme auslöst.
• Es wurde in späteren Versionen von Java hinzugefügt
• Es enthält vordefinierte Funktionen zum Lesen von Ganzzahlen, Zeichen und anderen Datentypen.

Syntax der Scanner-Klasse

Scanner scn = new Scanner(System.in);>

Scannerklasse importieren

' Um den Scanner verwenden zu können, müssen wir die Scanner-Klasse aus dem Util-Paket als importieren

import java.util.Scanner;>

Die integrierten Scannerfunktionen sind wie folgt:

• Ganze Zahl: nextInt()
• Schweben: nextFloat()
• Zeichenfolge: next() und nextLine()

Daher ist im Fall von Integer und String im Scanner kein Parsing erforderlich, wie wir es im BufferedReader benötigt haben.

// 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);  } }>

Ausgabe :

Entered String str1 : Geeks Entered String str2 : Geeks For Geeks Entered Integer : 123 Entered FloatValue : 123.090>

Beispiel 2:

// 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);  } }>

Ausgabe

Enter your name Geeks  Enter your rollno 5 Enter your marks 84.60 Name=Geeks  Rollno=5 Marks=84.60>

Unterschiede zwischen BufferedReader und Scanner

• BufferedReader ist eine sehr einfache Methode zum Lesen der Eingabe, die im Allgemeinen zum Lesen des Zeichenstroms verwendet wird. Es bietet einen Vorteil gegenüber dem Scanner, da es schneller als der Scanner ist, da der Scanner viele Nachbearbeitungen zum Parsen der Eingabe durchführt. wie in nextInt(), nextFloat() zu sehen
• BufferedReader ist flexibler, da wir die Größe der zu lesenden Stream-Eingabe angeben können. (Im Allgemeinen liest BufferedReader dort größere Eingaben als Scanner)
• Diese beiden Faktoren spielen eine Rolle, wenn wir größere Eingaben lesen. Im Allgemeinen dient die Scanner-Klasse der Eingabe.
• BufferedReader wird bevorzugt, da es synchronisiert ist. Beim Umgang mit mehreren Threads wird dies bevorzugt.
• Für anständige Eingaben und einfache Lesbarkeit. Der Scanner wird BufferedReader vorgezogen.