Java Scanner para lectura de datos

Actualizado 2021
La clase Scanner está disponible a partir de Java 5 y facilita la lectura de datos en los programas Java.
Primero veremos varios ejemplos de lectura de datos en Java con Scanner y después explicaremos en detalle como funciona.
Para utilizar Scanner en el programa tendremos que hacer lo siguiente:
1. Escribir el import
La clase Scanner se encuentra en el paquete java.util por lo tanto se debe incluir al inicio del programa la instrucción:
import java.util.Scanner;
2. Crear un objeto Scanner
Tenemos que crear un objeto de la clase Scanner asociado al dispositivo de entrada.
Si el dispositivo de entrada es el teclado escribiremos:
Scanner sc = new Scanner(System.in);
Se ha creado el objeto sc asociado al teclado representado por System.in
Una vez hecho esto podemos leer datos por teclado. 
3. Utilizar el Scanner
Para leer datos desde teclado con Scanner podemos usar los métodos nextXxx() donde Xxx indica el tipo de dato a leer:
  • nextByte()  para leer un dato de tipo byte.
  • nextShort()  para leer un dato de tipo short.
  • nextInt()  para leer un dato de tipo int.
  • nextLong()  para leer un dato de tipo long. 
  • nextFloat()  para leer un dato de tipo float. 
  • nextDouble()  para leer un dato de tipo double. 
  • nextBoolean()  para leer un dato de tipo boolean.
  • nextLine()  para leer un String hasta encontrar un salto de línea.
  • next()  para leer un String hasta el primer delimitador, generalmente hasta un espacio en blanco o hasta un salto de línea.  
 
Ejemplos de lectura:
Ejemplo de lectura por teclado de un número entero (tipo int):
int n;
System.out.print("Introduzca un número entero: ");
n = sc.nextInt(); //asigna a la variable n el número entero introducido por teclado    
Ejemplo de lectura de un número de tipo double:
double x;
System.out.print("Introduzca número de tipo double: ");
x = sc.nextDouble(); //asigna a la variable x el número double introducido por teclado 
Ejemplo de lectura de una cadena de caracteres (String):
String s;
System.out.print("Introduzca texto: ");
s = sc.nextLine(); //asigna a la variable s el String introducido por teclado          
Ejemplo de lectura de un número de tipo long:
long ln;
System.out.print("Introduzca un número: ");
ln = sc.nextLong(); //asigna a la variable ln el número long introducido por teclado   
Si el valor introducido por teclado no es del tipo esperado o de un tipo compatible al esperado, se produce un error. En este caso se lanza la excepción InputMismatchException
Ejemplo completo de programa Java con lectura de datos con Scanner:
El programa pide al usuario que introduzca por teclado su nombre y lo muestra por pantalla. A continuación pide que se introduzca por rteclado el valor del radio de una circunferencia de tipo double y muestra la longitud de la circunferencia. Además pide que se introduzca por teclado un número entero y muestra su cuadrado.
import java.util.Scanner;  //import de la clase Scanner

public class Ejemplo1Scanner {

    public static void main(String[] args) {  

           Scanner sc = new Scanner(System.in);  //Se crea un objeto Scanner
           String nombre;
           double radio;
           int n;

           System.out.print("Introduzca su nombre: ");       
           nombre = sc.nextLine();  //leer un String
           System.out.println("Hola " + nombre + "!!!");

           System.out.print("Introduzca el radio de la circunferencia: ");
           radio = sc.nextDouble(); //leer un double
           System.out.println("Longitud de la circunferencia: " + 2*Math.PI*radio);                
           
           System.out.print("Introduzca un número entero: ");
           n = sc.nextInt(); //leer un entero
           System.out.println("El cuadrado es: " + Math.pow(n,2));
     }
}
Funcionamiento interno de la clase Java Scanner.
Es importante conocer el funcionamiento interno de la clase Scanner para poder realizar las operaciones de lectura de forma correcta.
De forma resumida, el proceso de lectura por teclado en un programa Java es el siguiente:
  • Los datos que se introducen desde teclado se almacenan en una zona de memoria que vamoso a llamar buffer
  • Mediante un stream estos datos pasan al programa.
