Menu

Operazioni di I / O di base in Java (flussi di input / output)

  • Principale
  • Altro
  • Operazioni di I / O di base in Java (flussi di input / output)

basic i o operations java

Prova Il Nostro Strumento Per Eliminare I Problemi

In questo tutorial video, discuteremo il meccanismo di input-output di Java come input utente Java, InputStream, Java Printf, Println, ecc. Con dispositivi I / O standard:

In ogni linguaggio di programmazione, è necessario disporre di un meccanismo per leggere i dati di input e inviare anche i dati elaborati, noti anche come Output, all'utente finale.

Come sapete, ci sono molti dispositivi di input e output nel mondo del software che i programmatori possono utilizzare per leggere e scrivere o inviare dati.

Leggi il nostro Serie completa di formazione Java per ottenere maggiori informazioni sui concetti Java.

Operazioni di input output

Cosa imparerai:

Esercitazione video sulle operazioni di I / O di base in Java

Utilizzando un programma Java, è possibile leggere e scrivere dati da diverse origini e destinazioni. La lettura e la scrittura di origini dati e destinazioni includono:

  • File
  • Tubi
  • Le connessioni di rete
  • Buffer in memoria ( Per esempio: array)
  • System.in, System.out, System.error

In questo video tutorial, avremo l'input come file ed esploreremo varie classi, interfacce e metodi disponibili per leggere i dati dal file.

Operazioni di I / O di base in Java:

flvto non mi permetterà di convertirmi

Operazioni sui file Java:

Java I / O (Input-Output) è un meccanismo standard che elabora l'input e genera l'output. Il pacchetto “java.io” contiene i metodi per eseguire tutte le operazioni di input e output.

Per eseguire le operazioni di I / O più velocemente, Java utilizza il concetto di flussi. Un flusso può essere definito come una sequenza di dati composta da byte.

Impariamo di più sui flussi I / O Java !!

Flussi I / O standard in Java

Il linguaggio Java offre l'accesso alle risorse di sistema, ai dispositivi di input-output standard, ecc. Utilizzando una classe 'System'. Questa classe implementa un'interfaccia di programmazione dipendente dal sistema per accedere a varie risorse.

La classe System appartiene al pacchetto 'java.lang' di Java. Oltre a fornire flussi di I / O standard, la classe System fornisce anche l'accesso a variabili di ambiente, variabili esterne, caricamento di file e librerie e anche un metodo di utilità arrayCopy per copiare parte di un array.

Poiché questo tutorial si basa solo sull'I / O standard, tralasciamo il resto delle funzionalità fornite dalla classe System qui.

Dal punto di vista di Input-Output, la classe System offre i seguenti flussi:

# 1) Flusso di input standard (System.in)

Il flusso di input fornito dalla classe System, System.in, viene utilizzato per leggere i dati di input da un dispositivo di input standard come una tastiera.

Il flusso rimane aperto ed è pronto per leggere i dati forniti dall'utente al dispositivo di input standard.

L'esempio seguente mostra la funzione System.in.read per leggere una singola cifra intera.

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); } }

Produzione:

output del flusso di input standard

# 2) Stream di output standard (System.out)

L'interfaccia System.out della classe System viene utilizzata per scrivere l'output del programma sul dispositivo di output standard come il monitor. Nella maggior parte dei casi, l'interfaccia System.out scrive l'output del comando sul dispositivo di output standard.

Utilizza tre metodi della classe 'PrintStream' poiché l'output standard deriva da questa classe.

Questi metodi sono:

  1. Stampa
  2. println
  3. Scrivi

I metodi 'print' e 'println' hanno la stessa funzionalità tranne per una singola differenza che il metodo println aggiunge un carattere di nuova riga ( n) all'output.

Il metodo di scrittura non viene utilizzato frequentemente tranne nei casi in cui devono essere visualizzati dati non ASCII.

L'esempio seguente mostra il flusso 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); } }

Produzione:

flusso di output standard

Il programma sopra mostra le funzioni “print” e “println” usate con l'interfaccia System.out. Qui abbiamo definito variabili di diversi tipi di dati e visualizziamo ciascuna di esse utilizzando l'interfaccia System.out.

# 3) Flusso di errore standard (System.err)

Il flusso di errore standard, System.err, viene utilizzato per visualizzare eventuali errori durante l'esecuzione del programma.

Come il flusso System.out, il flusso di errore supporta anche i tre metodi della classe PrintStream, print, println e scrive.

Metodi per leggere l'input dalla console

Oltre al flusso di input descritto sopra, ci sono pochi altri metodi che consentono di leggere i dati di input dalla console in Java.

Questi metodi sono discussi di seguito.

# 1) Classe BufferedReader

La classe BufferedReader è stata introdotta per la prima volta in JDK 1.0 ed è il metodo classico per leggere i dati di input dalla console.

