java io Basics

O registro sobre a utilização de conhecimentos básicos de java io e codificação relacionados

Tenho que dizer, java io classes relacionadas Um lote de que, cada vez que todos nós sentimos um pouco caótico, temporariamente não pretendo saber demais, a primeira parte da aprendizagem, pode realizar operações básicas, pode ser usado na linha.

fonte https://www.codercto.com/courses/d/1491.html

---

java io alguém tem escrito uma série de tutoriais

java io classes relacionadas podem ser divididos no personagem principal e um byte

A este respeito também estou do outro blog para aprender, é a imagem descrição acima, o sentimento de acordo com estes dois métodos para distinguir, então é mais fácil de entender
em io, eu ainda preferem a abordagem c / c ++ linguagem, com um char tipo pode resolver todos os problemas, embora, desta forma pode não ser fácil de usar java io

---

A seguir, uma breve conversa sobre a diferença entre caráter e byte tipo de io

• Byte io, isto é, quando a unidade básica em bytes ler. Tudo no computador, em essência, é a representação binária
  para o código básico ascii, você precisa usar um byte (8 binário) representam diretamente a unidade básica que podemos ler de um arquivo é a palavra seção.
  Aqui podemos considerar por que não um pouco, mas byte, (entendimento pessoal, bit, em seguida, apenas dois estados, não é suficiente para distinguir a base de caracteres imprimíveis, que é o código ASCII usando byte seria relativamente fácil, uma vez remova de 8 bits, um valor que é muito fácil de distinguir entre diferentes personagens, há uma razão para ser a menor unidade de memória e o computador é uma relação bytes)

• io personagem, em comparação com o byte pode ser considerada uma linguagem de programação para ajudar você a fazer um passo, ele lê a ordem de bytes, de acordo com a tabela de codificação, se for julgado não um caractere válido, seria continuar a ler até a formação um caractere válido. Esta codificação tem uma relação. Para um exemplo comum, o número de bytes ocupados pelos diferentes caracteres de codificação diferente, em caracteres GBKquando codificados, 2 bytes para utf-8codificação, ocupa 3 bytes. Assim, em ambos os casos, podemos descrever o trabalho de java caráter io, o java ao ler 汉o primeiro byte na GBKtabela de codificação não consegue encontrar os caracteres de byte correspondente neste , que mesmo depois de ler isso de novo, vai ler um byte e um byte antes da fusão ir verificar a tabela de codificação para encontrar o personagem correspondente é 汉a palavra, de fato, não termina aqui, porque o uso de carvão java 2 bytes ele representa um personagem, então o java interno também precisa 汉encontrar uma palavra correspondente valor char (entendimento pessoal, sentindo-se cada vez mais problemas). Outra codificação é o mesmo.

---

A fim de explicar a relação entre os dois, com uma breve explicação sobre o programa em linguagem C, aqui você vai ver decodificação console de operação em um java caráter io semelhante

#include <stdio.h>
#include <string.h>

int main()
{
    const char* str = "汉字";
    int len = strlen(str);
    printf("len is %d\n", len);
    // 以 char 形式 逐个输出 
    for (int i = 0; i < len; i++) {
        printf("%c", str[i]);
    }
    puts("");
    return 0;
}

• Criar um novo test.c, defina o formato de codificação GBK, em circunstâncias normais, a saída do console no Windows é len = 4então a saída 汉字
  se colocarmos na entrada do console chcp 65001, consolar a página de código ativa alterado do utf-8, ou seja, deixar consola utf-8 fluxo de bytes descodificados de saída, a saída pode ser observado len = 4, 汉字não há distorção do símbolo de saída ou saída. (Note que o programa deve ser modificado para ser executado em uma janela da página activa no presente, porque nós modificar apenas um único válido)
• Ibid., Desta vez, vamos definir o formato de codificação de texto é utf-8o mesmo teste, verificou-se que quando a página de código consola activa para modificar utf-8a ordem de saída normal, enquanto é capaz de verlen = 6

Ou para o seu registro de que, se você pode usar ferramentas xxd de linux, você pode usar essa ferramenta para exibir caracteres binários de codificação diferente, disse, antes de tudo, podemos determinar, por GBKe utf8, Kanji disse no texto é diferente para a linguagem C , ele não se importa com codificação de texto, por isso vai ser tudo o leitor de binário, compilado, a saída de texto é uma saída binário correspondente para exibir resultados diferentes porque o console método de decodificação. io java caráter também.

