Entrada y salida de tipos de datos comunes en Java

        Después de aprender el lenguaje C y cambiar a Java, la primera sensación es que el método de escritura de Java es muy complicado y, al mismo tiempo, no es tan conveniente como el lenguaje C en la entrada y salida de tipos de datos de uso común. En el lenguaje C, la mayoría de los formatos se pueden ingresar fácilmente con la función scanf, pero no en Java. No existe una declaración similar a scanf en Java. Este artículo se basa en mis hábitos de entrada y salida y el registro de hacer preguntas, y hace un resumen de estos diferentes tipos, como los números enteros, que son números enteros pero separados por parámetros. Las clases principales en la siguiente descripción son todas las clases Principales, y usamos Scanner para la entrada. Puede haber múltiples métodos para cada entrada o salida, y solo escribí una forma de escritura relativamente simple.

1. Tipo de carácter

        El tipo char mencionado aquí se refiere al caso en el que solo se ingresa un carácter.

 1.1 Formato de entrada:

import java.io.IOException;//导入包

public class Main {

    public static void main(String[] args) throws IOException {

        char ch = (char)System.in.read();//<1>

        System.out.println((int)ch);

    }

}

Descripción: debe usarse con IOException. En <1>, System.in se ingresa desde el flujo de entrada estándar (el más común es el teclado), y el método rand() es para leer el contenido de entrada de este flujo. El resultado de entrada de <1> es de tipo int y debe convertirse en tipo char.

1.2 Ejemplos

2, tipo entero

1.1 Entrada de formato int simple:

        Esto se refiere al caso en el que solo hay una entrada en formato int por línea. Por ejemplo, el caso en el que solo se ingresa un número entero por línea.

importar java.util.Scanner;

public class Main {     public static void main(String[] args) {         Scanner scan = new Scanner(System.in);         int num = scan.nextInt();         Sistema.salida.println(num);     } }

        

 1.2 Ejemplos

Observaciones: Se requiere un número largo, de lo contrario, el resultado será inexacto cuando el número sea demasiado grande.

2.1 Entrada en formato int con espacios:

        Algo así como formato 23 34. Hay un espacio entre los dos números. En este momento, usar solo la entrada int no resolverá el problema. Por supuesto, puede usar dos scan.nextInt() consecutivamente para ingresar. Sin embargo, también podemos en este momento, necesitamos cambiar el ángulo. Consideramos 23 34 como una cadena como un todo, y luego la dividimos en el espacio para dividirla en dos cadenas de 23 y 34, y convertimos estas dos cadenas en números enteros. Consulte el manual de ayuda oficial para el método split().

importar java.util.Scanner ;

clase pública Principal {     public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        String[] str = scan.nextLine().split("[ ]");//Dividido en varias partes, hay varias matrices de cadenas, aquí hay dos partes de
        int a = Integer.parseInt (str[0]);
        int b = Integer.parseInt(str[1]);//etc...
        System.out.println(a + " " + b);
    }
}

 2.2 Ejemplos

 

3.1 Entrada de formato int complejo

        Similar a la entrada a=3, b=2, el método es el mismo que se describe en 2.1. Aquí vamos directo al ejemplo.

3.2 Ejemplos

La entrada de tipo largo y tipo int es similar y no se repetirá. 

3, doble

        En Java, el tipo doble debe usarse más en lugar del tipo flotante.

        Lo principal del punto flotante es su salida formateada, como un formato que retiene dos lugares decimales. En Java, existe un método printf similar al lenguaje C, y también podemos usar el método format() en String para lograrlo.

1.1 double retiene la salida en formato de dos dígitos

importar java.util.Scanner;

public class Main { 
     public static void main(String[] args) { 

        Scanner scan = new Scanner(System.in); 
        número doble = scan.nextDouble(); 
        Cadena a = Cadena.format("%.2f", num); 
        Sistema.salida.println(a); 
     } 
}

//salida en formato printf:

//Sistema.out.printf("%2f", num);

1.2 Ejemplos

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        
        Scanner scan = new Scanner(System.in);
        String str = scan.nextLine();
        String[] num = str.split("[;,]");
        String a = String.format("%.2f", Double.parseDouble((num[1])));
        String b = String.format("%.2f", Double.parseDouble((num[2])));
        String c = String.format("%.2f", Double.parseDouble((num[3])));
        System.out.println("The each subject score of No. " + num[0] + " is " + a + ", " + b + ", " + c + ".");
    }
}

4. Ingrese varias veces

1.1 Formato de entrada

        En el lenguaje C, hay dos formas más sencillas de hacer un bucle de varias entradas:

