八： IO流，数据的读写传输

IO流概括图：

IO流的分类：

 按流：

• 输入流(InputStream和Reader)：从硬盘或者别的地方读入内存
• 输出流(OutputStream和Writer)：从内存里向硬盘或别的地方输出

按操作类型：

• 字节流(InputStream和OutputStream)：    字节流可以操作任何数据，因为在计算机中数据以字节的形式存储
• 字符流(Reader和Writer)：字符流只能操作纯字符数据，比如文本，以防乱码

以上所述，InputStream、OutputStream、Reader、Writer都是抽象类

缓冲流：

• BufferedInputStream、BufferedOutputStream
• 优点：BufferedInputStream读取时会创建一个长度为8192的byte数组，读完返回-1。不用自己手动创建数组.

字符转换流：

• InputStreamReader和OutputStreamWriter可以设置编码，完成不同编码文件的转换

绝对路径和相对路径：

• 绝对路径：文件在硬盘上真正存在的路径,比如：D:\Java\HelloWorld.java
• 相对路径：只某个文件路径径和别的文件的路径关系 。

使用分隔符解决跨平台的问题：

• 使用File.separator解决不同系统路径问题
• 分隔符：    windows: \
• linux : /
• 为了保证代码跨平台，使用File.separator代替分隔符

文件加密和解密：利用两次异或的原理

中文乱码问题： 一个中文占两个字节，如果一次读写入奇数个字节，就有可能乱码，这时候推荐使用字符流解决，一次读一行

字符流读写文件：一次读一行，记得换行bw.newLine()、刷新缓冲区bw.flush()

Code：

• test() ：使用FileInputStream、FileOutputStream读取、写入文件中的内容
• test2()：使用Buffered缓冲流进行文件拷贝
• test3()：文件加密解密，利用两次异或
• test4()：使用字节流读取文件乱码问题(一个中文占两个字节)
• test5()：对乱码问题给出了解决，可使用字符流Writer、Reader
• test6()：使用字符流拷贝文本文件
• test7()：使用转换流解决不同文件编码问题
• test8()：使用转换流解决不同文件编码问题，乱码解决

package io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.net.URL;

import org.junit.Test;

public class IODemo {
    //定义加密code
    static int code = 88;
    //定义文件路径
    static String fileName = "C:"+File.separator+"Users"+File.separator+"李腾"+File.separator+"Desktop"+File.separator+"写入文件.txt";
    static String readName = "C:"+File.separator+"Users"+File.separator+"李腾"+File.separator+"Desktop"+File.separator+"读取文件.txt";