---

Io aprendendo sobre a operação de gravação

• caráter Io a ler e escrever arquivos

package Learn.Io;

import java.io.*;

public class DemoFirst {

    /**
     * 按字符依次读取
     */
    void readForeach() throws IOException {
        final int MAX_SIZE = 1024;              // 如果不能估计 文件字符个数，最好不要使用常量
        char[] save = new char[MAX_SIZE];
        FileReader in = new FileReader("./File/test.txt");
        int charValue, count = 0;
        while (-1 != (charValue = in.read())) {
            save[count++] = (char) charValue;
        }
        in.close();
        System.out.println(String.valueOf(save, 0, count));
    }

    /**
     * 一次性读取到 char 数组中
     * @throws IOException
     */
    void readOnce() throws IOException {
        final int MAX_SIZE = 1024;
        FileReader in = new FileReader("./File/test.txt");
        char[] data = new char[MAX_SIZE];
        int num = in.read(data);
        in.close();
        System.out.println(String.valueOf(data, 0, num));
    }

    /**
     * 字符方式写入文件
     * @throws IOException
     */
    void write() throws IOException {
        // 文件内容会被清除
        FileWriter out = new FileWriter("./File/test.txt");
        String str = "待写入字符";
        char[] s = {'测', '试', '一', '下'};
        out.write(str);
        out.write(s, 0, 2);
        out.flush();
        out.close(); // 关闭时会进行一次 flush 不过还是显式写一下比较好
    }

    public static void main(String[] args) throws IOException{
        DemoFirst test = new DemoFirst();
        test.readForeach();
        test.readOnce();
        test.write();
    }
}

• arquivos de leitura Byte e escrever

package Learn.Io;

import java.io.*;

public class ioByChar {
    File file = new File("./File/test.txt");

    /**
     * 循环处理文本
     * @throws IOException
     */
    void readForeach() throws IOException {
        InputStream read = new FileInputStream(file);
        int byteValue, count = 0;
        byte[] data = new byte[1024];
        while (-1 != (byteValue = read.read())) {
            data[count++] = (byte) byteValue;
        }

        System.out.println(new String(data, 0, count));
    }

    /**
     * 一次将文本全部加载到 内存
     * @throws IOException
     */
    void readOnce() throws IOException {
        InputStream in = new FileInputStream(file);
        byte[] data = in.readAllBytes();
        System.out.println(new String(data, 0, data.length));
    }

    /**
     * 按字节写入
     * @throws IOException
     */
    void write() throws IOException {
        OutputStream out = new FileOutputStream(file);
        String str = "写入文本";
        byte[] data = str.getBytes();
        out.write(data, 0, data.length);
        out.flush();
        out.close();
    }

    /**
     * 复制文件 //
     * @param src 源文件
     * @param dst 目的文件
     * @throws IOException
     */
    void copy(File src, File dst) throws IOException {
        InputStream a = new FileInputStream(src);
        OutputStream b = new FileOutputStream(dst, true);
        a.transferTo(b);
        a.close();
        b.close();
    }
    public static void main(String[] args) throws IOException {
        ioByChar test = new ioByChar();
        test.readForeach();
        test.readOnce();
        test.write();
        test.copy(new File("./File/src.txt"), new File("./File/dst.txt"));
    }
}

• io tamponada
  Tampão io io em relação ao equivalente geral para a adição de uma camada de embalagens, utilizar um tampão para evitar o acesso a ficheiros múltiplos, e não-cache como o método básico

package Learn.Io;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
/**
 * 这里只写了 BufferedReader BufferedWriter
 * 还有 BufferedInputStream 和 BufferedOutputStream
 */
public class bufferIo {
    static final String filePath = "./File/test.txt";

    /**
     * 按行处理
     * @throws IOException
     */
    void lineRead() throws IOException {
        // BufferedInputStream 不能按行处理
        BufferedReader charRead = new BufferedReader(new FileReader(filePath));
        String read;
        List<String> data = new ArrayList<>();

        while (null != (read = charRead.readLine())) {
            data.add(read);
        }
        System.out.println(data.toString());
        charRead.close();
        // 使用 Stream 处理
//        BufferedReader ano = new BufferedReader(new FileReader(filePath));
//        ano.lines().map((e) -> e + '|' +  e.length()).forEach(System.out::println);
//        ano.close();
    }

