Java fundação IO

Conceito de fluxo

Fluxo : Em Java, todos os dados são lidos e escritos usando o fluxo. Fluxo é um conjunto de sequencial, começando e terminando com uma colecção de bytes, é o termo geral para a transmissão de dados ou abstrato.
Que a transmissão de dados entre dois dispositivos é chamado de fluxo, a essência é o fluxo de transmissão de dados , características de transmissão de dados dos vários tipos de resumo de fluxo, manipulação de dados conveniente mais intuitiva.
Efeito do fluxo : o estabelecimento de um caminho de transporte da fonte de dados e destino

classificação de fluxo :

• Fluxo divididos por: a entrada do fluxo de saída
• De dados da unidade de processamento de acordo com o ponto: fluxo de bytes (8 bytes), (16 bytes) de fluxo de caracteres

Qual é a entrada, saída

Entrada é a leitura de dados a partir de vários dispositivos de entrada (incluindo arquivo, um teclado, etc.) na memória.
Saída pelo contrário, é para gravar dados em vários dispositivos de saída (como um arquivo, exibição, disco, etc.).
Do ponto de vista do arquivo é um resumo breve, o fluxo de dados de entrada é lido, o fluxo de saída para gravar dados. Neste processo, sempre colocar a memória como um ponto de referência.

O que é um fluxo de bytes, um fluxo de caracteres

Se você quer lidar com o conteúdo do arquivo, ele deve ser feito pelo modo de operação do fluxo.
No pacote java.io, é dividido em duas correntes: de fluxo de bytes e fluxo de caracteres
de fluxo de bytes : o fluxo de dados é um menor unidade de bytes de dados. InputStream, OutputStream.
Fluxo de caracteres : o fluxo de dados é um menor unidade de caracteres de dados, personagens Java em caracteres Unicode ocupa dois bytes. Reader, Writer.

fluxo de bytes

1, FilelnputStream 和 FileOutputStream

• input FileInputStream obtém bytes de um sistema de arquivos em um arquivo, para a leitura de fluxo de bytes matéria com base de dados de imagem
• fluxo de saída de arquivo FileOutputStream para escrever dados para o fluxo de saída ou um FileDescriptor Arquivo.

Por exemplo: por agora eu acho "D: \ mordeu" obter o arquivo "hello.txt" sob este caminho, então o caminho novamente sob outra cópia do mesmo documento.

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

? Por que você precisa de cache Fluxo
A: Quando lemos a leitura file (), cada um lê um byte de tempo de acesso de disco rígido, baixa eficiência. Quando o arquivo é muito grande, a operação não é muito conveniente. Então, precisamos de fluxo de buffer cache uso ao criar objetos de buffer, ele cria uma matriz de buffer. Quando lemos um arquivo, começando com o disco rígido ler o buffer, a saída pode diretamente da zona tampão, será mais eficiente.

• Quando BufferedInputStream adiciona funcionalidade ao outro fluxo de entrada para criar BufferedInputStream, que vai criar uma matriz de tampão interno
• BufferedOutputStream alcançar uma aplicação de fluxo de saída tamponada pode escrever bytes para o fluxo de saída de fundo

Exemplo: Use BufferedInputStream implementado cópia de arquivo e 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成功！");
    }
}

fluxo de caracteres

1, o personagem transmitir FileReader e FileWriter

• Se você ler o conteúdo do arquivo, você pode usar subclasses diretas FileReader
• Se você está escrevendo para um arquivo, você deve usar FileWriter subclasse

Copiar arquivos

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, o carácter e o fluxo de tampão BufferedReader BufferedWriter

Para melhorar a eficiência do fluxo de leitura de caracteres, o mecanismo de buffer é introduzida, lote ler e caráter de gravação, aumenta a eficiência da leitura e escrita de um único personagem.

• BufferedReader para ler caracteres utilizados para acelerar a velocidade de
• BufferedWriter usado para acelerar velocidades de gravação

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

byte comparar o fluxo de fluxo de caracteres

fluxo de bytes	fluxo de caracteres
A unidade de base é um byte	A unidade básica é um símbolo Unicode
Sem buffer, o próprio arquivo operar diretamente	Use Tampão
Recursos (método Close) não fechado, pode ser produzida	Fechar método não usá-lo, não de saída

conversão fluxo de bytes personagem

OutputStreamWriter 和 InputStreamReader

• Leitor InputStreamReader é uma subclasse da corrente de bytes de entrada em um fluxo de caracteres
• Escritor OutputStreamWriter é uma subclasse do fluxo de caracteres saída em um fluxo de bytes

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