Après avoir appris le langage C et être passé à Java, le premier sentiment est que la méthode d'écriture de Java est très compliquée, et en même temps, elle n'est pas aussi pratique que le langage C dans l'entrée et la sortie des types de données couramment utilisés. Dans le langage C, la plupart des formats peuvent être facilement entrés avec la fonction scanf, mais pas en Java. Il n'y a pas d'instruction similaire à scanf en Java. Cet article est basé sur mes habitudes d'entrée et de sortie et sur l'enregistrement des questions, et fait un résumé de ces différents types tels que les entiers, qui sont des entiers mais séparés par des paramètres. Les classes principales dans la description suivante sont toutes des classes Main, et nous utilisons Scanner pour l'entrée. Il peut y avoir plusieurs méthodes pour chaque entrée ou sortie, et je n'ai écrit qu'une manière relativement simple d'écrire.
1. Type de caractère
Le type char mentionné ici fait référence au cas où un seul caractère est entré.
1.1 Format d'entrée :
importjava.io.IOException;//导入包
publicclassMain {
publicstaticvoidmain(String[] args)throwsIOException {
charch = (char)System.in.read();//<1>
System.out.println((int)ch);
}
}
Description : il doit être utilisé avec IOException. Dans <1>, System.in est entré à partir du flux d'entrée standard (le plus courant est le clavier), et la méthode rand() consiste à lire le contenu d'entrée à partir de ce flux. Le résultat d'entrée de <1> est de type int et doit être converti en type char.
1.2 Exemples
2, type entier
1.1 Saisie au format int simple :
Cela fait référence au cas où il n'y a qu'une seule entrée au format int par ligne. Par exemple, le cas où un seul entier est saisi par ligne.
importer java.util.Scanner ;
public class Main { public static void main(String[] args) { Scanner scan = new Scanner(System.in); int num = scan.nextInt(); System.out.println(num); } }
1.2 Exemples
Remarques : un nombre long est requis, sinon le résultat sera inexact si le nombre est trop grand.
2.1 Saisie au format int avec espaces :
Quelque chose comme le format 23 34. Il y a un espace entre les deux nombres.Pour le moment, l'utilisation de l'entrée int seule ne résoudra pas le problème.Bien sûr, vous pouvez utiliser deux scan.nextInt() consécutivement pour entrer. Cependant, nous pouvons aussi à ce moment, nous devons changer l'angle. Nous considérons 23 34 comme une chaîne dans son ensemble, puis nous le divisons à l'espace pour le diviser en deux chaînes de 23 et 34, et convertissons ces deux chaînes en nombres entiers. Veuillez vous référer au manuel d'aide officiel pour la méthode split().
importer java.util.Scanner ;
public class Main { public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String[] str = scan.nextLine().split("[ ]");//Divisé en plusieurs morceaux, il y a plusieurs tableaux de chaînes, voici deux morceaux de
int a = Integer.parseInt (str[0]);
int b = Integer.parseInt(str[1]);//etc...
System.out.println(a + " " + b);
}
}
2.2 Exemples
3.1 Saisie du format int complexe
Semblable à l'entrée a=3, b=2, la méthode est la même que celle décrite en 2.1. Ici, nous passons directement à l'exemple.
3.2 Exemples
L'entrée de type long et de type int est similaire et ne sera pas répétée.
3、double型
En Java, le type double devrait être utilisé plutôt que le type flottant.
La principale chose à propos de la virgule flottante est sa sortie formatée, comme un format qui conserve deux décimales. En Java, il existe une méthode printf similaire au langage C, et nous pouvons également utiliser la méthode format() dans String pour y parvenir.
1.1 double conserve la sortie au format à deux chiffres
importer java.util.Scanner ;
public class Main { public static void main(String[] args) { Scanner scan = new Scanner(System.in); double num = scan.nextDouble(); Chaîne a = String.format("%.2f", num); System.out.println(a); } }// sortie au format printf :
//System.out.printf("%2f", num);
1.2 Exemples
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. Entrez plusieurs fois
1.1 Format d'entrée
En langage C, il existe deux manières plus simples de boucler plusieurs entrées :
while(scanf("%d", &n) != EOF)
tandis que(~scanf("%d", &n) )
En Java, il existe également un moyen simple :
tandis que(scan.hasNext())
1.2 Exemples
Il convient de noter que lorsque plusieurs groupes de caractères uniques sont entrés, ils doivent être entrés au format chaîne pour les convertir en types de caractères.
5. Tableau
L'entrée est similaire à celle du langage C. Cependant, il convient de noter que pour les entrées telles que les chaînes, en langage C, il s'agit d'un type de pointeur. En Java, il a son propre type de chaîne spécial. Vous ne pouvez pas saisir chaque caractère dans une boucle sans apprendre les pointeurs comme en langage C. faire une ficelle.
1.1 Format d'entrée du tableau :
importer 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 un tableau en chaîne
Utilisez simplement la méthode toString() dans Arrays.
importer java.util.Scanner ;
importer 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)); } }
Entrez 1, 2, 3 et vous verrez [1,2,3]. Parfois, le format des questions du JO est 1 2 3. [1,2,3] Ce format peut aussi être passé.
6. Chaîne
Étant donné que la plupart des entrées sont converties en type chaîne. Par conséquent, pour les chaînes, de nombreuses opérations doivent être converties, telles que la conversion des chaînes fractionnées en entiers, en types à virgule flottante, en tableaux, etc.
1.1 Conversion de chaînes en nombres entiers, types à virgule flottante (prenez les nombres entiers comme exemple)
int a = Integer.parseInt (str[0]);//Supposer que str[0] est un caractère '1' après division
1.2 Entier, conversion en virgule flottante en chaîne
nombre entier = 10 ;
// méthode 1
String str1 = num + "";//"" représente une chaîne vide, différente de null en Java
// méthode 2
Chaîne str2 = String.valueOf(num);
2.1 Convertir une chaîne en tableau de caractères
importer java.util.Scanner ;
importer java.util.Arrays ;
classe publique principale {
public static void main(String[] args) {
Numérisation du scanner = nouveau scanner (System.in);
Chaîne str = scan.nextLine();
char[] arr = str.toCharArray();
for (int i = 0; i < arr.longueur; i++) {
System.out.print(arr[i] + " ");
}
}
}
2.2 Convertir un tableau de caractères en chaîne
// méthode 1
nouvelle chaîne(arr);
//méthode 2
String.copyValueOf(arr);
3 exemples
Description : écrivez une fonction qui saisit une chaîne et implémente l'inversion de la chaîne. code afficher comme ci-dessous:
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);
}
}Le résultat est le suivant :
7. Saisie rapide
L'utilisation de Scanner pour l'entrée est relativement lente, voici une nouvelle fonction d'entrée et de sortie. Par rapport à eux, l'avantage est que la vitesse est relativement rapide, et l'inconvénient peut être qu'il est trop long et que la frappe est très laborieuse.
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. Écrivez à la fin
Ces entrées sont communes. Plus vous écrivez le code, mieux vous les maîtriserez.