Un stream o flujo de datos es un objeto que hace de intermediario entre el programa y el origen o el destino de los datos. El programa lee del stream o escribe en él, sin importarle de donde proceden los datos físicamente o hacia qué dispositivo se dirigen realmente.
Un stream está formado por una secuencia de bytes utilizados para la entrada o salida de un programa.
Java crea de forma automática los siguientes streams cuando se ejecuta un programa: 
System.in: stream de entrada conectado al teclado 
System.out: stream de salida conectado al monitor
System.err: stream de salida conectado al monitor para mensajes de error.
Además de estos streams estándar, java proporciona una gran cantidad de clases para streams que permiten leer y escribir en ficheros.
  • Cuando en el programa aparece una instrucción para leer un dato por teclado, se accede al buffer de entrada en busca del dato. Si lo encuentra, lo extrae del buffer y lo incorpora al programa.
  • Si el dato no ha sido encontrado en el buffer generalmente se deberá a que el buffer está vacío. Esta es la situación más habitual. En este caso el programa espera a que el usuario introduzca el dato por teclado. Cuando el usuario lo introduce y pulsa intro entonces se extrae el valor introducido del buffer y se incorpora al programa.
  • Si el dato encontrado no es del tipo esperado o de un tipo compatible se produce un error. En este caso se lanza la excepción InputMismatchException. Esto se produce, por ejemplo, cuando se está ejecutando el método nextInt() para extraer un entero del buffer y se introduce por ejemplo un double o un char. El tipo de dato encontrado en el buffer no coincide con el tipo que se quiere leer.
Ejemplo: acciones internas que se realizan cuando se lee un número entero desde teclado.
int n;
System.out.print("Introduzca un número entero: ");     
n = sc.nextInt();  
Mediante la instrucción sc.nextInt() Scanner accede al buffer de entrada para obtener un dato de tipo int y asignarlo a la variable n.
Si en el buffer no hay nada (que será lo más habitual) el programa espera a que se introduzca un número. Cuando el usuario introduce el número y pulsa intro, se extrae ese número del buffer y se lo asigna a la variable n.


Importante: cuando se introducen datos desde teclado, se pueden introducir varios valores separados por espacios en blanco.
Por ejemplo, para el ejemplo anterior se podría haber introducido:
12 2.1 5
A continuación, utilizando los métodos adecuados de la clase Scanner se puede acceder a esos tokens y trabajar con ellos en el programa.
 
Ejemplo: acciones internas que se realizan cuando se quiere leer un número entero desde teclado pero se han introducido varios valores separados por espacios en blanco.
int n;
System.out.print("Introduzca un número entero: ");               
n = sc.nextInt(); 

Debemos teneclaro el funcionamiento de Scanner en estos casoso para evitar errores durante la ejecución del programa.
 
Si apartir de esta situación del buffer se pide al usuario que introduzca otro número entero:
System.out.print("Introduzca otro número entero: ");      
n = sc.nextInt();          
Ahora de forma interna se realizarían las siguientes acciones:
 

Para evitar estos errores la clase Scanner proporciona métodos para saber si hay tokens en el buffer y para saber el tipo del siguiente token a extraer: 
 
  • hasNext():  Devuelve un boolean. Indica si existe o no un siguiente token para extraer.
  • hasNextXxx():  Devuelve un boolean. Indica si el siguiente token a extraer es del tipo especificado por Xxx, por ejemplo hasNextInt(), hasNextDouble(), etc.
Ejemplo: programa que lee por teclado un número entero positivo. Si el valor introducido no es un número entero positivo se muestra un mensaje y se vuelve a pedir.
import java.util.Scanner;
public class Ejemplo2Scanner {
       public static void main(String[] args) {
              Scanner sc = new Scanner(System.in);
              int N;
              do {
                  System.out.print("Introduce un número entero positivo: ");
                  while (!sc.hasNextInt()) {
                         System.out.println("Valor no válido");
                         sc.next();
                         System.out.print("Introduce un número entero positivo: ");                               
                  }
                  N = sc.nextInt();
                  if(N <= 0){
                     System.out.println("El número debe ser positivo");                                           
                  }
              } while (N <= 0);
              System.out.println("Número introducido: " + N);
       }
}
En el programa se ha utilizado el método hasNextInt() para comprobar si el número que se introduce por teclado es de tipo int. El método hasNextInt() accede al buffer para comprobar si el siguiente token a extraer es un int. Si encuentra el buffer vacío espera a que el usuario introduzca un valor y una vez introducido comprueba su tipo. Si no es un int devuelve false. El while se está ejecutando mientras que el dato introducido por teclado no sea de tipo int.