Il flusso di input (System.in) è racchiuso all'interno della classe InputStreamReader che a sua volta è avvolto in BufferedReader.

Il seguente programma mostra l'utilizzo della classe BufferedReader per leggere i dati di input dall'utente.

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); } }

Produzione:

Uscita BufferReader

come dividere una stringa per carattere in python

Nel programma sopra, abbiamo dichiarato un oggetto della classe BufferedReader inizializzata nel flusso System.in. Usando questo oggetto, leggiamo un'intera riga di input.

Come puoi vedere, puoi leggere tutti i dati memorizzati nel buffer rendendo questa funzionalità molto efficiente. L'unico inconveniente è il codice criptico che potrebbe essere difficile da ricordare ogni volta.

# 2) Classe console

La classe 'System.console' può essere utilizzata per leggere l'input dalla console. Viene utilizzato per leggere in particolare i caratteri di input come una password dalla riga di comando.

Il metodo di lettura dei dati di input utilizzando la classe console è attualmente il metodo più efficiente e preferito in Java.

Il seguente programma 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); } }

Produzione:

Output della classe della console

Usando la classe System.console, puoi leggere i caratteri di input senza fare eco ai caratteri. Quindi questo metodo è più utile per leggere le password. In secondo luogo, puoi anche utilizzare stringhe di formato per formattare i dati di input, simili a quelli usati in System.out.printf ().

Sebbene questo sia il modo preferito di leggere i dati di input, si noti che la classe System.console non può essere utilizzata con un ambiente Java interattivo come gli IDE.

# 3) Scanner

L'uso di una classe scanner per leggere i dati di input è probabilmente il metodo più veloce e preferito. Lo scanner viene utilizzato principalmente per analizzare i tipi di dati, inclusi i tipi primitivi e le stringhe. Ma può anche essere utilizzato per leggere i dati di input e analizzarli utilizzando l'input tokenizzato.

La classe scanner utilizza espressioni regolari per questo scopo.

Il seguente programma legge i dati di input dall'utente utilizzando 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); } }

Produzione:

Uscita scanner

Nel programma precedente, abbiamo utilizzato la classe scanner per leggere la stringa e i dati interi.

Formattazione dell'output in Java utilizzando printf

Abbiamo già visto come visualizzare l'output in un programma Java. In questa sezione vedremo come formattare questo output. A tale scopo utilizziamo la funzione printf della classe 'PrintStream' insieme al flusso 'System.out' di Java.

La funzione printf in Java è simile alla funzione printf in C / C ++. A differenza delle funzioni System.out.print e System.out.println che accettano un singolo argomento, System.out.printf accetta più di un argomento.

Di seguito sono riportate le variazioni della funzione printf in Java.

NoPrototipo di funzioneDescrizione
unoSystem.out.printf (stringa);Stampa una stringa fornita nell'argomento senza alcuna formattazione
DueSystem.out.printf (formato, argomenti);Stampa l'output utilizzando la stringa di formato 'format' e gli argomenti specificati.
3System.out.printf (locale, formato, argomenti);Stampa l'output utilizzando la stringa di formato specificata applicando le impostazioni locali e gli argomenti.

Notare che la funzione System.out.format () è la stessa di System.out.printf ().

La sintassi generale per specificare la stringa di formato è la seguente:

%specifier => + for right-aligning, - for left-aligning. => to specify leading/trailing zeros and precision => suggests the data type.

Per esempio:

System.out.println(“ ‘%05.2f’%n”, 2.28);

Genererà il seguente output:

’02 .28 ’

Discuteremo in dettaglio printf in Java negli argomenti successivi di questo tutorial.

Domande frequenti

D # 1) Cosa sono lo standard input e lo standard output?

Risposta: I flussi di input e output standard sono canali precollegati per comunicare tra il programma del computer e l'ambiente esterno quando il programma inizia la sua esecuzione. I tre diversi flussi di I / O standard sono input standard (stdin), output standard (stdout), errore standard (stderr).

Q # 2) Cos'è lo standard input nella programmazione?

Risposta: L'input standard o stdin è il flusso utilizzato per leggere l'input da un dispositivo di input standard come una tastiera.

Q # 3) Cos'è il flusso di input-output?

Risposta: Un flusso di input-output rappresenta un'origine da cui leggere l'input e la destinazione a cui indirizzare l'output.

Un flusso, in generale, rappresenta molti dispositivi che vengono utilizzati come origine e destinazioni, ovvero tastiera, file su disco, monitor, ecc.

Q # 4) Cos'è l'input standard in Java?

Risposta: L'input standard in Java è fornito dalla classe System come flusso System.in. La classe System fa parte del pacchetto java.lang.

Q # 5) Qual è l'output standard in Java?

Risposta: L'output standard in Java è fornito dalla classe System come flusso System.out. La classe System fa parte del pacchetto java.lang.

