Java中的IO流（二）_io流写入字符串不乱码-CSDN博客

本文链接：https://blog.csdn.net/Veer_c/article/details/103833423

Java中的IO流（一）：
https://blog.csdn.net/Veer_c/article/details/103833045
Java中的IO流（二）：
https://blog.csdn.net/Veer_c/article/details/103833423
Java中的IO流（三）：
https://blog.csdn.net/Veer_c/article/details/103833811

编码问题

String中的编码和解码问题。
编码：把我们能够看懂的字符转换为看不懂的数据
解码：把我们看不懂的数据转换为看得懂的字符
public byte[] getBytes(String charsetName) 按照给定的编码方式，编码字节数组（gbk,utf-8）
String(byte[] bytes, String charsetName) 按照给定的编码方式解码字符数组

String s = "中国好";
byte[] bytes = s.getBytes("utf-8");
System.out.println(Arrays.toString(bytes));
//String(byte[] bytes, String charsetName)
System.out.println(new String(bytes,"gbk"));

注意：用什么编码，就必须用什么解码，否则会出现乱码。

字符流

Reader
Writer

IO流中的编码和解码问题
OutputStreamWriter:把字节输出流转换为字符输出流
InputStreamReader:把字节输入流转换为字符输入流

转换流

写入数据，把字节输出流转换为字符输出流（不指定码表）
 	OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));
把字节输出流转换为字符输出流（指定码表）
     OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"), "GBK");
     OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"), "UTF-8"); 
读取数据， 把字节输入流转换为字符输入流（不指定码表）
     InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"));
把字节输入流转换为字符输入流（指定码表）
     InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"), "GBK");

总结：一般创建字符输入或者输出流一般情况下使用系统默认的码表就可以，如果来来回回需要指定码表的话，就显得非常的麻烦了。

将以上创建方式继续简化
如果采用刚才的方式，创建对象写起来比较复杂。
InputStreamReader isr = new InputStreamReader(new FileInputStream(“a.txt”));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(“b.txt”));
为了简化这种操作，java就针对这两个转换的字符流提供其子类。
FileReader
FileWriter
它们的默认编码是采用系统编码。
构造学习：
FileWriter(File file)
FileWriter(String fileName)
FileReader(File file)
FileReader(String fileName)

flush()和close()的区别：
flush：刷新缓冲区，流对象可以继续
close：先刷新缓冲区，再关闭流对象。流对象不可以继续使用了。

public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        /*要给字符输出流中写数据步骤：
         * 1.创建字符输出流对象，并指向一个文件
         * 2.调用字符输出流写数据的方法给里面写数据
         * 3.刷新缓冲区
         * 4.关流 */
        // FileWriter(File file) 
        // FileWriter(String fileName) 
        //1.创建字符输出流对象
        //FileWriter fw = new FileWriter(new File("c.txt"));
        FileWriter fw = new FileWriter("c.txt");
        //调用方法写数据
        //一次写一个字符  write(int c) 
        //fw.write('a');
        //一次写一个字符数组write(char[] cbuf)
        //char[] chs = {'h','e','l','l','o'};
        //fw.write(chs);
        //一次写一个字符数组的一部分write(char[] cbuf, int off,int len)
        //char[] chs = {'h','e','l','l','o'};
        //fw.write(chs, 2, 3);
        //一次写一个字符串write(String str)
        //fw.write("helloworld");
        //一次写一个字符串的一部分write(String str,int off,int len)
        fw.write("helloworld", 5, 5);
        //刷新缓冲区
        fw.flush();
        //关流
        fw.close();
    }
}
import java.io.FileNotFoundException;
import java.io.FileReader;
/*   FileReader(File file) 
     FileReader(String fileName)*/
public class FileReaderDemo {
    public static void main(String[] args) throws Exception {
        /**
         * 使用字符输入流读取c.txt真的个文件的步骤：
         * 1.创建字符输入流对象，指向c.txt这个文件
         * 2.一次读取一个字符
         * 3.关流
         */
        //1.创建字符输入流对象，指向c.txt这个文件
        FileReader fr = new FileReader("c.txt");
        //2.一次读取一个字符
        /*System.out.println((char)fr.read());
        System.out.println((char)fr.read());
        System.out.println((char)fr.read());
        System.out.println((char)fr.read());
        System.out.println((char)fr.read());
        System.out.println(fr.read());*/
        //使用循环改进
/*      int ch;
        while ((ch=fr.read())!=-1) {
            System.out.println((char)ch);
        }*/
        //一次读取一个字符数组
/*      char[] chs = new char[2];
        System.out.println(fr.read(chs));//一次读取一个字符数组，返回的是读取到的实际的字符长度
        System.out.println(fr.read(chs));
        System.out.println(fr.read(chs));
        System.out.println(fr.read(chs));
        System.out.println(fr.read(chs));*/
        //使用循环改进上面代码
        //定义一个字符数组
        char[] chs = new char[1024];
        int len;
        while ((len=fr.read(chs))!=-1) {
            System.out.println(new String(chs, 0, len));
        }
        //3.关流
        fr.close();
    }
}