Dentro del while aparece la instrucción:

sc.next();

Esta instrucción sirve para extraer del buffer el número no válido introducido. Es necesario escribirla ahí porque si no lo hacemos provocaremos que ese while se convierta en un bucle infinito. El dato no válido introducido seguirá estando en el buffer con lo que el método hasNextInt() comprobará de nuevo que no es válido y así seguirá indefinidamente.

  
Otro método que puede resultarnos útil cuando trabajamos con Scanner es el método  useDelimiter(String) que sirve para establecer un nuevo delimitador de tokens.

Cómo limpiar el buffer de entrada en Java
En el ejemplo anterior hemos visto que en ocasiones es necesario extraer del buffer de entrada los datos no válidos introducidos.
 
En el ejemplo se ha eliminado el dato con el método next().
 
Podemos limpiar el buffer mediante dos métodos:
  • next() extrae del buffer el siguiente token en forma de String. Debemos tener en cuenta que este método solo extrae un token, si hubiese más permanecerían en el buffer.
  • nextLine() extrae del buffer un String con todo el contenido del buffer hasta encontrar un salto de línea. El salto de línea no se incluye en el String devuelto. El salto de línea se elimina del buffer.
Cuando se introducen datos de distinto tipo desde teclado habrá situaciones en la que será necesario eliminar totalmente el contenido del buffer de entrada. De otro modo la lectura de datos no se realizará de forma correcta, en particular cuando se intenten introducir datos de tipo String.
 
Ejemplo: Programa que lee por teclado el nombre, edad y dirección de una persona y lo muestra por pantalla.
import java.util.Scanner;
public class Ejemplo3Scanner {
       public static void main(String[] args) {
              Scanner sc = new Scanner(System.in);
              String nombre, direccion;
              int edad;
              System.out.print("Introduce tu nombre: ");
              nombre = sc.nextLine(); //leer el nombre
              System.out.print("Introduce tu edad: ");
              edad = sc.nextInt(); //leer la edad
              System.out.print("Introduce tu dirección: ");
              direccion = sc.nextLine(); //leer la dirección                                                      
              System.out.println("Datos introducidos");
              System.out.println("Nombre: " + nombre);
              System.out.println("Edad: " + edad);
              System.out.println("Dirección: " + direccion);                                                      
       }
}
Si lo ejecutamos vemos que la lectura de datos no se realiza de forma correcta:
Introduce tu nombre: Juan Redondo
Introduce tu edad: 25
Introduce tu dirección: Datos introducidos                                                                        
Nombre: Juan Redondo
Edad: 25
Dirección:
Se ha leído por teclado el nombre y la edad pero el programa no se ha detenido para que el usuario introduzca la dirección por lo que la variable dirección queda sin valor.
 
La explicación a lo que ha ocurrido podemos verla de forma gráfica:
Primero se introduce el nombre por teclado:

La siguiente operación de lectura por teclado es la edad:

La siguiente operación de lectura por teclado es la dirección:


Después de leer la edad, el intro permanece en el buffer y si después intentamos leer un String, la lectura por teclado no se realizará.
 
La solución es sencilla:
 
Limpiar el buffer después de leer el número entero mediante el método nextLine();
 
El programa quedaría así:
import java.util.Scanner;
public class Ejemplo3Scanner {
       public static void main(String[] args) {
              Scanner sc = new Scanner(System.in);
              String nombre, direccion;
              int edad;
              System.out.print("Introduce tu nombre: ");
              nombre = sc.nextLine(); //leer el nombre
              System.out.print("Introduce tu edad: ");
              edad = sc.nextInt(); //leer la edad
			  
              sc.nextLine(); //limpiar el buffer de entrada
			  
              System.out.print("Introduce tu dirección: ");
              direccion = sc.nextLine(); //leer la dirección                                                      
              System.out.println("Datos introducidos");
              System.out.println("Nombre: " + nombre);
              System.out.println("Edad: " + edad);
              System.out.println("Dirección: " + direccion);                                                      
       }
}
Ahora, después de introducir la edad, el método nextLine() elimina el intro que ha quedado en el buffer por lo que la lectura de la dirección se realizará de forma correcta.
Introduce tu nombre: Juan Redondo
Introduce tu edad: 25
Introduce tu dirección: C/Mayor 134 - Madrid.                                                                     
Datos introducidos
Nombre: Juan Redondo                                                                                              
Edad: 25
Dirección: C/Mayor 134 - Madrid.
En general se debe limpiar el buffer de entrada de Scanner cuando tengamos que introducir un dato de tipo String después de haber introducido un dato de tipo numérico