while(scanf("%d", &n) != EOF) 

 while(~scanf("%d", &n) ) 

        En Java, también hay una manera fácil:

while(escanear.hasNext()) 

1.2 Ejemplos

 Debe tenerse en cuenta que cuando se ingresan múltiples grupos de caracteres únicos, deben ingresarse en formato de cadena para convertirlos en tipos de caracteres.

  

5. matriz

        La entrada es similar a la del lenguaje C. Sin embargo, debe tenerse en cuenta que para entradas como cadenas, en lenguaje C, es un tipo de puntero. En Java, tiene su propio tipo de cadena especial. No puede ingresar cada carácter en un ciclo sin aprender punteros como en el lenguaje C. formar una cadena.

1.1 Formato de entrada de matriz:

importar java.util.Scanner;

public class Main { 
   public static void main(String[] args) { 

       Scanner scan = new Scanner(System.in); 
       int[] arr = new int[3];//输入3个
       for(int i = 0; i < arr.length; i++) { 
           arr[i] = scan.nextInt(); 
       } 
       for(int i = 0; i < arr.length; i++) { 
           System.out.print(arr[i] + " "); 
       } 
  } 
}

2.1 Convertir matriz en cadena

        Simplemente use el método toString() en Arrays. 

importar java.util.Scanner;

importar java.util.Arrays;

public class Main { 
    public static void main(String[] args) { 

       Scanner scan = new Scanner(System.in); 
       int[] arr = new int[3];//输入3个
       for(int i = 0; i < arr.length; i++) { 
           arr[i] = scan.nextInt(); 
       } 
       System.out.println(Arrays.toString(arr)); 
   } 
}

Introduzca 1, 2, 3 y verá [1,2,3]. A veces, el formato de las preguntas de OJ es 1 2 3. [1,2,3] Este formato también se puede pasar.

6. Cuerda

        Dado que la mayor parte de la entrada se convierte en tipo de cadena. Por lo tanto, para las cadenas, hay muchas operaciones que deben convertirse, como convertir las cadenas divididas en enteros, tipos de coma flotante, matrices, etc.

1.1 Conversión de cadenas a enteros, tipos de coma flotante (tomar enteros como ejemplo)

int a = Integer.parseInt (str[0]);//Suponga que str[0] es un carácter '1' después de la división

1.2 Conversión de entero, punto flotante a cadena

numero int = 10;

// Método 1

String str1 = num + "";//"" representa una cadena vacía, que es diferente de nulo en Java

// método 2

Cadena str2 = Cadena.valueOf(num);

2.1 Convertir cadena en matriz de caracteres

 importar java.util.Scanner;

importar java.util.Arrays;

clase pública Principal {

        public static void main(String[] args) {

        Exploración del escáner = nuevo escáner (System.in); 

        Cadena str = scan.nextLine();

        char[] arr = str.toCharArray();

        for (int i = 0; i < arr.longitud; i++) {

               System.out.print(arr[i] + " ");

        }

      }

}

2.2 Convertir matriz de caracteres en cadena

// Método 1

nueva cadena (arr);

//método 2

String.copyValueOf(arr); 

3 ejemplos

Descripción: escriba una función que ingrese una cadena e implemente la inversión de la cadena. el código se muestra a continuación:

import java.util.Scanner;

public class Main {

    public static String my_reverse(String str) {

        int left = 0;
        int right = str.length() - 1;
        char[] arr = str.toCharArray();
        while(left < right) {
            char tmp = 0;
            tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
            left++;
            right--;
        }
        return new String(arr);
    }

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        String str = scan.next();
        String ret = my_reverse(str);
        System.out.println(ret);
    }
}

 El resultado es el siguiente:

7. Entrada rápida

        El uso de Scanner para la entrada es relativamente lento, aquí hay una nueva función de entrada y salida. En comparación con ellos, la ventaja es que la velocidad es relativamente rápida y la desventaja puede ser que es demasiado largo y la escritura es muy laboriosa.

import java.io.*;
//省略了Main
    public static void main(String[] args) throws IOException {
        
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        
        int a = Integer.parseInt(bf.readLine());
        System.out.println(a);
        double b = Double.parseDouble(bf.readLine());
        System.out.println(b);
        char c = bf.readLine().charAt(0);
        System.out.println(c);
        char d = (char)bf.read();//都可以，但是这个不能和多组输入连用，原因是它保留了换行。
        System.out.println(d);
        System.out.println("------");
        String str = null;
        //多组输入
        while((str = bf.readLine()) != null) {
            char ch = str.charAt(0);//其他的类似
            System.out.println(ch);
        }
    }

8. Escribe al final

        Estas entradas son comunes. Cuanto más escribas el código, mejor los dominarás.