Java Foundation IO

Concept de flux

Débit : En Java, toutes les données sont lues et écrites à l' aide du flux. Flow est un ensemble de séquentielle, en commençant et se terminant par une collection d'octets, est le terme général pour la transmission de données ou abstraite.
Cette transmission de données entre deux appareils est appelée flux, l'essence est le flux de transmission de données , les caractéristiques de transmission de données des différents types de flux abstrait, la manipulation de données pratique plus intuitive.
Effet de l' écoulement : l' établissement d' un trajet de transport pour la source de données et de destination

Classement flux :

• Écoulement divisé par: l'entrée du flux de sortie
• l'unité de traitement de données conformément au point: flux d'octets (8 octets), (16 octets) flux de caractères

Quelle est l'entrée, la sortie

Entrée sont les données lues à partir de différents périphériques d'entrée (y compris le fichier, un clavier, etc.) dans la mémoire.
Sortie par contre, est d'écrire des données à différents dispositifs de sortie (tel qu'un fichier, afficher, disque, etc.).
Du point de vue du dossier est un bref résumé, le flux de données d'entrée est lu, le flux de sortie pour écrire des données. Dans ce processus, toujours mettre la mémoire comme point de référence.

Qu'est-ce qu'un flux d'octets, un flux de caractères

Si vous voulez traiter avec le contenu du fichier, il doit être fait par le mode de fonctionnement du flux.
Dans paquet java.io, il est divisé en deux flux: le flux d'octets et flux de caractères
flux d'octets : le flux de données est une unité la plus petite d'octets de données. InputStream, OutputStream.
Flux de caractères : le flux de données est une unité plus petite des caractères de données, les caractères Java dans caractères Unicode occupe deux octets. Reader, Writer.

flux d'octets

1, FileInputStream 和 FileOutputStream

• l'entrée de FileInputStream octets à partir d'un système de fichiers dans un fichier, pour lire des données d'image sur la base du flux d'octets brut
• flux de sortie de fichier FileOutputStream pour écrire des données dans le flux de sortie ou un fichier FileDescriptor.

Par exemple: pour l'instant je trouve « D: \ bit » get fichier « hello.txt » sous ce chemin, le chemin à nouveau sous une autre copie du même document.

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Solution {
    public static void main(String[] args) throws IOException {
        FileInputStream fin = new FileInputStream("D:\\bit\\hello.txt");
        FileOutputStream fout = new FileOutputStream("D:\\bit\\hell0Copy.txt");
        int len = 0;
        byte[] buff = new byte[1024];
        while ((len = fin.read(buff)) != -1) {
            fout.write(buff, 0, len);
        }
        fin.close();
        fout.close();
    }
}

2. BufferedInputStream 和 BufferedOutputStream

Pourquoi avez-vous besoin Flux du cache
A: Quand on lit la lecture de fichiers (), chaque lecture du mal d'accès disque octet, faible efficacité. Lorsque le fichier est trop volumineux, l'opération est très pratique. Nous avons donc besoin d'utiliser les flux de cache de mémoire tampon lors de la création d' objets tampons, il crée un réseau de tampon. Quand on lit un fichier, en commençant par le disque dur tampon de lecture, la sortie peut directement à partir de la zone tampon, sera plus efficace.

• Lorsque BufferedInputStream ajoute des fonctionnalités à un autre flux d'entrée pour créer BufferedInputStream, il va créer un tableau de mémoire tampon interne
• BufferedOutputStream parvenir à une application de flux de sortie tamponnée peut écrire des octets vers le bas du courant de sortie

Exemple: Utiliser copie de fichier mis en œuvre BufferedInputStream et BufferedOutputStream

import java.io.*;
public class Solution {
    public static void main(String[] args) throws IOException {
        File file = new File("bit.txt");
        if (!file.isFile()) {
            return;
        }
        BufferedInputStream bfis = new BufferedInputStream(new FileInputStream(file));
        BufferedOutputStream bfos = new BufferedOutputStream(new
                FileOutputStream("D:\\bit" + file.getName()));//copy到src目录下
        byte bytes[] = new byte[1024];
        int temp = 0; //边读边写
        while ((temp = bfis.read(bytes)) != -1) {//读
            bfos.write(bytes, 0, temp); //写
        }
        bfos.flush();
        bfos.close();
        bfis.close();
        System.out.println("copy成功！");
    }
}

flux de caractères