Si quieres ver más ejemplos de entrada de datos en Java con Scanner los tienes en este enlace

Ejercicios Básicos en Java

93 comentarios:

  1. Excelente!!!!1, me ayudo bastante

    ResponderEliminar
  2. ~Me ayudo mucho en esto muchas gracias^^

    ResponderEliminar
  3. Gracias. Me alegro de que os sea útil.

    ResponderEliminar
    Respuestas
    1. excelenteeeeee !! gracias por este aporte

      Eliminar
    2. explicas mejor que mi profesor :v

      Eliminar
    3. que tal para poder limpiar la consola, he utilizado getRuntime, el System.out.print("\033[H\033[2J");
      System.out.flush(); y nada alguna otra solucion

      Eliminar
    4. como ago para desarrolar un programa que permita leer el nombre de una persona y como resultado muestre u saludo

      Eliminar
    5. import java.util.Scanner;
      public class JavaApplication335 {
      public static void main(String[] args) {
      Scanner sc = new Scanner(System.in);
      String nombre;
      System.out.print("Introduzca su nombre: ");
      nombre = sc.nextLine();
      System.out.println("Hola " + nombre + "!!!");
      }
      }

      En el código de arriba estaba jejej

      Eliminar
    6. no entendi ni me funciono nada, te odio

      Eliminar
    7. eres un buen cervatiyo

      Eliminar
  4. ¡Muchas gracias!

    Ese ".nextLine()" después de un ".nextInt()" me ha salvado de implementar soluciones más originales ;-)

    ResponderEliminar
  5. Pff!! tienes talentoo para esto! nunca ví un Blog como este! sigue así, pon más temas por fa (:

    ResponderEliminar
  6. no me ayudo en nada! -.-

    ResponderEliminar
    Respuestas
    1. por pendejo!!! y me vale madres... .l.(-.-).l.

      Eliminar
  7. Muy buena informacion,,, buen apunte...

    ResponderEliminar
  8. Hola gracias por la información. Tengo una duda en que casos hay la necesidad de usar más de un objeto Scanner.

    ResponderEliminar
    Respuestas
    1. Por ejemplo, cuando vas a leer datos por teclado y además quieres leer el contenido de un fichero de texto. Puedes usar un objeto Scanner para cada cosa.

      Eliminar
  9. y no hay ningun metodo como sc.nextChar();???

    ResponderEliminar
    Respuestas
    1. No, ahi puedes escribir algo como esto:
      Scanner sc;
      sc = new Scanner(System.in);
      char c;
      c=sc.next.charAt(0);

      // este es el equivalente

      Eliminar
  10. Gracias, tenía problemas con un nextLine() que al parecer no se ejecutaba, con esta info lo pude resolver.

    ResponderEliminar
  11. como hago usando la clase scanner , por ejemplo , para Imponerle que me ponga tal nombre , y que la persona no lo elija ?

    ResponderEliminar
  12. Excelente amigo de verdad gracias muy buena explicacion!

    ResponderEliminar
  13. PORQUE AL REALIZAR ESTO:
    System.out.print("Introduzca su nombre: ");
    nombre = sc.nextLine();
    System.out.println("Hola " + nombre + "!!!");

    Y AL IMPRIMIR nombre no me imprime la letra ñ?

    ResponderEliminar
    Respuestas
    1. porque ñ es de caracter especial

      Eliminar
    2. y tambien por que no existe en el abecedario ingles.

      Eliminar
  14. muy buen post gracias muchacho Dios te bendiga y te siga dando conocimiento para compartir fue de gran ayuda (:

    ResponderEliminar
  15. Gracias me ha servido de mucho...

    ResponderEliminar
  16. Muchas gracias por los comentarios, espero que os haya servido de ayuda para poder entender mejor el funcionamiento de la clase Scanner

    ResponderEliminar
  17. GRACIASSSSSSSSSSSS mas que util

    ResponderEliminar
  18. hola como puedo hacer si quiero hacer un ciclo para introducir 10 datos de personas con for y al comenzar la 2da vuelta me salta la segunda linea y evita introducir el nombre nuevamente? gracias

    System.out.println("Enter the Name of your " + i + " Seller: ");
    seller[i] = keyboard.nextLine();
    System.out.println("Enter your Sex('F' Female or 'M' Male: ");
    sex[i] = keyboard.next().charAt(0);
    System.out.println("How many T-shirt have the person sold?: ");
    tshirt[i] = keyboard.nextInt();
    quien tenga info acerca de este sera bien recibida,
    gracias.

    ResponderEliminar
    Respuestas
    1. Yo creo que no le pondría el nextLine sino solo next(); porque seller debe ser string no?

      Eliminar
    2. Si en el campo seller se lee nombre y apellido separado por espacio, next() solo obtiene el nombre dejando el apellido para elo siguiente next(). seller hay que leerlo con nextLine(). La solución paralo que planteas es escribir la instrución keyboard.nextLine(); justo después de la instrucción
      tshirt[i] = keyboard.nextInt();
      La explicación la tienes en esta entrada en el apartado: como limpiar el buffer en Java

      Eliminar
  19. Grande!!! Me ayudó mucho ya que estaba leyendo datos y strings y no entendía por qué se saltaba el string :-D

    ResponderEliminar
    Respuestas
    1. Daniel me alegro de que te haya servido de ayuda. A ti y a los demás que también han comentado antes que tenían el mismo problema de lectura. Es algo que nos ha pasado a todos y hasta que no lo descubres es muy frustrante porque en apariencia el código está bien pero la lectura no se hace de forma correcta.
      Un saludo y espero que sigas visitando el blog

      Eliminar
  20. hola muy buen post, oye tengo una duda cuando se usa br en cambio de sc para que es??

    ResponderEliminar
  21. gracias por tu explicacion esta muy completa me sirvio mucho

    ResponderEliminar
  22. en el double x; que declaraste , no lo usaste bien, es x.sc.nextDouble(); / y no n.sc.nextDouble();
    declaraste "x" para el double , no "n" ese era del int del ejemplo de arriba del double

    ResponderEliminar
    Respuestas
    1. Gracias por avisar, ya está corregido. Cosas del Copy-Paste

      Eliminar
  23. Para evitar escribir una línea de más (sc.nextLine()), simplemente hacemos la lectura con next, es decir:

    nombre=sc.next();

    ResponderEliminar
  24. en efecto haciendo nombre=sc.next(); funciona y no hay que hacer limpieza.

    ResponderEliminar
    Respuestas
    1. El problema de leer con next() es que si se introduce más de una palabra solo se toma la primera.

      Eliminar
    2. Eres el unico que me a podido explicar con claridad el Scanner gracias ni mi profesora de programacion sabe explicarla con bien solo da un papel con trabajo y que se encomiende uno a Dios porque tiene que sacarsela de la manga .

      Eliminar
    3. Me alegro de que te haya servido de ayuda. Gracias por seguir el blog ;)

      Eliminar
  25. Has resuelto la duda exacta que tenia con esta clase. Gracias

    ResponderEliminar
  26. Otra opción (para el problema con los nextInt() ) sería usar por ejemplo:
    int x = Integer.parseInt(sc.nextLine());
    De esta forma te lee la linea entera (descartando el retorno de carro) y te lo transforma a un int.

    ResponderEliminar
  27. si declaro una variable int, y en la consola se me pide un entero; pero si escribo cualquier otra cosa me truena el programa, metiendole un try- catch me permite correrlo pero se para el programa, si yo quisiera meterlo en un ciclo y terminar el programa hasta que se me ingrese un entero. ¿cómo podria hacerlo? algúna pista? Gracias.

    ResponderEliminar
    Respuestas
    1. puedes hacerlo con un do .. while
      boolean repetir;
      do{
      try{
      repetir = false;
      System.out.print("Introduce un número entero: ");
      n = sc.nextInt();
      System.out.println("Número introducido: " + n);
      }catch(InputMismatchException e){
      sc.nextLine();
      repetir = true;
      System.out.println("Debe introducir un número entero " + e.toString());
      }
      }while(repetir);

      Eliminar
    2. De nada Aaron, espero que te sirva. Saludos

      Eliminar
  28. tengo unas dudas donde te puedo contactar?

    ResponderEliminar
  29. Excelente aporte sinceramente [^^] Noob to java Here xd

    ResponderEliminar
  30. q la fuerza del pan te acompañe a todos lados

    ResponderEliminar
  31. Que tal estoy utilizando la clase Scanner pero quiero limpiar la pantalla; he utilizado Runtime.getRuntime().exec(), el System.out.print("\033[H\033[2J");System.out.flush();
    y nada alguna otra solucion saludos

    ResponderEliminar
  32. 1. Solicite al usuario la temperatura máxima del mes y la temperatura medida hoy, actualice el valor de la temperatura máxima si la temperatura leída hoy es mayor que la temperatura máxima.

    ResponderEliminar
  33. Buenísimo tu blog sigue así... Trata de subir mas informaciones como por ejemplo los tipos de librerías que se usan en java y sus funcionalidades...

    ResponderEliminar
  34. Buenísimo tu blog sigue así... Trata de subir mas informaciones como por ejemplo los tipos de librerías que se usan en java y sus funcionalidades...

    ResponderEliminar
  35. Me encantó tu explicación. Muy útil gracias!!!

    ResponderEliminar
  36. Buenas tardes

    Estoy buscando el codigo que me permita utilizar un periférico especifico, un scanner, con el fin de digitalizar unos formularios.

    ResponderEliminar
  37. ¿Como colocas el scanner en la encapsulación de datos es decir en el método establecer? saludos

    ResponderEliminar
  38. entonces hay el limpiar el buffer cada vez que entra un entero y después se quiere leer un string?

    ResponderEliminar
  39. Hola Amigos, y gracias por la ayuda de antemano...
    weno tengo un problema, estoy tratando de leer dos o mas cadenas continuamentes(en realidad es una lista de lecturas de nombres completos - nombres apPat apMat - con un while), algo parecido a esto:
    Scanner st=new Scanner(System.in);
    int c=10;
    while(c-->0)
    {
    System.out.print("Digite su nombre completo: ");
    String nombre=st.nextLine();
    }
    de momento eso, pero solo me leeria la primera iteracion y no asi la segunda iteracion y la que sigue. Ayuda...
    Posdata: es un ejemplo lo que puse, ya que estoy haciendo un ejercicio que incluye ese fragmento...

    ResponderEliminar
  40. necesito por favor el codigo que me permita leer al azar dos numeros y sumarlos; luego me permita comparar este resultado con una respuesta dada por mi desde el teclado en java

    ResponderEliminar
  41. Muy bueno, me ha servido de mucho, gracias

    ResponderEliminar
  42. package semana_03;
    import java.util.Scanner;
    public class Semana_03 {

    public static void main(String[] args) {
    Scanner sc= new Scanner(System.in);
    double n1,n2,n3,tot=0;
    String p ;
    p = "";
    System.out.println("ingrese datos n1");
    n1=sc.nextDouble();
    System.out.println("ingrese datos n2");
    n2=sc.nextDouble();
    System.out.println("ingrese caso 1,2");
    p=sc.nextLine();

    switch (p){
    case "Arroz":
    tot=n1*1;
    break;
    case "Leche":
    tot=n2*2;
    break;
    default:
    System.out.println("no se ingreso correctamente");
    }
    System.out.println("resultado"+tot);

    }

    }

    el problema es que no me quiere leer el cambo String y se salta directo a switch y me sale como resultado 0.0
    ingrese datos n1
    2
    ingrese datos n2
    3
    ingrese caso 1,2
    no se ingreso correctamente
    resultado0.0

    ResponderEliminar
  43. Hola, estoy estudiando java y realizo los ejercicios en NetBeans 8, pero en este último proyecto que estoy realizando, no me quiere importar "import java.util.Scanner;", me sale el mensaje unused import, me puedes ayudad por favor. De antemano gracias

    ResponderEliminar
  44. excelente! gracias por el aporte

    ResponderEliminar
  45. Graciaaas! Me ha sido de mucha ayuda

    ResponderEliminar
  46. Gracias. me salvaste de una noche de estrés. pase tratando de parar para que me volviera a pedir el dato, no pasaba del bucle hasta que limpie el buffer

    ResponderEliminar
  47. Gracias, siempre me lío con el Scanner y su maldito buffer! <3

    ResponderEliminar
  48. Gracias, me ha servido para arreglar un pequeño programa que estaba haciendo :)

    ResponderEliminar
  49. Hola, como hago para que solo lea entrada horizontales?

    ResponderEliminar