Java---使用IO流进行数据的传输

字符流

字符流只能读写文本文件，其他类型的文件读写不了

字符输出流

• OutputStreamWriter(OutputStream out)
  OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

public class MyTest4 {
    public static void main(String[] args) throws IOException {
    //使用默认编码
	OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("a.txt"));
	out.write('a');//一次写入一个字符
	out.flush();//注意：字符流要刷新一下，才会将缓存中的数据，写入到硬盘
	out.close;


        //OutputStreamWriter(OutputStream out, String charsetName)
        //创建使用指定字符集的 OutputStreamWriter。
        //参数2 可以指定编码表
        OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("c.txt"),"UTF-8");
        writer.write("你是不是我最疼爱的人，你为什么不说话");
        writer.flush();
        writer.close();
    }
}

- 字符流的5种写数据的方式
public void write(int c) 写一个字符
public void write(char[] cbuf) 写一个字符数组
public void write(char[] cbuf,int off,int len) 写一个字符数组的 一部分
public void write(String str) 写一个字符串
public void write(String str,int off,int len) 写一个字符串的一部分

public class MyTest2 {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("b.txt"));
        writer.write('a');//一次写入一个字符
	 writert.flush();//注意：字符流要刷新一下，才会将缓存中的数据，写入到硬盘

        //一次写入一个字符串
        writer.write("你好中国");
        writer.write("\r\n");

        //一次写入一个字符串的一部分
        writer.write("你好中国",0,2);
        writer.flush();

        //一次写人一个字符数组
	writer.write(new char[]{'你','a','b'});
	writer.write("\r\n");

	//一次写入字符数组的一部分
	writer.write(new char[]{'你', 'a', 'b'},0,1);
	writer.write("\r\n");
	writer.flush();

	        writer.close();
    }
}

字符输入流

• 字符流的2种读数据的方式
  public int read() 一次读取一个字符
  public int read(char[] cbuf) 一次读取一个字符数组 如果没有读到 返回-1

public class MyTest {
    public static void main(String[] args) throws IOException {
        //输入流所关联的文件，如果没找到就报错
        InputStreamReader in = new InputStreamReader(new FileInputStream("b.txt"));
        int read = in.read(); //一次读取一个字符
        System.out.println((char)read);
        system.out.println(read);//读取不到返回 -1 这个返回值可以判断文件是否读取完了

	 char[] chars = new char[1000];
	  //一次读取一个字符数组
	  int len = in.read(chars); //返回值是读取到的有效的字符个数
	  //一次读取一个字符数组的一部分
	//  int len = in.read(chars,0,522); //返回值是读取到的有效的字符个数
	  System.out.println(len);
	  for (char cha : chars) {
	      System.out.println(char);
	  }

	        in.close();


    }
}

• 将一个字符串转换成字节数组

public class MyTest {
    public static void main(String[] args) throws UnsupportedEncodingException {


        //将一个字符串转换成字节数组
        //编码：把看的懂，转成看不懂的
        //解码：把看不懂，转成看的懂得
        //乱码产生的原因：编解码使用的不是同一个码表

        //byte[] getBytes ()
        //使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
        //byte[] getBytes (Charset charset)
        //使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。

        byte[] bytes = "你好中国".getBytes("UTF-8");
        System.out.println(bytes);

        //将一个字节数组，转换成字符串
        //String( byte[] bytes)
        //通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
        //String( byte[] bytes, Charset charset)
        //通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。

        String s = new String(bytes, "UTF-8");
        System.out.println(s);

      }
}

FileWriter和FileReader复制文本文件

，

1. FileReader和FileWriter的出现 转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的所以，为了简化我们的书写，转换流提供了对应的子类。
   转换流 ------------------------- 便捷类
   OutputStreamWriter ------- FileWriter
   InputStreamReader ------- FileReader

public class MyTest {
    public static void main(String[] args) throws IOException {
             FileReader fileReader = new FileReader("MyTest.java");
       FileWriter fileWriter = new FileWriter("E:\\MyTest2.java");
        int len = 0;
        char[] chars = new char[1024];
        while ((len = fileReader.read(chars)) != -1) {
            fileWriter.write(chars, 0, len);
            fileWriter.flush();
            for (char c : chars) {
                System.out.println(c);
            }
        }

        fileReader.close();
       fileWriter.close();


    }
}

高效字符流

// BufferedWriter
// BufferedReader

public class MyTest {
    public static void main(String[] args) throws IOException {
        //高效的字符流
       // BufferedWriter
       // BufferedReader
        BufferedReader in = new BufferedReader(new FileReader("MyTest.java"));
        BufferedWriter out = new BufferedWriter(new FileWriter("E:\\MyTest3.java"));
        int len = 0;
        char[] chars = new char[1024];
        while ((len = in.read(chars)) != -1) {
            out.write(chars, 0, len);
            out.flush();
        }
        //释放资源
        in.close();
        out.close();
    }
}

• 高效字符流里面的特有方法

1. BufferedReader 里面有一个特有的方法 String readLine () 一次取一行文本
2. BufferedWriter 里面有一个特有的方法 void newLine () 写入一个换行符，具有平台兼容性

public class MyTest2 {
    public static void main(String[] args) throws IOException {

        //BufferedReader 里面有一个特有的方法    String readLine () 一次取一行文本

        BufferedReader in = new BufferedReader(new FileReader("MyTest.java"));

        //BufferedWriter 里面有一个特有的方法 void newLine () 写入一个换行符，具有平台兼容性
        BufferedWriter out = new BufferedWriter(new FileWriter("E:\\MyTest4.java"));

        //采用读取一行写人一行来复制文件
        String line = null;
        while ((line = in.readLine()) != null) { //读取不到返回 null
            out.write(line);
            out.newLine();
            out.flush();
        }
        in.close();
        out.close();
    }
}