    /**
     *
     * @throws IOException
     */
    void Write() throws IOException {
        BufferedWriter out = new BufferedWriter(new FileWriter(filePath));
        out.write("line 1");
        out.newLine();
        out.write("line 2");
        out.flush();
        out.close();
    }
    public static void main(String[] args) throws IOException {
        bufferIo s = new bufferIo();
        s.lineRead();
        s.Write();
    }
}

• Leia e arquivos de gravação de acordo com a codificação especificada

package Learn.Io;

import java.io.*;

public class fileIo {

    /**
     * 读取指定编码的文件
     * 这里关心文件的编码 所以使用 Reader 和 Writer
     * @param filePath 文件路径
     * @param encoding 文件编码
     */
    void read(String filePath, String encoding) throws IOException {
        File file = new File(filePath);
        InputStreamReader in = new InputStreamReader(new FileInputStream(file), encoding);
        char[] data = new char[1024];
        in.read(data);
        in.close();
        System.out.println(data);
    }

    /**
     * 使用 bufferIo 读取
     * @param filePath
     * @param encoding
     * @throws IOException
     */
    void bufferRead(String filePath, String encoding) throws IOException {
        File file = new File(filePath);
        BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(file), encoding));
        // Stream 很方便
        in.lines().forEach(System.out::println);
        in.close();
    }

    /**
     * 字节流读取，使用 String 解码
     * 这种方式没有 字符流安全，按字节读取有可能读取到某个字符的一部分就终止了
     * 这时如果使用 字符集去解码，就会造成问题
     * 如果是要将文件整体读入，作为一个字符串处理，则可以用这种方式
     * @param filePath
     * @param encoding
     */
    void byteRead(String filePath, String encoding) throws IOException {
        File file = new File(filePath);
        InputStream in = new FileInputStream(file);
        byte[] data = in.readAllBytes();
        System.out.println(new String(data, encoding));
    }

    /**
     * 输出与上述相反，Reader <=> Writer Input <=> Output 就不写了
     */
    void write() {

    }

    public static void main(String[] args) throws IOException {
        fileIo rw = new fileIo();
        rw.read("./File/test.txt", "gbk");
        rw.read("./File/test.txt", "gbk");
    }
}

• dados formatados

package Learn.Io;

import java.io.*;
import java.util.stream.IntStream;

public class formatIo {

    /**
     * 利用 printf 格式化数据写入文件
     * @throws FileNotFoundException
     */
    void writeFormatDataToFile() throws FileNotFoundException {
        PrintWriter out = new PrintWriter("./File/test.txt");
        IntStream.range(0, 10).forEach(e -> out.printf("number of this line is %3d\n", e));
        out.flush();
        out.close();
    }

    /**
     * 格式化数据输入 字符串
     * @throws IOException
     */
    void formatDataToString() throws IOException {
        StringWriter str = new StringWriter();
        PrintWriter w = new PrintWriter(str);
        w.printf("10 的 16进制表示 : %#06x", 10);
        w.flush();
        w.close();
        str.close();
        System.out.println(str);
    }

    public static void main(String[] args) throws IOException {
        formatIo rw = new formatIo();
        rw.writeFormatDataToFile();
        rw.formatDataToString();
    }
}

• outro

package Learn.Io;

import java.io.*;

public class vector {

    /**
     * 感觉 java 中的 ByteArrayOutputStream CharArrayWriter 实现的功能类似 c++ 中的 vector
     * @throws IOException
     */
    void readIntoByteArray() throws IOException {
        InputStream in = new FileInputStream("./File/test.txt");
        ByteArrayOutputStream data = new ByteArrayOutputStream();
        int num;
        while (-1 != (num = in.read())) {
            data.write(num);
        }
        in.close();
        System.out.println(data);
    }

    /**
     * 使用 StringReader 和 StringWriter
     * @throws IOException
     */
    void rwString() throws IOException {
        String str = "this is a string";
        StringReader in = new StringReader(str);
        StringWriter out = new StringWriter();
        PrintWriter w = new PrintWriter(out);
        w.println("first line");
        in.transferTo(out);         // 输入流传送到输出流
        in.close();
        out.close();
        System.out.println(str);
        System.out.println("---------------");
        System.out.println(out);
    }

    public static void main(String[] args) throws IOException {
        vector s = new vector();
        s.readIntoByteArray();
        s.rwString();
    }
}

Não são aprendidos ...