Java trae varios Streams con su paquete de E/S que ayuda al usuario a realizar todas las operaciones de entrada y salida de Java. Estos flujos admiten todo tipo de objetos, tipos de datos, caracteres, archivos, etc. para ejecutar completamente las operaciones de E/S. La entrada en Java se puede realizar con ciertos métodos que se mencionan a continuación en el artículo.

Métodos para recibir información en Java

Hay dos caminos mediante el cual podemos tomar la entrada de Java del usuario o de un archivo

• Clase BufferedReader
• Clase de escáner

1. Uso de la clase BufferedReader para entrada de cadenas en Java

Es una clase simple que se utiliza para leer una secuencia de caracteres. Tiene una función simple read que lee un carácter, otra read que lee una matriz de caracteres y una función readLine() que lee una línea.

InputStreamReader() es una función que convierte el flujo de entrada de bytes en un flujo de caracteres para que pueda leerse como BufferedReader espera un flujo de personajes. BufferedReader puede generar excepciones marcadas.

A continuación se muestra la implementación del enfoque anterior:

si no, si bash

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

Producción

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

Uso de la clase de lector de búfer para leer la entrada

A continuación se muestra la implementación del enfoque anterior:

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

Producción:

Enter your name: Geeks Name=Geeks>

2. Uso de la clase Scanner para recibir información en Java

Es una versión avanzada de BufferedReader que se agregó en versiones posteriores de Java. El escáner puede leer entradas formateadas. Tiene diferentes funciones para diferentes tipos de tipos de datos.

• El escáner es mucho más fácil de leer ya que no tenemos que escribir lanzamientos ya que no genera ninguna excepción.
• Fue agregado en versiones posteriores de Java.
• Contiene funciones predefinidas para leer un número entero, un carácter y también otros tipos de datos.

Sintaxis de la clase Scanner

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

Importación de clase de escáner

‘ Para usar Scanner necesitamos importar la clase Scanner del paquete util como

import java.util.Scanner;>

Las funciones del escáner incorporado son las siguientes:

• Entero: siguienteInt()
• Flotar: siguienteFlotar()
• Cadena : siguiente() y siguientelínea()

Por lo tanto, en el caso de Integer y String en Scanner, no requerimos el análisis como lo requerimos en BufferedReader.

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

Producción :

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

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

Producción

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

Diferencias entre BufferedReader y Scanner

• BufferedReader es una forma muy básica de leer la entrada que generalmente se usa para leer el flujo de caracteres. Le da una ventaja sobre Scanner porque es más rápido que Scanner porque Scanner realiza mucho posprocesamiento para analizar la entrada; como se ve en nextInt(), nextFloat()
• BufferedReader es más flexible ya que podemos especificar el tamaño de la entrada del flujo que se leerá. (En general, es allí donde BufferedReader lee entradas más grandes que el Escáner)
• Estos dos factores entran en juego cuando leemos información más amplia. En general, la clase Scanner sirve la entrada.
• Se prefiere BufferedReader ya que está sincronizado. Es preferible tratar con múltiples subprocesos.
• Para una entrada decente y fácil lectura. Se prefiere el escáner a BufferedReader.