1, le caractère FileReader flux et FileWriter

• Si vous lisez le contenu du fichier, vous pouvez utiliser les sous-classes directes FileReader
• Si vous écrivez à un fichier, vous devez utiliser la sous-classe FileWriter

Copier les fichiers

import java.io.*;
public class Solution {
    public static void main(String[] args) throws IOException {
        //创建输入流对象
        FileReader fr = new FileReader("D:\\bit\\bitSrc.java");
        //创建输出流对象
        FileWriter fw = new FileWriter("D:\\bit\\bitCopy.java");
        //读写数据
        int ch;
        while((ch=fr.read())!=-1) {
            fw.write(ch);
        }
        //释放资源
        fw.close();
        fr.close();
    }
}

2, le caractère et le flux de tampon BufferedReader BufferedWriter

Pour améliorer l'efficacité du flux caractère lu, est introduit le mécanisme de mise en mémoire tampon, le lot de lecture et le caractère d'écriture, augmente l'efficacité de la lecture et l'écriture d'un seul caractère.

• BufferedReader pour lire les caractères utilisés pour accélérer la vitesse de
• BufferedWriter utilisé pour accélérer les vitesses d'écriture

import java.io.*;
public class Solution {
    public static void main(String[] args) throws IOException {
        FileReader reader=new FileReader("D:\\Ideaproject\\bit.txt");
        BufferedReader bReader=new BufferedReader(reader);
        FileWriter writer=new FileWriter("D:\\Ideaproject\\bit2.txt");
        BufferedWriter bWriter=new BufferedWriter(writer);
        String content="";
        //readLine一行一行的读取
        while((content=bReader.readLine())!=null){
        //\r\n换行
            bWriter.write(content+"\r\n");
        }
        /**
         * 关闭流的顺序：
         * 当A依赖B的时候先关闭A，再关闭B
         * 带缓冲的流最后关闭的时候会执行一次flush
         */
        reader.close();
        bReader.close();
        bWriter.close();
        writer.close();
    }
}

octet Comparer les flux de flux de caractères

flux d'octets	flux de caractères
L'unité de base est un octet	L'unité de base est un symbole Unicode
Pas de tampon, le fichier lui-même opérez	Utiliser un tampon
Ressource non fermée (méthode Close), peut être sortie	méthode Close ne l'utilise pas, pas de sortie

Caractère conversion de flux d'octets

OutputStreamWriter 和 InputStreamReader

• Lecteur InputStreamReader est une sous-classe de flux d'octets d'entrée en un flux de caractères
• Graveur OutputStreamWriter est une sous-classe de la chaîne de caractères de sortie en un flux d'octets

import java.io.*;
public class Solution {
    public static void main(String[] args) {
        // 创建字节流对象 System.in 代表从控制台输入
        InputStream in = System.in;
        // 创建字符流对象
        BufferedWriter bw = null;
        BufferedReader br = null;
        try {
            // 实例化字符流对象 通过 InputStreamReader 将字节输入流转化成字符输入流
            br = new BufferedReader(new InputStreamReader(in));
            //br = new BufferedReader(new InputStreamReader(in,"GBK"));
            bw = new BufferedWriter(new FileWriter("a.txt"));
            // 定义读取数据的行
            String line = null;
            // 读取数据
            while ((line = br.readLine()) != null) {
                // 如果输入的是"exit"就退出
                if ("exit".equals(line)) {
                    break;
                }
                // 将数据写入文件
                bw.write(line);
                // 写入新的一行
                bw.newLine();
                // 刷新数据缓冲
                bw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            try {
                if (bw != null)
                    bw.close();
                if (br != null)
                    br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.io.*;
public class Solution {
    public static void main(String[] args) {
        // 定义字节输出流的对象System.out
        OutputStream out = System.out;
        // 定义字符流的对象
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //通过OutputStreamWriter将字符转流换为字节流对象
            bw = new BufferedWriter(new OutputStreamWriter(out));
            //bw = new BufferedWriter(new OutputStreamWriter(out,"GBK"));
            br = new BufferedReader(new FileReader("a.txt"));
            // 定义读取行的字符串
            String line = null;
            // 读取数据
            while ((line = br.readLine()) != null) {
                // 输出到控制台
                bw.write(line);
                // 新的一行
                bw.newLine();
                // 刷新缓冲
                bw.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bw != null)
                    bw.close();
                if (br != null)
                    br.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}