basic i o operations java
Dans ce didacticiel vidéo, nous discuterons du mécanisme d'entrée-sortie Java tel que l'entrée utilisateur Java, InputStream, Java Printf, Println, etc. avec les périphériques d'E / S standard:
Dans chaque langage de programmation, nous avons besoin d'un mécanisme pour lire les données d'entrée et également envoyer les données traitées, également appelées Output, à l'utilisateur final.
Comme vous le savez, il existe de nombreux périphériques d'entrée et de sortie dans le monde du logiciel que les programmeurs peuvent utiliser pour lire des données et y écrire ou sortir des données.
Lisez notre Série complète de formations Java pour mieux comprendre les concepts Java.
Ce que vous apprendrez:
- Tutoriel vidéo sur les opérations d'E / S de base en Java
- Exemples supplémentaires - Flux d'entrée / sortie
- Conclusion
Tutoriel vidéo sur les opérations d'E / S de base en Java
À l'aide d'un programme Java, vous pouvez lire et écrire des données à partir de différentes sources et destinations. La lecture et l'écriture des sources et destinations de données incluent:
- Des dossiers
- Tuyaux
- Les connexions de réseau
- Tampons en mémoire ( Par exemple: tableaux)
- System.in, System.out, System.error
Dans ce didacticiel vidéo, nous disposerons de l'entrée sous forme de fichier et explorerons diverses classes, interfaces et méthodes disponibles pour lire les données du fichier.
Opérations d'E / S de base en Java:
Opérations sur les fichiers Java:
Java I / O (Input-Output) est un mécanisme standard qui traite l'entrée et génère la sortie. Le package «java.io» contient les méthodes pour effectuer toutes les opérations d'entrée et de sortie.
Pour effectuer des opérations d'E / S plus rapidement, Java utilise le concept de flux. Un flux peut être défini comme une séquence de données constituée d'octets.
Apprenons-en plus sur les flux d'E / S Java !!
Flux d'E / S standard en Java
Le langage Java offre un accès aux ressources système, aux périphériques d'entrée-sortie standard, etc. en utilisant une classe «System». Cette classe implémente une interface de programmation dépendante du système pour accéder à diverses ressources.
La classe System appartient au package «java.lang» de Java. En plus de fournir des flux d'E / S standard, la classe System fournit également un accès aux variables d'environnement, aux variables externes, au chargement de fichiers et de bibliothèques, ainsi qu'à une méthode utilitaire arrayCopy pour copier une partie d'un tableau.
Comme ce didacticiel est basé uniquement sur les E / S standard, nous ignorerons le reste des fonctionnalités fournies par la classe System ici.
Du point de vue Input-Output, la classe System propose les flux suivants:
# 1) Flux d'entrée standard (System.in)
Le flux d'entrée fourni par la classe System, System.in est utilisé pour lire les données d'entrée à partir d'un périphérique d'entrée standard tel qu'un clavier.
Le flux reste ouvert et est prêt à lire les données fournies par l'utilisateur au périphérique d'entrée standard.
L'exemple ci-dessous illustre la fonction System.in.read pour lire un seul chiffre entier.
public class Main { public static void main(String args()) throws java.io.IOException { int ch; System.out.println('Enter the character to be displayed : '); ch = System.in.read(); System.out.println('You entered : ' + (char)ch); } }Production:
# 2) Flux de sortie standard (System.out)
L'interface System.out de la classe System est utilisée pour écrire la sortie du programme sur le périphérique de sortie standard comme le moniteur. Dans la plupart des cas, l'interface System.out écrit la sortie de commande sur le périphérique de sortie standard.
Il utilise trois méthodes de la classe «PrintStream» car la sortie standard dérive de cette classe.
Ces méthodes sont:
- impression
- println
- écrivez
Les méthodes «print» et «println» ont les mêmes fonctionnalités, sauf pour une seule différence que la méthode println ajoute un caractère de nouvelle ligne ( n) à la sortie.
La méthode d'écriture n'est pas utilisée fréquemment, sauf dans les cas où des données non ASCII doivent être affichées.
L'exemple suivant illustre le flux System.out.
public class Main { public static void main(String args()) throws java.io.IOException { String stringType = 'Java Tutorial Series'; char() charTypeArray = { 'a', 'e', 'i', 'o', 'u' }; boolean booleanType = true; int integerType = 10; double doubleType = Math.PI; long longType = Long.MAX_VALUE; float floatType = Float.MIN_VALUE; System.out.println('String::' + stringType); System.out.print('Character::'); System.out.println(charTypeArray); System.out.println('Boolean::' + booleanType); System.out.println('Integer::' + integerType); System.out.println('Double::' + doubleType); System.out.println('Long::' + longType); System.out.println('Float::' + floatType); } } Production:
Le programme ci-dessus montre les fonctions «print» et «println» utilisées avec l'interface System.out. Ici, nous avons défini des variables de différents types de données et affichons chacune d'elles à l'aide de l'interface System.out.
# 3) Flux d'erreur standard (System.err)
Le flux d'erreur standard, System.err, est utilisé pour afficher les erreurs éventuelles lors de l'exécution du programme.
Comme le flux System.out, le flux d'erreur prend également en charge les trois méthodes de la classe PrintStream, print, println et écrit.
Méthodes pour lire l'entrée de la console
Outre le flux d'entrée décrit ci-dessus, il existe quelques méthodes supplémentaires permettant de lire les données d'entrée de la console en Java.
Ces méthodes sont décrites ci-dessous.
# 1) Classe BufferedReader
La classe BufferedReader a été introduite pour la première fois dans JDK 1.0 et est la méthode classique de lecture des données d'entrée depuis la console.
Le flux d'entrée (System.in) est encapsulé dans la classe InputStreamReader qui est à son tour encapsulée dans BufferedReader.
Questions d'entretien avancées pour oracle pl sql
Le programme suivant montre l'utilisation de la classe BufferedReader pour lire les données d'entrée de l'utilisateur.
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class Main { public static void main(String() args) throws IOException { BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); System.out.println('Enter the input string'); String name = reader.readLine(); System.out.println('You entered: ' + name); } } Production:
Dans le programme ci-dessus, nous avons déclaré un objet de la classe BufferedReader initialisé au flux System.in. En utilisant cet objet, nous lisons une ligne entière d'entrée.
Comme vous pouvez le voir, vous pouvez lire toutes les données en mémoire tampon, ce qui rend cette fonctionnalité très efficace. Le seul inconvénient est le code cryptique qui peut être difficile à retenir à chaque fois.
# 2) Classe de console
La classe «System.console» peut être utilisée pour lire les entrées de la console. Ceci est utilisé pour lire en particulier les caractères d'entrée comme un mot de passe depuis la ligne de commande.
La méthode de lecture des données d'entrée à l'aide de la classe console est actuellement la méthode la plus efficace et la plus préférée en Java.
Le programme suivant illustre la classe System.console.
public class Main { public static void main(String() args) { System.out.println('Enter the input string'); String name = System.console().readLine(); System.out.println('You entered: ' + name); } } Production:
En utilisant la classe System.console, vous pouvez lire les caractères d'entrée sans faire écho aux caractères. Par conséquent, cette méthode est plus utile pour lire les mots de passe. Deuxièmement, vous pouvez également utiliser des chaînes de format pour formater les données d'entrée, similaires à celles utilisées dans System.out.printf ().
Bien que ce soit la manière préférée de lire les données d'entrée, notez que la classe System.console ne peut pas être utilisée avec un environnement Java interactif comme les IDE.
# 3) Scanner
L'utilisation d'une classe de scanner pour lire les données d'entrée est probablement la méthode la plus rapide et la plus préférée. Le scanner est principalement utilisé pour analyser les types de données, y compris les types primitifs et les chaînes. Mais il peut également être utilisé pour lire les données d'entrée et les analyser à l'aide d'une entrée tokenisée.
La classe scanner utilise des expressions régulières à cet effet.
Le programme suivant lit les données d'entrée de l'utilisateur à l'aide de la classe scanner.
import java.util.Scanner; class Main { public static void main(String args()) { Scanner myscan = new Scanner(System.in); System.out.println('Enter the input:'); String mystr = myscan.nextLine(); System.out.println('You entered a string:'+mystr); System.out.println('Enter Next input:'); int num = myscan.nextInt(); System.out.println('You entered an integer:'+num); } } Production:
Dans le programme ci-dessus, nous avons utilisé la classe scanner pour lire la chaîne et les données entières.
Formatage de la sortie en Java à l'aide de printf
Nous avons déjà vu comment afficher la sortie dans un programme Java. Dans cette section, nous verrons comment formater cette sortie. Nous utilisons pour cela la fonction printf de la classe «PrintStream» avec le flux «System.out» de Java.
La fonction printf en Java est similaire à la fonction printf en C / C ++. Contrairement aux fonctions System.out.print et System.out.println qui acceptent un seul argument, System.out.printf prend plus d'un argument.
Voici les variantes de la fonction printf en Java.
| Ne pas | Prototype de fonction | Description |
|---|---|---|
| 1 | System.out.printf (chaîne); | Imprime une chaîne fournie dans l'argument sans aucune mise en forme |
| deux | System.out.printf (format, arguments); | Imprime la sortie en utilisant la chaîne de format «format» et les arguments spécifiés. |
| 3 | System.out.printf (paramètres régionaux, format, arguments); | Imprime la sortie en utilisant la chaîne de format spécifiée en appliquant les paramètres régionaux et les arguments. |
Notez que la fonction System.out.format () est la même que System.out.printf ().
La syntaxe générale pour spécifier la chaîne de format est la suivante:
%specifier => + for right-aligning, - for left-aligning. => to specify leading/trailing zeros and precision => suggests the data type.Par exemple:
System.out.println(“ ‘%05.2f’%n”, 2.28);Générera la sortie suivante:
«02 .28»
Nous aborderons en détail printf en Java dans les rubriques suivantes de ce didacticiel.
Questions fréquemment posées
Q # 1) Que sont l'entrée standard et la sortie standard?
Répondre: Les flux d'entrée et de sortie standard sont des canaux préconnectés pour communiquer entre le programme informatique et l'environnement extérieur lorsque le programme commence son exécution. Les trois flux d'E / S standards différents sont l'entrée standard (stdin), la sortie standard (stdout), l'erreur standard (stderr).
Q # 2) Qu'est-ce que l'entrée standard dans la programmation?
Répondre: L'entrée standard ou stdin est le flux utilisé pour lire l'entrée d'un périphérique d'entrée standard comme un clavier.
Q # 3) Qu'est-ce que le flux d'entrée-sortie?
Répondre: Un flux d'entrée-sortie représente une source à partir de laquelle vous lisez l'entrée et la destination vers laquelle vous dirigez votre sortie.
Un flux, en général, représente de nombreux périphériques qui sont utilisés comme source et destinations à savoir, clavier, fichier disque, moniteurs, etc.
Q # 4) Qu'est-ce que l'entrée standard en Java?
Répondre: L'entrée standard en Java est fournie par la classe System sous la forme d'un flux System.in. La classe System fait partie du package java.lang.
Q # 5) Quelle est la sortie standard en Java?
Répondre: La sortie standard en Java est fournie par la classe System en tant que flux System.out. La classe System fait partie du package java.lang.
Exemples supplémentaires - Flux d'entrée / sortie
Les flux représentent le flux de données et ces données peuvent être dans n'importe quel format (comme l'octet, le texte, le type de données primitif, etc.). Pour écrire des données dans une destination, le flux de sortie est utilisé et pour lire les données, le flux d'entrée est utilisé.
Différents formats de lecture et d'écriture
Les entrées / sorties peuvent être lues / écrites dans les différents formats suivants:
# 1) Lecture du fichier en tant que flux d'octets
Ici, les données seront lues au format octet. ' FileInputStream » et ' FileOutputStream «Les classes sont utilisées pour lire le contenu sous forme d'octet. De cette façon, pour chaque octet, le compilateur enverra une requête au système d'exploitation.
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class ByteStreamsDemo { public static void main(String() args) throws IOException { FileInputStream fin =null; FileOutputStream fout =null; try { fin=new FileInputStream('input.txt'); fout=new FileOutputStream('out.txt'); int c; while((c=fin.read() )!= -1) { fout.write(c); } } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { if(fin!=null) { fin.close(); }if(fout!=null) { fout.close(); } } } } 
# 2) Lire le fichier en tant que flux de caractères
De cette manière, le flux d'entrée sera lu au format caractère. Ainsi, pour chaque caractère, le compilateur enverra une requête au système d'exploitation. ' FileReader » et ' FileWriter » les classes sont utiles pour lire le contenu en tant que personnage.
public class CharStreamDemo { public static void main(String() args) throws IOException { FileReader input = null; FileWriter output = null; try { input = new FileReader('input.txt'); output = new FileWriter('out1.txt'); int c; while ((c = input.read()) != -1) { output.write(c); } } finally { if (input != null) { input.close(); } if (output != null) { output.close(); } } } } 
# 3) Mise en mémoire tampon du flux d'entrée / sortie
Lorsque vous utilisez les classes FileInputStream ou FileReader, pour chaque opération de lecture ou d'écriture, une nouvelle demande est envoyée au système d'exploitation. Cela peut donc entraîner des problèmes de performances. Afin d'éviter ce BufferedInputStream ou BufferedReader, les classes sont utilisées pour encapsuler les classes sans tampon.
Cela lit le flux d'entrée lorsque le tampon est vide.
De même, FileOutputStream ou FileWriter, les classes sont encapsulées avec BufferedOutputStream ou BufferedWriter pour écrire la sortie une fois que la mémoire tampon est pleine.
public class BufferedStreamDemo { public static void main(String() args) throws IOException { BufferedReader input = null; BufferedWriter output = null; try { input = new BufferedReader(new FileReader('input.txt')); output = new BufferedWriter(new FileWriter('out1.txt')); int c; while ((c = input.read()) != -1) { output.write(c); } } finally { if (input != null) { input.close(); } if (output != null) { output.close(); } } } } 
# 4) Lecture en tant que flux de données
Dans cette méthode, les classes DataInputStream ou DataOutputStream sont utilisées pour lire et écrire le contenu sous forme de types de données primitifs tels que boolean, char, byte, short, int, long, float, double et String. La plupart du temps, DataInputStream et DataOutputStream seront utilisés ensemble.
public class DataInputOutputStreamDemo { public static void main(String() args) { File file = new File('read.bin'); FileOutputStream fos = null; DataOutputStream dos = null; try { fos=new FileOutputStream(file); dos=new DataOutputStream(fos); dos.writeInt(50244); dos.writeDouble(400.253); dos.writeChar('d'); dos.flush(); } catch (IOException e) { e.printStackTrace(); }finally { try { if(fos!=null){ fos.close(); } if(dos!=null){ dos.close(); } } catch (Exception e) { e.printStackTrace(); } } /*Reading operation */ FileInputStream fis = null; DataInputStream dis = null; try { fis = new FileInputStream(file); dis = new DataInputStream(fis); System.out.println(dis.readInt()); System.out.println(dis.readDouble()); System.out.println(dis.readChar()); } catch (IOException e) { e.printStackTrace(); }finally { try { if(fis!=null){ fis.close(); } if(dis!=null){ dis.close(); } } catch (Exception e) { e.printStackTrace(); } } } } 
# 5) Lecture en tant que flux d'objets
ObjectInputStream / ObjectOutputStream, les classes sont utiles pour écrire des objets dans un fichier et lire les objets à partir du fichier. Pour stocker l'objet dans un fichier, la classe doit implémenter l'interface Serializable.
public class ObjectStreamDemo implements Serializable { int age ; String name; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } 
Nous allons créer un objet pour cette classe «ObjectStreamDemo» et nous allons écrire cet objet dans un fichier et lire le même objet à partir de ce fichier.
public class ObjectStreamDemoTest { public static void main(String() args) { // TODO Auto-generated method stub ObjectStreamDemo obj=new ObjectStreamDemo(); obj.setAge(32); obj.setName('bob'); try { FileOutputStream fos = new FileOutputStream('t.tmp'); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(obj); oos.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } FileInputStream fis; ObjectInputStream ois; try { fis = new FileInputStream('t.tmp'); ois = new ObjectInputStream(fis); ObjectStreamDemo obj1 = (ObjectStreamDemo)ois.readObject(); System.out.println(obj1.name); System.out.println(obj1.age); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch(Exception e) { e.printStackTrace(); } } } 
Opérations d'E / S de fichier
La classe de fichier est utile pour effectuer des opérations sur les fichiers.
Certaines des opérations de fichier effectuées à l'aide de la classe File incluent:
- Créer un fichier
- Vérifiez si le fichier existe
- Obtenez le chemin du fichier
- Ecrire le fichier
- Lisez le dossier
- Supprimer un fichier et renommer le fichier
- Vérifiez les autorisations de fichier et modifiez les autorisations de fichier
- Déplacer le fichier d'un répertoire vers un autre emplacement
Programme de démonstration pour créer, lire et écrire le fichier:
public class CreateFileDemo { public static void main(String() args) throws IOException { File newfile=new File('created.txt'); if(!newfile.exists()) { newfile.createNewFile(); System.out.println('file not exist'); } try { String FILENAME='created.txt'; String content='hi how are u'; FileWriter fwt = new FileWriter(FILENAME); BufferedWriter bwt = new BufferedWriter(fwt); bwt.write(content); System.out.println('writing completed ...'); bwt.close(); } catch (IOException e) { e.printStackTrace(); } } } 
Points clés à noter:
- Un flux est une représentation logique du flux de données.
- Vous pouvez lire / écrire des données dans un format différent comme l'octet, le caractère, l'objet, le type de données primitif.
- La classe de fichier est utilisée pour créer un fichier, supprimer le fichier et déplacer ou copier ou renommer le fichier.
- BufferedInputStream ou BufferedOutputStream est utilisé pour améliorer les performances en mettant en mémoire tampon les données.
Conclusion
Java a un package java.lang qui fournit les fonctions d'entrée et de sortie standard à l'aide de la classe System.
Outre les flux, System.in et System.out qui sont utilisés respectivement pour l'entrée et la sortie standard, il existe également d'autres méthodes telles que BufferedReader, la classe de console et la classe de scanner qui sont utilisées pour lire les entrées de l'utilisateur.
System.out stream utilise la fonction de classe «PrintStream», print et println pour afficher la sortie. Ce sont les fonctions qui sont utilisées pour afficher la sortie sans formatage. Une autre fonction «printf» qui est similaire à la fonction printf en C / C ++ est également utilisée en Java pour la sortie formatée.
Nous explorerons plus en détail la classe de scanner et la fonction printf en Java dans nos prochains tutoriels.
=> Visitez ici pour la série exclusive de didacticiels de formation Java.
Tutoriel PREV | Tutoriel SUIVANT
lecture recommandée
- Opérations d'entrée / sortie de base en C ++
- Opérations de sortie de fichier d'entrée en C ++
- Tutoriel Java Collections Framework (JCF)
- Déploiement Java: création et exécution d'un fichier JAR Java
- Machine virtuelle Java: comment JVM aide à exécuter une application Java
- Entrée-sortie et fichiers en Python (ouverture, lecture et écriture de Python dans un fichier)
- Modificateurs d'accès en Java - Tutoriel avec des exemples
- Tutoriel de réflexion Java avec des exemples