flux de Java (flux), fichier (File) et IO

package de classe Java.io comprend presque toutes les opérations de besoins d'entrée et de sortie. Toutes ces classes de flux constituent la source d'entrée et la destination de sortie.

Java.io package continu supporte une variété de formats, tels que: types de base, les objets, les jeux de caractères localisées et ainsi de suite.

Elle peut être comprise comme une séquence d'un flux de données. Représente le flux d'entrée pour lire les données à partir d'une source à un flux de sortie cible représente l'écriture de données.

Java fournit un support puissant et flexible pour I / O, ce qui rend plus largement utilisé dans les transferts de fichiers et la programmation du réseau.

Toutefois, cette section décrit les fonctions I / O connexes les plus élémentaires et cours d'eau. Nous allons apprendre par exemple à ces fonctions.

Lire l'entrée de la console

entrée de la console Java terminée par le System.in.

Afin d'obtenir un flux de caractère contraignant à la console, vous pouvez System.in enveloppé dans un objet BufferedReader pour créer un flux de caractères.

Voici la syntaxe de base pour créer un BufferedReader:

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

Après objet BufferedReader est créé, nous pouvons utiliser la méthode de lecture () pour lire un caractère à partir de la console, ou lire une méthode chaîne readLine ().

Lire la suite saisie de caractères à partir de la console

Consulter l'objet BufferedReader est un personnage que vous souhaitez utiliser la méthode lire (), qui a la syntaxe suivante:

int read( ) throws IOException

Chaque appel à lire la méthode (), qui lit un caractère à partir du flux d'entrée et renvoie le caractère comme une valeur entière. Lorsque la fin du flux renvoie -1. La méthode renvoie IOException.

Le programme suivant illustre l'utilisation de la méthode read () lit les caractères à partir de la console continue jusqu'à ce que l'utilisateur entre "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');
   }
}

Les exemples ci-dessus les résultats compilés sont les suivants:

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

Lit une chaîne à partir de la console

Lire à partir de l'entrée standard une chaîne a besoin d'utiliser une méthode BufferedReader readLine ().

Son format général est:

String readLine( ) throws IOException

Le programme suivant lit et lignes affiche de caractères jusqu'à ce que vous entrez le mot «fin».

// 使用 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"));
   }
}

Les exemples ci-dessus les résultats compilés sont les suivants:

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 la version 5 après que nous pouvons également utiliser Java Scanner classe pour obtenir la console d'entrée.

sortie Console

Il a été introduit dans la sortie précédente de la console se fait par print () et println (). Ces méthodes définies par la PrintStream de classe, System.out est une référence à l'objet de classe.

PrintStream hérité classe OutputStream, et met en œuvre la méthode write (). Ainsi, write () peut également être utilisé pour et à partir de la console écrit.

La définition la plus simple de PrintStream le format d'écriture () sont les suivantes:

void write(int byteval)

Cette méthode permettra de réduire octet byteval écrite dans le flux.

Exemples

L'exemple suivant utilise write () le caractère "A" et suivi par une sortie de retour à la ligne à l'écran:

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

Exécutez l'exemple ci-dessus sortie "A" caractère dans la fenêtre de sortie

A

Remarque: la méthode write () est pas souvent utilisé parce que la méthode print () et println () est plus pratique à utiliser.

Lecture et écriture de fichiers

Comme cela est décrit ci-dessus, un courant est définie comme étant une séquence de données. flux d'entrée pour la lecture des données de la source vers le flux de sortie cible pour l'écriture des données.

Ce qui suit est une description des flux de hiérarchie de classe d'entrée et de sortie du diagramme.

Le suivant sera examiné deux courants importants sont FileInputStream et FileOutputStream:

FileInputStream

Le flux de lecture de données à partir d'un fichier, son objet peut être utilisé pour créer un nouveau mot-clé.

Il existe plusieurs procédés de construction peuvent être utilisés pour créer des objets.

Vous pouvez utiliser le nom de fichier de type chaîne pour créer un objet de flux d'entrée pour lire le fichier:

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

Vous pouvez également utiliser un objet de fichier pour créer un objet de flux pour lire les fichiers d'entrée. Nous devons d'abord utiliser la méthode File () pour créer un objet de fichier:

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

objet InputStream est créé, vous pouvez utiliser la méthode suivante pour lire le flux de courant ou effectuer d'autres opérations.

En plus de InputStream, il y a un autre flux d'entrée, pour plus de détails se référer aux liens suivants:

• ByteArrayInputStream
• DataInputStream

FileOutputStream

Cette classe est utilisée pour créer un fichier et écrire des données de fichier.

* Si le flux d'ouvrir un fichier pour la sortie, n'existe pas le fichier cible, puis le flux va créer le fichier.

Il existe deux façons de créer un objet constructeur FileOutputStream.

Utiliser la chaîne tapez un nom de fichier pour créer un objet de flux de sortie:

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

Vous pouvez également utiliser un objet de fichier pour créer un flux de sortie pour écrire des fichiers. Nous devons d'abord utiliser la méthode File () pour créer un objet de fichier:

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

Créer un objet OutputStream est terminée, vous pouvez utiliser la méthode suivante pour écrire le débit d'eau ou d'effectuer d'autres opérations.

Outre OutputStream, il y a un autre flux de sortie, pour plus de détails se référer aux liens suivants:

• ByteArrayOutputStream
• DataOutputStream

Exemples

Voici une démonstration des exemples d'utilisation InputStream et OutputStream:

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

Le programme ci-dessus crée un fichier test.txt, et le nombre donné par écrit sous forme binaire du document, alors que la sortie de la console.

Parce qu'il est écrit en code binaire ci-dessus, il peut être déformé, vous pouvez utiliser les exemples de code suivants pour résoudre le problème des ordures:

//文件名 :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();
		// 关闭输入流,释放系统资源

	}
}

Les fichiers et les E / S

Il y a aussi des cours sur fichier et I / O, nous avons aussi besoin de savoir:

• Fichier de classe (classe)
• FileReader Class (Classe)
• FileWriter Class (Classe)

Le répertoire Java

Créez un répertoire:

classe File possède deux méthodes peuvent être utilisées pour créer un dossier:

• mkdir () pour créer un dossier, le succès, renvoie vrai, ne parvient pas elle retourne false. Le non montré objet File chemin spécifié existe déjà, ou parce que n'existe pas le chemin complet, le dossier ne peut pas être créé.
• méthode mkdirs () pour créer un dossier et tout son dossier parent.

L'exemple suivant crée le dossier "/ 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();
  }
}

Compiler et exécuter le code ci-dessus pour créer le répertoire "/ tmp / user / java / bin".

Remarque: Java sur UNIX et Windows automatiquement en fonction du séparateur de chemin du fichier de résolution convenu. Si vous utilisez un séparateur dans la version Windows de Java, (/), le chemin est encore d'être correctement résolu.

Lire répertoire

Un répertoire est en fait un objet de fichier qui contient d'autres fichiers et dossiers.

Si vous créez un objet File et il est un répertoire, puis une méthode isDirectory d'appel () retourne vrai.

En faisant appel à la méthode liste d'objets () pour extraire une liste des fichiers et dossiers qu'il contient.

L'exemple suivant montre comment utiliser la méthode list () pour vérifier le contenu d'un fichier contenu dans le dossier:

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

Les exemples ci-dessus les résultats compilés sont les suivants:

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