练习：给字符输出流里面利用方法写数据

字符输出流操作步骤：
A:创建字符输出流对象
B:调用写数据方法
C:释放资源
写数据方法：
一次写一个字符 write(int c)
一次写一个字符数组write(char[] cbuf)
一次写一个字符数组的一部分write(char[] cbuf, int off,int len)
一次写一个字符串write(String str)
一次写一个字符串的一部分write(String str,int off,int len)

字符输入流
字符输入流操作步骤:
A:创建字符输入流对象
FileReader fr = new FileReader(“a.txt”);
B:读取数据并显示在控制台：
a:一次读取一个字符
int ch;
while ((ch = fr.read()) != -1) {
System.out.print((char) ch);
}
b:一次读取一个字符数组
char[] chs = new char[1024];
int len;
while ((len = fr.read(chs)) != -1) {
System.out.print(new String(chs, 0, len));
}
C:释放资源：fr.close();
注意：字符流输入输出流复制的文件是有要求的，简单来说只要是记事本打开文件的内容你能够看得懂，就可以用字符流来进行复制，否则不行。
具体原因：像复制MP3或者一些视频文件的时候，如果他的字节个数不是偶数的话，就会造成文件的缺损，因为一个字符等于两个字节

1.利用字符流复制java文件（两种方式，一次读写一个字符，一次读写一个字符数组）

public class CopyFile {
    public static void main(String[] args) throws IOException {
        /* 1.封装数据源和目的地
         * 2.一次读写一个字符或者一次读写一个字符数组
         * 3.关流 */
        //1.封装数据源和目的地
        FileReader fr = new FileReader("InputStreamReaderDemo.java");
        FileWriter fw = new FileWriter("d.java");
        //2.1一次读写一个字符
        /*int ch;
        while ((ch=fr.read())!=-1) {
            fw.write(ch);//一次写一个字符
            fw.flush();//每写一次刷新缓冲区
        }*/
        //2.2一次读写一个字符数组
        char[] chs = new char[1024];
        int len;
        while ((len=fr.read(chs))!=-1) {
            fw.write(chs, 0, len);
            fw.flush();
        }
        //3.关流
        fw.close();
        fr.close();
    }
}

高效流：操作基本流的流
需求：给文件中写入十个”helloworld”,每写一个换一行，每写一行必须写入一个换行符“/r/n”，这样写的弊端，windows系统下的换行符是“/r/n”，Linux是”\n”，Mac是”\r”，这样会造成代码的通用性不强。

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/* 	 BufferedWriter:字符缓冲输出流
     构造：BufferedWriter(Writer out) 
     特殊方法：public void newLine():会根据系统来确定写入不同的换行符 */
public class BufferedWriterDemo2 {
    public static void main(String[] args) throws IOException {
        //使用高效字符输出流写入10个helloworld,每写一个换一行
        /* 1.创建字符高效输出流，并指向一个txt文件
         * 2.调用里面写数据的方法，给文件中写入数据
         * 3.调用换行的方法，给写入的数据换行
         * 4.刷新换新区
         * 5.关流  */
        //1.创建字符高效输出流，并指向一个txt文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("f.txt"));
        //2.调用里面写数据的方法，给文件中写入数据
        for (int i = 0; i < 10; i++) {
            //给文件中写入helloworld
            bw.write("helloworld");
            //写入换行符
            bw.newLine();
            //刷新缓冲区
            bw.flush();
        }
        //关流
        bw.close();
    }
}

BufferedReader:字符缓冲输入流
构造：BufferedReader(Reader in)
特殊方法：public String readLine():包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。

BufferedWriter:字符缓冲输出流
构造：BufferedWriter(Writer out)
特殊方法：public void newLine():会根据系统来确定写入不同的换行符

package com.edu_06;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        /*需求：使用高效字符输入流读取f.txt文件
         * 1.创建高效字符输入流对象，指向f.txt
         * 2.一次读取一行，readLine()
         * 3.关流  */
        //1.创建高效字符输入流对象，指向f.txt
        //BufferedReader(Reader in) 
        BufferedReader br = new BufferedReader(new FileReader("f.txt"));
        //2.一次读取一行，readLine(),当读取文件末尾的时候返回null
/*      System.out.println(br.readLine());
        System.out.println(br.readLine());
        System.out.println(br.readLine());
        System.out.println(br.readLine());
        System.out.println(br.readLine());
        System.out.println(br.readLine());
        System.out.println(br.readLine());
        System.out.println(br.readLine());
        System.out.println(br.readLine());
        System.out.println(br.readLine());
        System.out.println(br.readLine());
        System.out.println(br.readLine());*/
        //使用循环改进
        String line;
        while ((line= br.readLine())!=null) {
            System.out.println(line);
        }
        //3.关流
        br.close();
    }
}