come creare un nuovo progetto in eclipse

Esempi aggiuntivi - Flussi di input / output

I flussi rappresentano il flusso di dati e tali dati possono essere in qualsiasi formato (come byte, testo, tipo di dati primitivo, ecc.). Per scrivere dati in una destinazione, viene utilizzato il flusso di output e per leggere i dati, viene utilizzato il flusso di input.

Diversi formati per la lettura e la scrittura

Input / output possono essere letti / scritti nei seguenti diversi formati:

# 1) Lettura del file come flusso di byte

Qui i dati verranno letti in formato byte. ' FileInputStream ' e ' FileOutputStream “Le classi vengono utilizzate per leggere il contenuto come byte. In questo modo, per ogni byte, il compilatore invierà una richiesta 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(); } } } }

Lettura del file come Byte Streams 1 Lettura del file come Byte Streams2

# 2) Lettura del file come flusso di caratteri

In questo modo, il flusso di input verrà letto in formato carattere. Quindi, per ogni carattere, il compilatore invierà una richiesta al sistema operativo. ' FileReader ' e ' FileWriter ' le classi sono utili per leggere il contenuto come il personaggio.

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(); } } } }

Lettura del file come flusso di caratteri

# 3) Buffering del flusso di input / output

Quando si utilizzano le classi FileInputStream o FileReader, per ogni operazione di lettura o scrittura, verrà inviata una nuova richiesta al sistema operativo. Quindi, questo potrebbe portare a problemi di prestazioni. Per evitare questo BufferedInputStream o BufferedReader, le classi vengono utilizzate per eseguire il wrapping delle classi senza buffer.

Questo legge il flusso di input quando il buffer è vuoto.

Allo stesso modo, FileOutputStream o FileWriter, le classi vengono racchiuse in BufferedOutputStream o BufferedWriter per scrivere l'output una volta che il buffer è pieno.

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(); } } } }

Buffering del flusso input-output

# 4) Lettura come flusso di dati

In questo metodo, DataInputStream o DataOutputStream, le classi vengono utilizzate per leggere e scrivere il contenuto come tipi di dati primitivi come boolean, char, byte, short, int, long, float, double e String. Per lo più DataInputStream e DataOutputStream verranno usati insieme.

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(); } } } }

Lettura come flussi di dati 1 Lettura come flussi di dati 2

# 5) Lettura come flusso di oggetti

ObjectInputStream / ObjectOutputStream, le classi sono utili per scrivere oggetti in un file e leggere gli oggetti dal file. Per memorizzare l'oggetto in un file, la classe dovrebbe implementare l'interfaccia 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; } }

Creeremo un oggetto per questa classe 'ObjectStreamDemo' e lo scriveremo in un file e leggeremo lo stesso oggetto da quel file.

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(); } } }

ObjectStreamDemo1 ObjectStreamDemo2

Operazioni di I / O su file

La classe di file è utile per eseguire operazioni sui file.

Alcune delle operazioni sui file eseguite utilizzando la classe File includono:

  1. Crea un file
  2. Controlla se il file esiste
  3. Ottieni il percorso del file
  4. Scrivi il file
  5. Leggi il file
  6. Elimina un file e rinomina il file
  7. Controlla i permessi del file e modifica i permessi del file
  8. Spostare il file da una directory a un'altra posizione

Programma demo per creare, leggere e scrivere il file:

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(); } } }

Programma demo per creare, leggere e scrivere il file

Punti chiave da notare:

  • Un flusso è una rappresentazione logica del flusso di dati.
  • Puoi leggere / scrivere dati in un formato diverso come byte, carattere, oggetto, tipo di dati primitivo.
  • La classe di file viene utilizzata per creare un file, eliminare il file e spostare, copiare o rinominare il file.
  • BufferedInputStream o BufferedOutputStream viene utilizzato per migliorare le prestazioni eseguendo il buffering dei dati.

Conclusione

Java ha un pacchetto java.lang che fornisce le funzionalità di input e output standard utilizzando la classe System.

Oltre ai flussi, System.in e System.out utilizzati rispettivamente per l'input e l'output standard, ci sono anche altri metodi come BufferedReader, classe console e classe scanner che vengono utilizzati per leggere l'input dell'utente.

Il flusso System.out utilizza la funzione di classe 'PrintStream', print e println per visualizzare l'output. Queste sono le funzioni che vengono utilizzate per visualizzare l'output senza formattazione. Un'altra funzione 'printf' che è simile alla funzione printf in C / C ++ viene utilizzata anche in Java per l'output formattato.

Esploreremo di più sulla classe scanner e sulla funzione printf in Java nei nostri prossimi tutorial.

=> Visita qui per l'esclusiva serie di tutorial di formazione Java.

Tutorial PREV | PROSSIMO Tutorial

Lettura consigliata

^