basic i o operations java
V tomto výukovém videu budeme diskutovat o mechanismu vstupu a výstupu Java, jako je vstup uživatele Java, InputStream, Java Printf, Println atd., Se standardními I / O zařízeními:
V každém programovacím jazyce musíme mít mechanismus pro čtení vstupních dat a také odesílání zpracovaných dat, které jsou také známé jako výstup, koncovému uživateli.
Jak víte, ve světě softwaru existuje mnoho vstupních a výstupních zařízení, která programátoři mohou použít ke čtení dat a zápisu nebo výstupu dat.
Přečtěte si naše Kompletní série školení Java získat více informací o konceptech Java.
Co se naučíte:
Výukový program o základních operacích I / O v Javě
Pomocí programu Java můžete číst a zapisovat data z různých zdrojů a cílů. Čtení a zápis datových zdrojů a cílů zahrnují:
- Soubory
- Trubky
- Síťová připojení
- Vyrovnávací paměti v paměti ( Např: pole)
- System.in, System.out, System.error
V tomto videonávodu budeme mít vstup jako soubor a prozkoumáme různé třídy, rozhraní a metody, které jsou k dispozici ke čtení dat ze souboru.
Základní operace IO v Javě:
Operace se soubory Java:
Java I / O (Input-Output) je standardní mechanismus, který zpracovává vstup a generuje výstup. Balíček „java.io“ obsahuje metody pro provádění všech vstupních a výstupních operací.
Pro rychlejší provádění I / O operací používá Java koncept streamů. Proud lze definovat jako posloupnost dat skládající se z bajtů.
Zjistíme více o I / O streamech Java !!
Standardní I / O proudy v Javě
Jazyk Java nabízí přístup k systémovým prostředkům, standardním vstupně-výstupním zařízením atd. Pomocí třídy „Systém“. Tato třída implementuje systémově závislé programovací rozhraní pro přístup k různým zdrojům.
Třída System patří do balíčku Java „java.lang“. Kromě poskytování standardních I / O streamů poskytuje třída System také přístup k proměnným prostředí, externím proměnným, načítání souborů a knihoven a také k metodě arrayCopy pro kopírování části pole.
Jelikož tento kurz je založen pouze na standardních I / O, přeskočíme zde zbytek zařízení poskytovaných třídou System zde.
Z hlediska Input-Output nabízí třída System následující streamy:
# 1) Standardní vstupní proud (System.in)
Vstupní proud poskytovaný třídou System System.in se používá ke čtení vstupních dat ze standardního vstupního zařízení, jako je klávesnice.
Stream zůstává otevřený a je připraven číst data dodaná uživatelem do standardního vstupního zařízení.
Níže uvedený příklad ukazuje funkci System.in.read na čtení jedné celé číslice.
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); } }Výstup:
# 2) Standardní výstupní proud (System.out)
Rozhraní System.out třídy System se používá k zápisu výstupu programu na standardní výstupní zařízení, jako je monitor. Ve většině případů rozhraní System.out zapisuje výstup příkazu na standardní výstupní zařízení.
Používá tři metody z třídy „PrintStream“, protože standardní výstup je odvozen z této třídy.
Jedná se o tyto metody:
- tisk
- tisk
- psát si
Metody „print“ a „println“ mají stejnou funkčnost až na jediný rozdíl, že metoda println připojí k výstupu znak nového řádku ( n).
Metoda zápisu se nepoužívá často, s výjimkou případů, kdy se mají zobrazit data, která nejsou ASCII.
Následující příklad ukazuje stream 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); } } Výstup:
jak otevřít soubor jar
Výše uvedený program zobrazuje funkce „tisk“ a „tisk“ používané s rozhraním System.out. Zde jsme definovali proměnné různých datových typů a zobrazujeme je každou pomocí rozhraní System.out.
# 3) Standardní proud chyb (System.err)
Standardní proud chyb System.err se používá k zobrazení případných chyb během provádění programu.
Stejně jako stream System.out, proud chyb také podporuje tři metody třídy PrintStream, tisk, tisk a zápis.
Metody čtení vstupu z konzoly
Kromě výše popsaného vstupního proudu existuje několik dalších metod, pomocí kterých můžeme číst vstupní data z konzoly v Javě.
Tyto metody jsou popsány níže.
# 1) Třída BufferedReader
Třída BufferedReader byla poprvé představena v JDK 1.0 a je klasickou metodou čtení vstupních dat z konzoly.
Vstupní proud (System.in) je zabalen uvnitř třídy InputStreamReader, která je zase zabalena do BufferedReader.
Následující program ukazuje použití třídy BufferedReader ke čtení vstupních dat od uživatele.
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); } } Výstup:
Ve výše uvedeném programu jsme deklarovali objekt třídy BufferedReader inicializovaný do proudu System.in. Pomocí tohoto objektu čteme celý řádek vstupu.
Jak vidíte, můžete si přečíst celá data ve vyrovnávací paměti, díky čemuž je tato funkce velmi efektivní. Jedinou nevýhodou je tajemný kód, který si pokaždé může být těžké zapamatovat.
# 2) Třída konzoly
Ke čtení vstupu z konzoly lze použít třídu „System.console“. Používá se zejména ke čtení vstupních znaků, jako je heslo, z příkazového řádku.
Metoda čtení vstupních dat pomocí třídy konzoly je v současné době nejúčinnější a preferovanou metodou v Javě.
Následující program ukazuje třídu 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); } } Výstup:
Pomocí třídy System.console můžete číst vstupní znaky bez opakování znaků. Proto je tato metoda užitečnější pro čtení hesel. Za druhé, můžete také použít formátovací řetězce k formátování vstupních dat, podobně jako v System.out.printf ().
I když se jedná o upřednostňovaný způsob čtení vstupních dat, nezapomeňte, že třídu System.console nelze použít s prostředím Interactive Java, jako jsou IDE.
# 3) Skener
Použití třídy skeneru ke čtení vstupních dat je pravděpodobně nejrychlejší a preferovaná metoda. Skener se většinou používá k analýze datových typů včetně primitivních typů a řetězců. Lze jej však také použít ke čtení vstupních dat a jejich analýze pomocí tokenizovaného vstupu.
Třída skeneru používá pro tento účel regulární výrazy.
Následující program načte vstupní data od uživatele pomocí třídy skeneru.
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); } } Výstup:
Ve výše uvedeném programu jsme použili třídu skenerů ke čtení řetězcových a celočíselných dat.
Formátování výstupu v Javě pomocí printf
Už jsme viděli, jak zobrazit výstup v programu Java. V této části uvidíme, jak tento výstup formátovat. Pro tento účel využíváme funkci printf třídy „PrintStream“ spolu se streamem Java „System.out“.
Funkce printf v Javě je podobná funkci printf v C / C ++. Na rozdíl od funkcí System.out.print a System.out.println, které přijímají jeden argument, System.out.printf trvá více než jeden argument.
Následují varianty funkce printf v Javě.
| Nedělej | Funkční prototyp | Popis |
|---|---|---|
| 1 | System.out.printf (řetězec); | Vytiskne řetězec poskytnutý v argumentu bez jakéhokoli formátování |
| dva | System.out.printf (formát, argumenty); | Vytiskne výstup pomocí zadaného řetězce formátu a formátu argumentů. |
| 3 | System.out.printf (národní prostředí, formát, argumenty); | Vytiskne výstup pomocí zadaného řetězce formátu použitím národního prostředí a argumentů. |
Všimněte si, že funkce System.out.format () je stejná jako System.out.printf ().
Obecná syntaxe pro určení řetězce formátu je následující:
%specifier => + for right-aligning, - for left-aligning. => to specify leading/trailing zeros and precision => suggests the data type.Například:
System.out.println(“ ‘%05.2f’%n”, 2.28);Vygeneruje následující výstup:
„02,28“
O printf v Javě budeme podrobně diskutovat v dalších tématech tohoto tutoriálu.
Často kladené otázky
Otázka č. 1) Co jsou standardní vstup a standardní výstup?
Odpovědět: Standardní vstupní a výstupní toky jsou předem propojené kanály ke komunikaci mezi počítačovým programem a vnějším prostředím, když program zahájí provádění. Tři různé standardní I / O toky jsou standardní vstup (stdin), standardní výstup (stdout), standardní chyba (stderr).
Otázka č. 2) Co je standardní vstup v programování?
Odpovědět: Standardní vstup nebo standardní vstup je proud používaný ke čtení vstupu ze standardního vstupního zařízení, jako je klávesnice.
Otázka č. 3) Co je vstupně-výstupní proud?
Odpovědět: Proud vstupu a výstupu představuje zdroj, ze kterého čtete vstup, a cíl, na který směřujete výstup.
Stream obecně představuje mnoho zařízení, která se používají jako zdroj a cíle, jmenovitě klávesnice, soubor na disku, monitory atd.
Otázka č. 4) Co je standardní vstup v Javě?
Odpovědět: Standardní vstup v Javě poskytuje třída System jako stream System.in. Třída System je součástí balíčku java.lang.
Otázka č. 5) Co je standardní výstup v Javě?
Odpovědět: Standardní výstup v Javě poskytuje třída System jako stream System.out. Třída System je součástí balíčku java.lang.
Další příklady - Vstupní / výstupní toky
Proudy představují tok dat a tato data mohou být v jakémkoli formátu (například bajt, text, primitivní datový typ atd.). K zápisu dat do cíle se používá výstupní proud a ke čtení dat se používá vstupní proud.
Různé formáty pro čtení a psaní
Vstup / výstup lze číst / zapisovat v následujících různých formátech:
# 1) Čtení souboru jako bajtového proudu
Zde budou data čtena v bajtovém formátu. ' FileInputStream “ a ' FileOutputStream „Třídy se používají ke čtení obsahu jako bajt. Tímto způsobem pro každý bajt odešle kompilátor požadavek na OS.
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) Čtení souboru jako proud znaků
Tímto způsobem bude vstupní proud čten ve formátu znaků. Takže pro každý znak kompilátor odešle požadavek do OS. ' FileReader “ a ' FileWriter ” třídy jsou užitečné pro čtení obsahu jako postavy.
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) Vyrovnávání vstupního / výstupního proudu
Když použijete třídy FileInputStream nebo FileReader, pro každou operaci čtení nebo zápisu se do OS odešle nový požadavek. To tedy může vést k problémům s výkonem. Aby se tomu zabránilo BufferedInputStream nebo BufferedReader, třídy se používají k zabalení tříd bez vyrovnávací paměti.
Toto čte vstupní proud, když je vyrovnávací paměť prázdná.
Podobně FileOutputStream nebo FileWriter jsou třídy zabaleny pomocí BufferedOutputStream nebo BufferedWriter pro zápis výstupu, jakmile je vyrovnávací paměť plná.
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) Čtení jako datový proud
V této metodě se třídy DataInputStream nebo DataOutputStream používají ke čtení a zápisu obsahu jako primitivní datové typy, jako jsou boolean, char, byte, short, int, long, float, double a String. Většinou se DataInputStream a DataOutputStream použijí společně.
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) Čtení jako objektový proud
ObjectInputStream / ObjectOutputStream, třídy jsou užitečné pro zápis objektů do souboru a čtení objektů ze souboru. Pro uložení objektu do souboru by třída měla implementovat Serializovatelné rozhraní.
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; } } 
Chystáme se vytvořit objekt pro tuto třídu „ObjectStreamDemo“ a tento objekt zapíšeme do souboru a přečteme stejný objekt z tohoto souboru.
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(); } } } 
Soubor I / O operace
Třída souboru je užitečná pro provádění operací se soubory.
Některé operace se soubory prováděné pomocí třídy File zahrnují:
- Vytvořte soubor
- Zkontrolujte, zda soubor existuje
- Získejte cestu k souboru
- Napište soubor
- Přečtěte si soubor
- Odstraňte soubor a přejmenujte jej
- Zkontrolujte oprávnění souboru a změňte oprávnění souboru
- Přesuňte soubor z jednoho adresáře do jiného umístění
Ukázkový program pro vytvoření, čtení a zápis souboru:
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(); } } } 
Klíčové body, které je třeba poznamenat:
- Proud je logická reprezentace toku dat.
- Data můžete číst / zapisovat v jiném formátu, jako je bajt, znak, objekt, primitivní datový typ.
- Třída souboru se používá k vytvoření souboru, odstranění souboru a přesunutí nebo zkopírování nebo přejmenování souboru.
- BufferedInputStream nebo BufferedOutputStream se používá ke zlepšení výkonu pomocí vyrovnávací paměti dat.
Závěr
Java má balíček java.lang, který poskytuje standardní vstupní a výstupní zařízení využívající třídu System.
Kromě streamů System.in a System.out, které se používají pro standardní vstup a výstup, existují také další metody, jako je BufferedReader, třída konzoly a třída skeneru, která se používá ke čtení vstupu od uživatele.
Stream System.out používá k zobrazení výstupu funkci třídy „PrintStream“, print a println. Jedná se o funkce, které se používají k zobrazení výstupu bez formátování. Další funkce „printf“, která je podobná funkci printf v C / C ++, se také používá v Javě pro formátovaný výstup.
Prozkoumáme více o třídě skeneru a funkci printf v Javě v našich připravovaných tutoriálech.
=> Navštivte zde exkluzivní sérii výukových programů Java.
Výukový program PREV | DALŠÍ výuka
Doporučené čtení
- Základní operace vstupu / výstupu v C ++
- Vstupní operace se soubory v C ++
- Výukový program Java Collections Framework (JCF)
- Implementace Java: Vytvoření a spuštění souboru Java JAR
- Virtuální stroj Java: Jak JVM pomáhá při spouštění aplikace Java
- Vstup-výstup a soubory v Pythonu (Python Open, Read and Write to File)
- Modifikátory přístupu v Javě - výuka s příklady
- Výukový program Java Reflection s příklady