basic i o operations java
En aquest tutorial de vídeo, parlarem del mecanisme d'entrada-sortida de Java, com ara l'entrada d'usuari de Java, InputStream, Java Printf, Println, etc. amb dispositius d'E / S estàndard:
En tots els llenguatges de programació, hem de tenir un mecanisme per llegir les dades d’entrada i també enviar les dades processades que també es coneix com a Sortida a l’usuari final.
Com és conscient, hi ha molts dispositius d’entrada i sortida al món del programari que els programadors poden utilitzar per llegir dades i escriure-les o sortir-ne.
Llegiu el nostre document Sèrie d'entrenament completa sobre Java per obtenir més informació sobre els conceptes de Java.
Què aprendreu:
- Vídeo tutorial sobre operacions bàsiques d'E / S a Java
- Exemples addicionals: corrents d'entrada / sortida
- Conclusió
Vídeo tutorial sobre operacions bàsiques d'E / S a Java
Mitjançant un programa Java, podeu llegir i escriure dades de diferents fonts i destinacions. La lectura i escriptura de fonts i destinacions de dades inclouen:
- Fitxers
- Tubs
- Connexions de xarxa
- Memòries intermèdies ( Per exemple: matrius)
- System.in, System.out, System.error
En aquest vídeo tutorial, tindrem l'entrada com a fitxer i explorarem diverses classes, interfícies i mètodes disponibles per llegir les dades del fitxer.
Operacions bàsiques d'E / S a Java:
Operacions de fitxers Java:
Java E / S (entrada-sortida) és un mecanisme estàndard que processa l'entrada i genera la sortida. El paquet 'java.io' conté els mètodes per realitzar totes les operacions d'entrada i sortida.
Per realitzar operacions d'E / S més ràpidament, Java utilitza el concepte de fluxos. Un flux es pot definir com una seqüència de dades que consisteix en bytes.
Aprenem més sobre els fluxos d'E / S de Java.
Corrents d'E / S estàndard a Java
El llenguatge Java ofereix accés a recursos del sistema, dispositius estàndard d’entrada-sortida, etc. mitjançant una classe “Sistema”. Aquesta classe implementa una interfície de programació dependent del sistema per accedir a diversos recursos.
La classe System pertany al paquet 'java.lang' de Java. A part de proporcionar fluxos d'E / S estàndard, la classe System també proporciona accés a variables d'entorn, variables externes, càrrega de fitxers i biblioteques, i també un mètode d'utilitat arrayCopy per copiar part d'una matriu.
Com que aquest tutorial es basa només en E / S estàndard, ometrem la resta de facilitats que proporciona la classe System aquí.
Des del punt de vista Entrada-Sortida, la classe System ofereix els fluxos següents:
# 1) Flux d'entrada estàndard (System.in)
El flux d'entrada proporcionat per la classe System, System.in, s'utilitza per llegir les dades d'entrada d'un dispositiu d'entrada estàndard com un teclat.
El flux continua obert i està a punt per llegir les dades subministrades per l'usuari al dispositiu d'entrada estàndard.
L'exemple següent mostra la funció System.in.read per llegir un sol dígit enter.
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); } }
Sortida:
# 2) Flux de sortida estàndard (System.out)
La interfície System.out de la classe System s’utilitza per escriure la sortida del programa al dispositiu de sortida estàndard com el monitor. En la majoria dels casos, la interfície System.out escriu la sortida de l'ordre al dispositiu de sortida estàndard.
Utilitza tres mètodes de la classe 'PrintStream' ja que la sortida estàndard deriva d'aquesta classe.
Aquests mètodes són:
- imprimir
- println
- escriure
Els mètodes 'print' i 'println' tenen la mateixa funcionalitat, tret d'una única diferència que el mètode println afegeix un caràcter de línia nova ( n) a la sortida.
El mètode d'escriptura no s'utilitza amb freqüència excepte en els casos en què es mostrin dades que no són ASCII.
L'exemple següent mostra el 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); } }
Sortida:
El programa anterior mostra les funcions 'print' i 'println' utilitzades amb la interfície System.out. Aquí hem definit variables de diferents tipus de dades i les mostrem cadascuna mitjançant la interfície System.out.
# 3) Corrent d'error estàndard (System.err)
El flux d'errors estàndard, System.err, s'utilitza per mostrar errors, si n'hi ha, durant l'execució del programa.
Igual que el flux System.out, el flux d'errors també admet els tres mètodes de la classe PrintStream, print, println i write.
Mètodes per llegir l'entrada des de la consola
A part del flux d’entrada descrit anteriorment, hi ha pocs mètodes més que permetin llegir les dades d’entrada des de la consola a Java.
A continuació, es descriuen aquests mètodes.
# 1) Class BufferedReader
La classe BufferedReader es va introduir per primera vegada a JDK 1.0 i és el mètode clàssic de lectura de dades d’entrada des de la consola.
El flux d’entrada (System.in) s’embolica dins de la classe InputStreamReader que al seu torn s’embolica a BufferedReader.
El programa següent mostra l'ús de la classe BufferedReader per llegir les dades d'entrada de l'usuari.
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); } }
Sortida:
Al programa anterior, hem declarat un objecte de la classe BufferedReader inicialitzat al flux System.in. Mitjançant aquest objecte, llegim tota una línia d’entrada.
Com podeu veure, podeu llegir totes les dades de memòria intermèdia, cosa que fa que aquesta funcionalitat sigui molt eficient. L’únic inconvenient és el codi críptic que pot ser difícil de recordar cada vegada.
exemples de casos de prova per a la sol·licitud d’assegurança
# 2) Classe de consola
La classe 'System.console' es pot utilitzar per llegir l'entrada de la consola. S'utilitza per llegir especialment els caràcters d'entrada com una contrasenya de la línia d'ordres.
Actualment, el mètode de lectura de dades d’entrada mitjançant la classe de consola és el mètode més eficient i preferit de Java.
El programa següent mostra 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); } }
Sortida:
Amb la classe System.console, podeu llegir els caràcters d’entrada sense fer-ne ressò. Per tant, aquest mètode és més útil per llegir contrasenyes. En segon lloc, també podeu utilitzar cadenes de format per formatar les dades d’entrada, de manera similar a les que s’utilitzen a System.out.printf ().
Tot i que aquesta és la forma preferida de llegir les dades d’entrada, tingueu en compte que la classe System.console no es pot utilitzar amb un entorn Java interactiu com els IDE.
# 3) Escàner
L’ús d’una classe d’escàner per llegir les dades d’entrada és probablement el mètode més ràpid i preferit. L’escàner s’utilitza principalment per analitzar els tipus de dades, inclosos els tipus primitius i les cadenes. Però també es pot utilitzar per llegir les dades d'entrada i analitzar-les mitjançant l'entrada tokenitzada.
La classe d'escàner utilitza expressions regulars amb aquest propòsit.
El programa següent llegeix les dades d’entrada de l’usuari mitjançant la classe d’escàner.
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); } }
Sortida:
Al programa anterior, hem utilitzat la classe d’escàner per llegir les dades de cadenes i enters.
Format de sortida a Java mitjançant printf
Ja hem vist com mostrar la sortida en un programa Java. En aquesta secció, veurem com formatar aquesta sortida. Utilitzem la funció printf de la classe 'PrintStream' juntament amb el flux 'System.out' de Java per a aquest propòsit.
La funció printf a Java és similar a la funció printf a C / C ++. A diferència de les funcions System.out.print i System.out.println que adopten un únic argument, System.out.printf accepta més d’un argument.
A continuació es detallen les variacions de la funció printf a Java.
no | Prototip de funció | Descripció |
---|---|---|
1 | System.out.printf (cadena); | Imprimeix una cadena proporcionada a l'argument sense cap format |
2 | System.out.printf (format, arguments); | Imprimeix la sortida mitjançant la cadena de format especificat 'format' i arguments. |
3 | System.out.printf (configuració regional, format, arguments); | Imprimeix la sortida mitjançant la cadena de format especificada aplicant la configuració regional i els arguments. |
Tingueu en compte que la funció System.out.format () és la mateixa que System.out.printf ().
La sintaxi general per especificar la cadena de format és la següent:
%specifier => + for right-aligning, - for left-aligning. => to specify leading/trailing zeros and precision => suggests the data type.
Per exemple:
System.out.println(“ ‘%05.2f’%n”, 2.28);
Generarà la següent sortida:
'02 .28 '
Discutirem printf a Java amb detall en els temes posteriors d’aquest tutorial.
Preguntes freqüents
P # 1) Què són l'entrada estàndard i la sortida estàndard?
Resposta: Els fluxos d’entrada i sortida estàndard són canals preconnectats per comunicar-se entre el programa d’ordinador i l’entorn extern quan el programa comença la seva execució. Els tres fluxos d'E / S estàndard diferents són l'entrada estàndard (stdin), sortida estàndard (stdout), error estàndard (stderr).
quin és el millor programari de gestió de tasques
Q # 2) Què és l'entrada estàndard a la programació?
Resposta: L'entrada estàndard o stdin és el flux que s'utilitza per llegir l'entrada d'un dispositiu d'entrada estàndard com un teclat.
Q # 3) Què és el flux d'entrada-sortida?
Resposta: Un flux d'entrada-sortida representa una font des de la qual llegiu l'entrada i la destinació a la qual dirigiu la sortida.
Un flux, en general, representa molts dispositius que s’utilitzen com a origen i destinacions, és a dir, teclat, fitxer de disc, monitors, etc.
Q # 4) Què és l'entrada estàndard a Java?
Resposta: L'entrada estàndard a Java la proporciona la classe System com a flux System.in. La classe System forma part del paquet java.lang.
Q # 5) Què és la sortida estàndard a Java?
Resposta: La sortida estàndard a Java la proporciona la classe System com a flux System.out. La classe System forma part del paquet java.lang.
Exemples addicionals: corrents d'entrada / sortida
Els fluxos representen el flux de dades i aquestes dades poden estar en qualsevol format (com ara bytes, text, tipus de dades primitives, etc.). Per escriure dades a una destinació, s’utilitza el flux de sortida i, per llegir-les, s’utilitza el flux d’entrada.
Diferents formats de lectura i escriptura
L’entrada / sortida es pot llegir / escriure en els formats següents:
# 1) Lectura de fitxers com a flux de bytes
Aquí les dades es llegiran en format de bytes. ' FileInputStream ” i “ FileOutputStream “Les classes s’utilitzen per llegir el contingut com un byte. D’aquesta manera, per a cada byte, el compilador enviarà una sol·licitud al SO.
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) Lectura de fitxers com a flux de caràcters
D'aquesta manera, el flux d'entrada es llegirà en format de caràcters. Per tant, per a cada caràcter, el compilador enviarà una sol·licitud al SO. ' FileReader ” i “ FileWriter ” les classes són útils per llegir el contingut com a personatge.
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) Memòria intermèdia del flux d'entrada / sortida
Quan utilitzeu les classes FileInputStream o FileReader, per a cada operació de lectura o escriptura, s’enviarà una nova sol·licitud al SO. Per tant, això pot comportar problemes de rendiment. Per evitar aquest BufferedInputStream o BufferedReader, s’utilitzen classes per embolicar classes sense tampó.
Això llegeix el flux d'entrada quan el buffer està buit.
De la mateixa manera, FileOutputStream o FileWriter, les classes s’ajusten amb BufferedOutputStream o BufferedWriter per escriure la sortida un cop el buffer està ple.
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) Lectura com a flux de dades
En aquest mètode, les classes DataInputStream o DataOutputStream, s’utilitzen per llegir i escriure el contingut com a tipus de dades primitives com ara booleà, char, byte, short, int, long, float, double i String. Majoritàriament, DataInputStream i DataOutputStream s’utilitzaran junts.
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) Lectura com a flux d’objectes
ObjectInputStream / ObjectOutputStream, les classes són útils per escriure objectes en un fitxer i llegir-ne els objectes. Per emmagatzemar l'objecte en un fitxer, la classe hauria d'implementar la interfície serialitzable.
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; } }
Crearem un objecte per a aquesta classe 'ObjectStreamDemo' i escriurem aquest objecte en un fitxer i llegirem el mateix objecte d'aquest fitxer.
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(); } } }
Operacions d'E / S de fitxers
La classe de fitxers és útil per fer operacions de fitxers.
Algunes de les operacions de fitxers realitzades amb la classe File inclouen:
- Creeu un fitxer
- Comproveu si el fitxer existeix
- Obteniu la ruta del fitxer
- Escriviu el fitxer
- Llegiu el fitxer
- Suprimiu un fitxer i canvieu el nom del fitxer
- Comproveu els permisos del fitxer i canvieu-los
- Mou el fitxer d’un directori a una altra ubicació
Programa de demostració per crear, llegir i escriure el fitxer:
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(); } } }
Punts clau que cal tenir en compte:
- Un flux és una representació lògica del flux de dades.
- Podeu llegir / escriure dades en un format diferent, com ara bytes, caràcters, objectes, tipus de dades primitives.
- La classe de fitxers s’utilitza per crear un fitxer, eliminar-lo i moure o copiar o canviar el nom del fitxer.
- BufferedInputStream o BufferedOutputStream s’utilitzen per millorar el rendiment mitjançant la memòria intermèdia de les dades.
Conclusió
Java té un paquet java.lang que proporciona les instal·lacions d’entrada i sortida estàndard mitjançant la classe System.
A part dels fluxos, System.in i System.out que s'utilitzen respectivament per a l'entrada i sortida estàndard, també hi ha altres mètodes com BufferedReader, classe de consola i classe d'escàner que s'utilitza per llegir l'entrada de l'usuari.
El flux System.out utilitza la funció de classe 'PrintStream', print i println per mostrar la sortida. Aquestes són les funcions que s’utilitzen per mostrar la sortida sense formatar. Una altra funció 'printf' que és similar a la funció printf en C / C ++ també s'utilitza a Java per a la sortida formatada.
Explorarem més informació sobre la classe d’escàner i la funció printf a Java als nostres propers tutorials.
=> Visiteu aquí la sèrie exclusiva de cursos de formació de Java.
Lectura recomanada
- Operacions bàsiques d'entrada / sortida en C ++
- Operacions de sortida d'entrada de fitxers en C ++
- Tutorial sobre Java Collections Framework (JCF)
- Desplegament de Java: creació i execució del fitxer JAR de Java
- Màquina virtual Java: com ajuda JVM a executar aplicacions Java
- Entrada-sortida i fitxers a Python (Python Obrir, llegir i escriure al fitxer)
- Modificadors d'accés a Java: tutorial amb exemples
- Tutorial de reflexió de Java amb exemples