  //使用FileInputStream、FileOutputStream读取、写入文件中的内容
   @Test
   public void test(){
       FileInputStream fis = null;
       FileOutputStream fos = null;
       //绝对路径
       String readFile = "D:"+File.separator+"mylog.log";
       String writeFile = "D:"+File.separator+"newWrite.txt";
   try {
        fos = new FileOutputStream(writeFile,true);
        fis = new FileInputStream(readFile);
        //定义字节数组接收信息
        byte[] bytes = new byte[6000];
        int temp;
        while((temp = fis.read(bytes))!=-1){
            fos.write(temp);
            //刷新并写出所有缓冲字节
            fos.flush();
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            fos.close();
            fis.close();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
   }
   //使用Buffered缓冲流进行文件拷贝
   @Test
   public void test2(){
       BufferedInputStream bis = null;
       BufferedOutputStream bos = null;
       try {
        bis = new BufferedInputStream(new FileInputStream("D:"+File.separator+"mylog.log"));
        bos = new BufferedOutputStream(new FileOutputStream("D:"+File.separator+"buf.txt"));
        int temp;
        while((temp=bis.read())!=-1){
            bos.write(temp);
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }finally{
        try {
            bis.close();
            bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
   }
   //文件加密解密，利用两次异或
   //JDK7新特性，系统自动close
   @Test
   public void test3(){
       BufferedOutputStream bos = null;
       BufferedInputStream bis = null;
       //加密
       try {
        bis = new BufferedInputStream(new FileInputStream("D:"+File.separator+"IO流.rar"));
        bos = new BufferedOutputStream(new FileOutputStream("D:"+File.separator+"加密.rar"));
        int temp;
        while((temp=bis.read())!=-1){
            bos.write(temp^code);
            bos.flush();
        }
       } catch (IOException e) {
        e.printStackTrace();
    }
       //解密
       try {
           bis = new BufferedInputStream(new FileInputStream("D:"+File.separator+"加密.rar"));
           bos = new BufferedOutputStream(new FileOutputStream("D:"+File.separator+"解密.rar"));
           int temp;
           while((temp=bis.read())!=-1){
               bos.write(temp^code);
               bos.flush();
           }
       } catch (IOException e) {
           e.printStackTrace();
       }
   }

   //使用字节流读取文件乱码问题(一个中文占两个字节)
   //test5对乱码问题给出了解决，可使用字符流Writer、Reader
   @Test
   public void test4(){
       FileOutputStream fos = null;
       FileInputStream fis = null;
       String msg = "好好";
       try {
        fos = new FileOutputStream(fileName);
        fis = new FileInputStream(readName);
        int temp;
        //每次读三个字节，也乱码
        byte[] arr = new byte[3];
        //每次写三个字节，因为中文占两，所以乱码
        fos.write(msg.getBytes(),0,3);
        //换行
        fos.write("\r\n".getBytes());
        fos.flush();
        while((temp=fis.read(arr))!=-1){
            System.out.println(new String(arr,0,temp));
        }

    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
   }

  /* 用字符流解决中文乱码问题
   * BufferdReader可以一次读一行文字,readLine方法返回null
   * */
   @Test
   public void test5(){
       BufferedReader buf = null;
       FileWriter fw = null;
       BufferedWriter bw = null;
       try {
        buf = new BufferedReader(new FileReader(readName));
        String s;
        //写
        bw = new BufferedWriter(new FileWriter(fileName));
        bw.write("我喜欢学习java");
        bw.write(97);
        bw.flush();
        fw = new FileWriter(fileName);
        fw.write("FileWriter写入");
        fw.flush();
        //读
        while((s = buf.readLine())!=null){
//            bw.write(s);
            System.out.print(s);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
   }

   //使用字符流拷贝文本文件
    @Test
    public void test6(){
        BufferedReader br = null;
        BufferedWriter bw = null;

        try {
            br = new BufferedReader(new FileReader(readName));
            bw = new BufferedWriter(new FileWriter(fileName));
            String s ;
            while((s=br.readLine())!=null){
                //读一行
                bw.write(s);
                //读完换行
                bw.newLine();
                bw.flush();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    //使用转换流解决不同文件编码问题
    //字符流乱码
    @Test
    public void test7(){
        try(
            //将utf-8的内容写出到GBK.txt中,发现乱码
            BufferedReader br=
            new BufferedReader(new FileReader("D:\\JAVA基础\\7.15\\1javaSe\\file\\utf-8.txt"));
            BufferedWriter bw=
            new BufferedWriter(new FileWriter("D:\\JAVA基础\\7.15\\1javaSe\\file\\GBK.txt"));
            ){
            String msg;
            while((msg=br.readLine())!=null){
                bw.write(msg);
            }
            bw.flush();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    //使用转换流解决不同文件编码问题，乱码解决
    @Test
    public void test8(){
        try(
        BufferedReader br =
        new BufferedReader(new InputStreamReader(new FileInputStream("D:\\JAVA基础\\7.15\\1javaSe\\file\\utf-8.txt"), "utf-8"));
        BufferedWriter bw =
        new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\JAVA基础\\7.15\\1javaSe\\file\\GBK.txt"),"GBK"));

            ){
            String msg;
            while((msg=br.readLine())!=null){
                bw.write(msg);
            }
            bw.flush();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}