basic i o operations java
In diesem Video-Tutorial werden wir den Java-Eingabe-Ausgabe-Mechanismus wie Java-Benutzereingabe, InputStream, Java Printf, Println usw. mit Standard-E / A-Geräten diskutieren:
In jeder Programmiersprache benötigen wir einen Mechanismus zum Lesen von Eingabedaten und zum Senden der verarbeiteten Daten, die auch als Ausgabe bezeichnet werden, an den Endbenutzer.
Wie Sie wissen, gibt es in der Softwarewelt viele Eingabe- und Ausgabegeräte, mit denen Programmierer Daten lesen und Daten daraus schreiben oder ausgeben können.
Lesen Sie unsere Schließen Sie die Java-Schulungsserie ab um mehr Einblick in Java-Konzepte zu erhalten.
Was du lernen wirst:
- Video-Tutorial zu grundlegenden E / A-Vorgängen in Java
- Zusätzliche Beispiele - Eingabe- / Ausgabestreams
- Fazit
Video-Tutorial zu grundlegenden E / A-Vorgängen in Java
Mit einem Java-Programm können Sie Daten aus verschiedenen Quellen und Zielen lesen und schreiben. Das Lesen und Schreiben von Datenquellen und -zielen umfasst:
- Dateien
- Rohre
- Netzwerkverbindungen
- In-Memory-Puffer ( Z.B: Arrays)
- System.in, System.out, System.error
In diesem Video-Tutorial haben wir die Eingabe als Datei und untersuchen verschiedene Klassen, Schnittstellen und Methoden, die zum Lesen von Daten aus der Datei verfügbar sind.
Grundlegende E / A-Operationen in Java:
Java-Dateivorgänge:
Java I / O (Input-Output) ist ein Standardmechanismus, der die Eingabe verarbeitet und die Ausgabe generiert. Das Paket „java.io“ enthält die Methoden zum Ausführen aller Eingabe- und Ausgabeoperationen.
Um E / A-Vorgänge schneller auszuführen, verwendet Java das Konzept von Streams. Ein Stream kann als eine Folge von Daten definiert werden, die aus Bytes bestehen.
Erfahren Sie mehr über Java-E / A-Streams!
Standard-E / A-Streams in Java
Die Java-Sprache bietet Zugriff auf Systemressourcen, Standardeingabe- / Ausgabegeräte usw. über eine Systemklasse. Diese Klasse implementiert eine systemabhängige Programmierschnittstelle für den Zugriff auf verschiedene Ressourcen.
Die Systemklasse gehört zum Java-Paket 'java.lang'. Neben der Bereitstellung von Standard-E / A-Streams bietet die Systemklasse auch Zugriff auf Umgebungsvariablen, externe Variablen, Laden von Dateien und Bibliotheken sowie eine Dienstprogrammmethode arrayCopy zum Kopieren eines Teils eines Arrays.
Da dieses Lernprogramm nur auf Standard-E / A basiert, werden wir den Rest der von der Systemklasse bereitgestellten Funktionen hier überspringen.
Unter dem Gesichtspunkt Eingabe / Ausgabe bietet die Systemklasse die folgenden Streams:
# 1) Standardeingabestream (System.in)
Der von der Systemklasse System.in bereitgestellte Eingabestream wird zum Lesen der Eingabedaten von einem Standardeingabegerät wie einer Tastatur verwendet.
Der Stream bleibt offen und ist bereit, die vom Benutzer an das Standardeingabegerät gelieferten Daten zu lesen.
Das folgende Beispiel zeigt die Funktion System.in.read zum Lesen einer einzelnen ganzzahligen Ziffer.
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); } }Ausgabe:
# 2) Standardausgabestream (System.out)
Die System.out-Schnittstelle der System-Klasse wird verwendet, um die Programmausgabe wie den Monitor auf das Standardausgabegerät zu schreiben. In den meisten Fällen schreibt die System.out-Schnittstelle die Befehlsausgabe auf das Standardausgabegerät.
Es werden drei Methoden aus der Klasse „PrintStream“ verwendet, da die Standardausgabe von dieser Klasse abgeleitet ist.
Diese Methoden sind:
- println
- schreiben
Die Methoden 'print' und 'println' haben dieselbe Funktionalität, mit Ausnahme eines einzigen Unterschieds, dass die println-Methode der Ausgabe ein Zeilenumbruchzeichen ( n) hinzufügt.
Die Schreibmethode wird nur in Fällen verwendet, in denen Nicht-ASCII-Daten angezeigt werden sollen.
Das folgende Beispiel zeigt den System.out-Stream.
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); } } Ausgabe:
Das obige Programm zeigt die Funktionen 'print' und 'println', die mit der System.out-Schnittstelle verwendet werden. Hier haben wir Variablen verschiedener Datentypen definiert und zeigen sie jeweils über die System.out-Schnittstelle an.
# 3) Standardfehlerstrom (System.err)
Der Standardfehlerstrom System.err wird verwendet, um eventuelle Fehler während der Ausführung des Programms anzuzeigen.
Wie der System.out-Stream unterstützt auch der Fehler-Stream die drei Methoden der PrintStream-Klasse print, println und write.
Methoden zum Lesen von Eingaben von der Konsole
Abgesehen von dem oben beschriebenen Eingabestream gibt es nur wenige weitere Methoden, mit denen wir Eingabedaten von der Konsole in Java lesen können.
Diese Methoden werden unten diskutiert.
# 1) Klasse BufferedReader
Die Klasse BufferedReader wurde erstmals in JDK 1.0 eingeführt und ist die klassische Methode zum Lesen von Eingabedaten von der Konsole.
Der Eingabestream (System.in) wird in die Klasse InputStreamReader eingeschlossen, die wiederum in BufferedReader eingeschlossen ist.
Das folgende Programm zeigt die Verwendung der BufferedReader-Klasse zum Lesen von Eingabedaten vom Benutzer.
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); } } Ausgabe:
Im obigen Programm haben wir ein Objekt der BufferedReader-Klasse deklariert, das mit System.in stream initialisiert wurde. Mit diesem Objekt lesen wir eine ganze Eingabezeile.
Wie Sie sehen können, können Sie die gesamten gepufferten Daten lesen, wodurch diese Funktionalität sehr effizient ist. Der einzige Nachteil ist der kryptische Code, an den man sich jedes Mal nur schwer erinnern kann.
# 2) Konsolenklasse
Die Klasse 'System.console' kann zum Lesen von Eingaben von der Konsole verwendet werden. Dies wird insbesondere verwendet, um Eingabezeichen wie ein Kennwort von der Befehlszeile zu lesen.
Die Methode zum Lesen von Eingabedaten mithilfe der Konsolenklasse ist derzeit die effizienteste und bevorzugte Methode in Java.
Das folgende Programm demonstriert die System.console-Klasse.
Fragen und Antworten zum Android-Interview pdf
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); } } Ausgabe:
Mit der System.console-Klasse können Sie die eingegebenen Zeichen lesen, ohne die Zeichen wiederzugeben. Daher ist diese Methode zum Lesen von Passwörtern nützlicher. Zweitens können Sie auch Formatzeichenfolgen verwenden, um die Eingabedaten zu formatieren, ähnlich wie in System.out.printf ().
Obwohl dies die bevorzugte Methode zum Lesen von Eingabedaten ist, beachten Sie, dass die Klasse System.console nicht mit einer interaktiven Java-Umgebung wie IDEs verwendet werden kann.
# 3) Scanner
Die Verwendung einer Scannerklasse zum Lesen von Eingabedaten ist wahrscheinlich die schnellste und bevorzugte Methode. Der Scanner wird hauptsächlich zum Parsen der Datentypen einschließlich primitiver Typen und Zeichenfolgen verwendet. Es kann aber auch verwendet werden, um die Eingabedaten zu lesen und sie mithilfe einer tokenisierten Eingabe zu analysieren.
Die Scannerklasse verwendet zu diesem Zweck reguläre Ausdrücke.
Das folgende Programm liest die Eingabedaten des Benutzers mithilfe der Scannerklasse.
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); } } Ausgabe:
Im obigen Programm haben wir die Scannerklasse verwendet, um die Zeichenfolgen- und Ganzzahldaten zu lesen.
Formatieren der Ausgabe in Java mit printf
Wir haben bereits gesehen, wie die Ausgabe in einem Java-Programm angezeigt wird. In diesem Abschnitt erfahren Sie, wie Sie diese Ausgabe formatieren. Zu diesem Zweck verwenden wir die printf-Funktion der Klasse 'PrintStream' zusammen mit dem Java-Stream 'System.out'.
Die printf-Funktion in Java ähnelt der printf-Funktion in C / C ++. Im Gegensatz zu System.out.print- und System.out.println-Funktionen, die ein einzelnes Argument verwenden, verwendet System.out.printf mehr als ein Argument.
Im Folgenden sind die Variationen der printf-Funktion in Java aufgeführt.
| Unterlassen Sie | Funktionsprototyp | Beschreibung |
|---|---|---|
| 1 | System.out.printf (Zeichenfolge); | Druckt eine im Argument angegebene Zeichenfolge ohne Formatierung |
| zwei | System.out.printf (Format, Argumente); | Druckt die Ausgabe mit der angegebenen Formatzeichenfolge 'Format' und Argumenten. |
| 3 | System.out.printf (Gebietsschema, Format, Argumente); | Druckt die Ausgabe unter Verwendung der angegebenen Formatzeichenfolge, indem das Gebietsschema und die Argumente angewendet werden. |
Beachten Sie, dass die Funktion System.out.format () mit System.out.printf () identisch ist.
Die allgemeine Syntax zum Angeben der Formatzeichenfolge lautet wie folgt:
%specifier => + for right-aligning, - for left-aligning. => to specify leading/trailing zeros and precision => suggests the data type.Zum Beispiel::
System.out.println(“ ‘%05.2f’%n”, 2.28);Erzeugt die folgende Ausgabe:
’02 .28 ’
Wir werden printf in Java in den späteren Themen dieses Tutorials ausführlich behandeln.
Häufig gestellte Fragen
F # 1) Was sind Standardeingang und Standardausgang?
Antworten: Standardeingabe- und -ausgabestreams sind vorverbundene Kanäle für die Kommunikation zwischen dem Computerprogramm und der externen Umgebung, wenn das Programm seine Ausführung beginnt. Die drei verschiedenen Standard-E / A-Streams sind Standardeingabe (stdin), Standardausgabe (stdout) und Standardfehler (stderr).
bestes Programm zur Überprüfung der Computertemperatur
Q # 2) Was ist Standardeingabe in der Programmierung?
Antworten: Standardeingabe oder stdin ist der Stream, der zum Lesen von Eingaben von einem Standardeingabegerät wie einer Tastatur verwendet wird.
Q # 3) Was ist der Input-Output-Stream?
Antworten: Ein Eingabe-Ausgabe-Stream stellt eine Quelle dar, von der Sie Eingaben lesen, und das Ziel, an das Sie Ihre Ausgabe richten.
Ein Stream repräsentiert im Allgemeinen viele Geräte, die als Quelle und Ziel verwendet werden, nämlich Tastatur, Festplattendatei, Monitore usw.
Q # 4) Was ist Standardeingabe in Java?
Antworten: Die Standardeingabe in Java wird von der Systemklasse als System.in-Stream bereitgestellt. Die Systemklasse ist Teil des Pakets java.lang.
Q # 5) Was ist die Standardausgabe in Java?
Antworten: Die Standardausgabe in Java wird von der Systemklasse als System.out-Stream bereitgestellt. Die Systemklasse ist Teil des Pakets java.lang.
Zusätzliche Beispiele - Eingabe- / Ausgabestreams
Streams stellen den Datenfluss dar und diese Daten können in jedem Format vorliegen (wie Byte, Text, primitiver Datentyp usw.). Um Daten in ein Ziel zu schreiben, wird der Ausgabestream verwendet, und um die Daten zu lesen, wird der Eingabestream verwendet.
Verschiedene Formate zum Lesen und Schreiben
Die Eingabe / Ausgabe kann in den folgenden verschiedenen Formaten gelesen / geschrieben werden:
# 1) Lesen der Datei als Byte-Stream
Hier werden die Daten im Byte-Format gelesen. „ FileInputStream ” und ' FileOutputStream „Klassen werden zum Lesen des Inhalts als Byte verwendet. Auf diese Weise sendet der Compiler für jedes Byte eine Anforderung an das Betriebssystem.
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) Lesen einer Datei als Zeichenstrom
Auf diese Weise wird der Eingabestream im Zeichenformat gelesen. Daher sendet der Compiler für jedes Zeichen eine Anforderung an das Betriebssystem. „ FileReader ” und ' FileWriter ” Klassen sind nützlich, um den Inhalt als Zeichen zu lesen.
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) Pufferung des Eingabe- / Ausgabestreams
Wenn Sie die Klassen FileInputStream oder FileReader verwenden, wird für jeden Lese- oder Schreibvorgang eine neue Anforderung an das Betriebssystem gesendet. Dies kann also zu Leistungsproblemen führen. Um diesen BufferedInputStream oder BufferedReader zu vermeiden, werden Klassen verwendet, um ungepufferte Klassen zu verpacken.
Dies liest den Eingabestream, wenn der Puffer leer ist.
Ebenso werden FileOutputStream- oder FileWriter-Klassen mit BufferedOutputStream oder BufferedWriter umbrochen, um die Ausgabe zu schreiben, sobald der Puffer voll ist.
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) Lesen als Datenstrom
Bei dieser Methode werden die Klassen DataInputStream oder DataOutputStream verwendet, um den Inhalt als primitive Datentypen wie Boolesche Werte, Zeichen, Bytes, Short, Int, Long, Float, Double und String zu lesen und zu schreiben. Meistens werden DataInputStream und DataOutputStream zusammen verwendet.
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) Lesen als Objektstrom
ObjectInputStream / ObjectOutputStream, Klassen sind nützlich, um Objekte in eine Datei zu schreiben und die Objekte aus der Datei zu lesen. Zum Speichern des Objekts in einer Datei sollte die Klasse die Serializable-Schnittstelle implementieren.
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; } } 
Wir werden ein Objekt für diese 'ObjectStreamDemo' -Klasse erstellen und dieses Objekt in eine Datei schreiben und dasselbe Objekt aus dieser Datei lesen.
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(); } } } 
Datei-E / A-Vorgänge
Die Dateiklasse ist nützlich für Dateivorgänge.
Einige der mit der Dateiklasse ausgeführten Dateivorgänge umfassen:
- Erstellen Sie eine Datei
- Überprüfen Sie, ob die Datei vorhanden ist
- Holen Sie sich den Pfad der Datei
- Schreiben Sie die Datei
- Lesen Sie die Datei
- Löschen Sie eine Datei und benennen Sie die Datei um
- Überprüfen Sie die Dateiberechtigungen und ändern Sie die Dateiberechtigungen
- Verschieben Sie die Datei von einem Verzeichnis an einen anderen Speicherort
Demo-Programm zum Erstellen, Lesen und Schreiben der Datei:
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(); } } } 
Wichtige zu beachtende Punkte:
- Ein Stream ist eine logische Darstellung des Datenflusses.
- Sie können Daten in einem anderen Format wie Byte, Zeichen, Objekt oder primitiven Datentyp lesen / schreiben.
- Die Dateiklasse wird verwendet, um eine Datei zu erstellen, die Datei zu löschen und die Datei zu verschieben, zu kopieren oder umzubenennen.
- BufferedInputStream oder BufferedOutputStream wird verwendet, um die Leistung durch Puffern der Daten zu verbessern.
Fazit
Java verfügt über ein java.lang-Paket, das die Standardeingabe- und -ausgabefunktionen mithilfe der Systemklasse bereitstellt.
Neben den Streams System.in und System.out, die für die Standardeingabe bzw. -ausgabe verwendet werden, gibt es auch andere Methoden wie BufferedReader, Konsolenklasse und Scannerklasse, mit denen Eingaben vom Benutzer gelesen werden.
Der System.out-Stream verwendet die Klassenfunktion 'PrintStream', 'print' und 'println', um die Ausgabe anzuzeigen. Mit diesen Funktionen wird die Ausgabe ohne Formatierung angezeigt. Eine andere Funktion „printf“, die der Funktion printf in C / C ++ ähnelt, wird auch in Java für die formatierte Ausgabe verwendet.
In unseren nächsten Tutorials werden wir mehr über die Scannerklasse und die printf-Funktion in Java erfahren.
=> Besuchen Sie hier für die exklusive Java Training Tutorial-Reihe.
PREV Tutorial | NÄCHSTES Tutorial
Literatur-Empfehlungen
- Grundlegende Eingabe- / Ausgabeoperationen in C ++
- Dateieingabe Ausgabevorgänge in C ++
- JCF-Tutorial (Java Collections Framework)
- Java-Bereitstellung: Erstellung und Ausführung einer Java-JAR-Datei
- Java Virtual Machine: Wie JVM beim Ausführen von Java-Anwendungen hilft
- Eingabe-Ausgabe und Dateien in Python (Python öffnen, lesen und in Datei schreiben)
- Zugriffsmodifikatoren in Java - Tutorial mit Beispielen
- Java Reflection Tutorial mit Beispielen