flusso di Java (Stream), di file (File) e IO

package della classe Java.io comprende quasi tutte le operazioni di esigenze di input e output. Tutte queste classi stream rappresentano la sorgente di ingresso e destinazione di uscita.

Java.io Streaming pacchetto di supportare una varietà di formati, come ad esempio: tipi di base, oggetti, set di caratteri localizzati e così via.

Può essere inteso come una sequenza di un flusso di dati. Rappresenta il flusso di ingresso per leggere i dati da una fonte a un flusso di output target rappresenta scrivere i dati.

Java fornisce un supporto potente e flessibile per l'I / O, il che rende più ampiamente usato nel trasferimento di file e la programmazione di rete.

Tuttavia, questa sezione descrive la più fondamentale e flusso di I / O funzioni correlate. Impareremo un esempio di queste funzioni.

Leggi console di input

Ingresso console Java completato entro la System.in.

Per ottenere un flusso carattere vincolante alla console, è possibile System.in avvolto in un oggetto BufferedReader per creare un flusso di caratteri.

Ecco la sintassi di base per creare un BufferedReader:

BufferedReader br = new BufferedReader(new 
                      InputStreamReader(System.in));

Dopo la creazione oggetto BufferedReader, possiamo utilizzare il metodo read () per leggere un personaggio dalla console, o leggere un metodo stringa readLine ().

Leggi tutto immissione dei caratteri dalla console

Leggi da oggetto BufferedReader è un personaggio che si desidera utilizzare il metodo lettura (), che ha la seguente sintassi:

int read( ) throws IOException

Ogni chiamata a leggere il metodo (), che legge un carattere dal flusso di input e restituisce il carattere come un valore intero. Quando la fine del flusso restituisce -1. Il metodo genera IOException.

Il seguente programma illustra il metodo uso read () legge i caratteri dalla console continua fino a quando l'utente entra "q".

// 使用 BufferedReader 在控制台读取字符

import java.io.*;

public class BRRead {
   public static void main(String args[]) throws IOException
   {
      char c;
      // 使用 System.in 创建 BufferedReader 
      BufferedReader br = new BufferedReader(new 
                         InputStreamReader(System.in));
      System.out.println("Enter characters, 'q' to quit.");
      // 读取字符
      do {
         c = (char) br.read();
         System.out.println(c);
      } while(c != 'q');
   }
}

Gli esempi sopra risultati elaborati sono i seguenti:

Enter characters, 'q' to quit.
123abcq
1
2
3
a
b
c
q

Legge una stringa dal console

Leggere dallo standard input una stringa ha bisogno di usare un metodo BufferedReader readLine ().

Il formato generale è:

String readLine( ) throws IOException

Il seguente programma legge e le righe display caratteri fino a quando si immette la parola "fine".

// 使用 BufferedReader 在控制台读取字符
import java.io.*;
public class BRReadLines {
   public static void main(String args[]) throws IOException
   {
      // 使用 System.in 创建 BufferedReader 
      BufferedReader br = new BufferedReader(new
                              InputStreamReader(System.in));
      String str;
      System.out.println("Enter lines of text.");
      System.out.println("Enter 'end' to quit.");
      do {
         str = br.readLine();
         System.out.println(str);
      } while(!str.equals("end"));
   }
}

Gli esempi sopra risultati elaborati sono i seguenti:

Enter lines of text.
Enter 'end' to quit.
This is line one
This is line one
This is line two
This is line two
end
end

JDK versione 5 dopo possiamo anche usare Java Scanner classe per ottenere console di ingresso.

output della console

E 'stato introdotto nella precedente uscita della console è fatto da print () e println (). Questi metodi definiti dalla classe PrintStream, System.out è un riferimento all'oggetto classe.

PrintStream ereditato classe OutputStream, e implementa il metodo write (). Così, write () può essere utilizzato anche da e per la console scrive.

La definizione più semplice di formato PrintStream write () sono i seguenti:

void write(int byteval)

Questo metodo abbasserà ottetto byteval scritto al flusso.

Esempi

L'esempio seguente utilizza write () il carattere "A" e seguita da un'uscita carattere di nuova riga sullo schermo:

import java.io.*;

// 演示 System.out.write().
public class WriteDemo {
   public static void main(String args[]) {
      int b; 
      b = 'A';
      System.out.write(b);
      System.out.write('\n');
   }
}

Eseguire l'esempio precedente uscita carattere "A" nella finestra di output

A

Nota: il metodo write () non viene usato spesso perché il metodo print () e println () è più comodo da usare.

Leggere e scrivere file

Come descritto in precedenza, un flusso è definito come una sequenza di dati. flusso di input per la lettura dei dati dalla sorgente nel flusso di output di destinazione per la scrittura dei dati.

Quanto segue è una descrizione dei flussi di gerarchia delle classi di input e output di schema.

Di seguito sarà discusso due flussi importanti sono FileInputStream e FileOutputStream:

FileInputStream

Il flusso per la lettura di dati da un file, il suo oggetto può essere utilizzato per creare una nuova parola chiave.

Esistono diversi metodi di costruzione possono essere utilizzati per creare oggetti.

È possibile utilizzare il nome del file di tipo stringa per creare un oggetto stream di input per leggere il file:

InputStream f = new FileInputStream("C:/java/hello");

È inoltre possibile utilizzare un oggetto file per creare un oggetto flusso per leggere i file di input. Per prima cosa dobbiamo utilizzare il metodo di file () per creare un oggetto file:

File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);

Viene creato oggetto InputStream, è possibile utilizzare il seguente metodo per leggere il flusso di corrente o eseguire altre operazioni.

