Análise real do fluxo de entrada e saída do arquivo Java (adequado para Xiaobai)

        Na API Java, um objeto que pode ler uma sequência de bytes é chamado de fluxo de entrada e um objeto que pode escrever uma sequência de bytes é chamado de fluxo de saída. Os dois fluxos que envolvemos mais são InputStream e OutputStream. classe abstrata. Este artigo é minha experiência de leitura de "Java Core Technology Volume Dois". O código foi escrito por mim em combinação com cenários específicos. Acredito que os leitores que são iniciantes em fluxo de entrada e fluxo de saída serão capazes de distinguir com precisão os dois fluxos depois lendo. Finalmente, não é fácil criar, curtir, coletar e seguir três links, caranguejo e caranguejo ~

Um, fluxo de entrada e fluxo de entrada de arquivo

1. Explore o método de leitura

       Primeiro, a classe InputStream tem um método abstrato: abstract int read ()

       Este método lerá um byte e retornará o byte que foi lido, ou retornará -1 quando o fim da entrada for alcançado. Nota: Como InputStream raramente é usado diretamente na prática, usamos principalmente subclasses de InputStream, entre as quais a mais comumente usada é FileInputStream, em que a classe FileInputStream substitui o método de leitura da classe InputStream.

Aqui está o código-fonte JDK como referência:

       Código-fonte read () de InputStream:

       @Override
            public int read() throws IOException {
                ensureOpen();
                return -1;
            }

        A parte do comentário na figura abaixo diz: Leia um byte de dados desse fluxo de entrada. Se não houver entrada disponível para leitura, este método será bloqueado. Retorna o próximo byte. Se o final do arquivo for alcançado, -1 é retornado.

    /**
     * Reads a byte of data from this input stream. This method blocks
     * if no input is yet available.
     *
     * @return     the next byte of data, or {@code -1} if the end of the
     *             file is reached.
     * @throws     IOException  if an I/O error occurs.
     */
    public int read() throws IOException {
        return read0();
    }

Exemplos específicos são fornecidos abaixo.

Abra o IDEA (não use o Eclipse maligno, isso não é nada bom), crie um arquivo de texto Test.txt, o conteúdo do arquivo é: Olá!

Para criar o arquivo Test.java, você deve primeiro criar um objeto de arquivo: File file = new File ("E: \\ spraying problem \\ Test.txt");

public class Test {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\喷涂问题\\Test.txt");
        FileInputStream in=new FileInputStream(file);
        int read = in.read();
        System.out.println(read);
    }
}

Saída: 72.

         Talvez alguém esteja curioso para saber por que um número é gerado? Na verdade, este é o código ASCII correspondente à letra H!

Depois de consultar a tabela, os códigos ASCII correspondentes de H, e, l, l, o ,! são 72 101 108 108 111 33, portanto, só precisamos converter o tipo inteiro para o tipo de caractere.

public class Test {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\喷涂问题\\Test.txt");
        FileInputStream in=new FileInputStream(file);
        int read = in.read();
        char text=(char)read;
        System.out.println(text);
    }
}

         Então você pode produzir: H

 

2, método readAllBytes

            Se você usar apenas o método read, como no exemplo acima, você terá que ler 'H', 'E', 'L' ..., obviamente, é muito lento e inconveniente. Portanto, a partir do Java9, é fornecido um método readAllBytes (), que lê diretamente todos os caracteres no fluxo de entrada em uma matriz de bytes . Então você pode gerar informações de texto de uma vez por meio da conversão!

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\喷涂问题\\Test.txt");
        FileInputStream in=new FileInputStream(file);
        byte[] bytes = in.readAllBytes();
        for (byte Byte : bytes) {
            char c=(char)Byte;
            System.out.print(c);
        }
    }
}

Saída do console:

 

 

Em segundo lugar, o fluxo de saída do arquivo

        Agora vamos explicar as etapas gerais do fluxo de entrada anterior de maneira contínua:

1. Crie um arquivo de texto e insira um parágrafo de texto Hello!

2. Leia as informações de texto na matriz de bytes byte [] por meio do fluxo de entrada.

---------------------------------------------Linha divisória--- ---------------------------------------------

        E quanto ao fluxo de saída?

        Claro que é o contrário! ! Ou seja , produza os dados já na matriz de bytes para um arquivo de texto vazio .

Dê um exemplo com base no anterior:

1. Primeiro crie um arquivo de texto vazio ReadFromTest.txt.

2. Crie um objeto file2 representando um arquivo vazio e chame o método out.write (). Pode ser entendido que o fluxo de saída foi vinculado ao novo arquivo, e escrever a matriz de bytes no fluxo de saída é equivalente a escrever em o novo arquivo.

import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException {
        File file1 = new File("E:\\喷涂问题\\Test.txt");
        FileInputStream in=new FileInputStream(file1);
        byte[] bytes = in.readAllBytes();
//以上部分的代码将原来Test.txt中的hello!转移到字符数组bytes中了

        File file2 = new File("E:\\喷涂问题\\ReadFromTest.txt");
        FileOutputStream out = new FileOutputStream(file2);
        out.write(bytes);
    }
}

3. Execute o código acima e você verá que a mensagem de texto Hello! Aparece no novo arquivo ReadFromTest.txt.

Se você não sabe por que há um código truncado por trás, amigos que sabem como eliminá-lo podem comentar na área de mensagem!