Oltre a InputStream, ci sono alcuni altri flusso di input, per maggiori dettagli consultare i seguenti link:

• ByteArrayInputStream
• DataInputStream

FileOutputStream

Questa classe viene utilizzata per creare un file e scrivere i dati del file.

* Se il flusso aprire un file per l'output, il file di destinazione non esiste, allora il flusso creerà il file.

Ci sono due modi per creare un oggetto costruttore FileOutputStream.

Usa stringa di digitare un nome di file per creare un oggetto flusso di uscita:

OutputStream f = new FileOutputStream("C:/java/hello") 

È inoltre possibile utilizzare un oggetto file per creare un flusso di output per scrivere i file. Per prima cosa dobbiamo utilizzare il metodo di file () per creare un oggetto file:

File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);

Creare oggetto OutputStream è completa, è possibile utilizzare il seguente metodo per scrivere il flusso di corrente o eseguire altre operazioni.

OutputStream Inoltre, ci sono alcuni altri stream di output, per maggiori dettagli consultare i seguenti link:

• ByteArrayOutputStream
• DataOutputStream

Esempi

Ecco una dimostrazione di InputStream e OutputStream esempi di utilizzo:

import java.io.*;

public class fileStreamTest{

   public static void main(String args[]){
   
   try{
      byte bWrite [] = {11,21,3,40,5};
      OutputStream os = new FileOutputStream("test.txt");
      for(int x=0; x < bWrite.length ; x++){
         os.write( bWrite[x] ); // writes the bytes
      }
      os.close();
     
      InputStream is = new FileInputStream("test.txt");
      int size = is.available();

      for(int i=0; i< size; i++){
         System.out.print((char)is.read() + "  ");
      }
      is.close();
   }catch(IOException e){
      System.out.print("Exception");
   }	
   }
}

Il programma di cui sopra crea una test.txt di file, ed il dato numero scritto in forma binaria del documento, mentre l'uscita per la console.

Perché è scritto in codice binario sopra, ci possono essere alterati, è possibile utilizzare i seguenti esempi di codice per risolvere il problema dei rifiuti:

//文件名 :fileStreamTest2.java
import java.io.*;

public class fileStreamTest2{
	public static void main(String[] args) throws IOException {
		
		File f = new File("a.txt");
		FileOutputStream fop = new FileOutputStream(f);
		// 构建FileOutputStream对象,文件不存在会自动新建
		
		OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
		// 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk
		
		writer.append("中文输入");
		// 写入到缓冲区
		
		writer.append("\r\n");
		//换行
		
		writer.append("English");
		// 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入
		
		writer.close();
		//关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉
		
		fop.close();
		// 关闭输出流,释放系统资源

		FileInputStream fip = new FileInputStream(f);
		// 构建FileInputStream对象
		
		InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
		// 构建InputStreamReader对象,编码与写入相同

		StringBuffer sb = new StringBuffer();
		while (reader.ready()) {
			sb.append((char) reader.read());
			// 转成char加到StringBuffer对象中
		}
		System.out.println(sb.toString());
		reader.close();
		// 关闭读取流
		
		fip.close();
		// 关闭输入流,释放系统资源

	}
}

I file e le I / O

Ci sono anche lezioni su di file e di I / O, abbiamo anche bisogno di sapere:

• File di classe (Class)
• FileReader Class (Class)
• FileWriter Class (Class)

La directory Java

Creare una directory:

classe File ha due metodi possono essere usati per creare una cartella:

• mkdir () per creare una cartella, il successo, restituisce vero, non riesce restituisce false. La mancata mostrato oggetto File percorso specificato esiste già, o perché l'intero percorso non esiste, la cartella non può essere creata.
• Metodo mkdirs () per creare una cartella e tutto il suo cartella principale.

L'esempio seguente crea la cartella "/ tmp / user / java / bin":

import java.io.File;

public class CreateDir {
   public static void main(String args[]) {
      String dirname = "/tmp/user/java/bin";
      File d = new File(dirname);
      // 现在创建目录
      d.mkdirs();
  }
}

Compilare ed eseguire il codice qui sopra per creare la directory "/ tmp / user / java / bin".

Nota: Java su UNIX e Windows automaticamente in base al separatore di percorso del file risoluzione concordata. Se si utilizza un separatore nella versione per Windows di Java, (/), il percorso è ancora essere adeguatamente risolto.

directory Leggi

Una directory è in realtà un oggetto File che contiene altri file e cartelle.

Se si crea un oggetto File ed è una directory, il metodo poi un isDirectory call () restituisce true.

Chiamando il metodo lista degli oggetti () per estrarre un elenco di file e cartelle che contiene.

L'esempio seguente mostra come utilizzare il metodo di lista () per verificare il contenuto di un file contenuto nella cartella:

import java.io.File;

public class DirList {
   public static void main(String args[]) {
      String dirname = "/tmp";
      File f1 = new File(dirname);
      if (f1.isDirectory()) {
         System.out.println( "Directory of " + dirname);
         String s[] = f1.list();
         for (int i=0; i < s.length; i++) {
            File f = new File(dirname + "/" + s[i]);
            if (f.isDirectory()) {
               System.out.println(s[i] + " is a directory");
            } else {
               System.out.println(s[i] + " is a file");
            }
         }
      } else {
         System.out.println(dirname + " is not a directory");
    }
  }
}

Gli esempi sopra risultati elaborati sono i seguenti:

Directory of /tmp
bin is a directory
lib is a directory
demo is a directory
test.txt is a file
README is a file
index.html is a file
include is a directory