IO流（读写文件）

IO流

字节流
（一次读写一个字节）：使用的多 图片，视频，音频，exe

//主要代码

	//创建一个输入流管道，为其指定输入文件,输入流要求文件存在，否则会报错
		FileInputStream in =new FileInputStream(new File("C:/demo/demo.txt"));
	 //创建输出流管道，为其指定输出的文件，输出文件可以不存在，会自动创建
        FileOutputStream out=new FileOutputStream(new File("D:/demo.txt"));
       //in.read(); 从文件中读取数据， 一次读一个字节，文件内容读完后返回-1
       int b=0;
       while((b=in.read())!=-1){
           out.write(b);
        }
       in.close();
       out.close();//先打开的先关闭

read()与read(byte[] b)的区别

read() 一次只读取一个字节，并返回结果，a-97
read(byte[] b)一次读取byte数组个字节内容，返回数组实际装入的长度，读完返回-1

		FileInputStream in =new FileInputStream(new File("D:/demo.txt"));
		FileOutputStream out=new FileOutputStream(new File("D:/api/demo.txt"));
	 	byte[] b=new byte[10];//10个为一组传送
        int size=0;//实际向数组中读到的内容长度  主要是最后一次的实际数量
        while((size=in.read(b))!=-1){
            //out.write(b)  会把44读成50
            out.write(b,0,size);
            //write(装内容的数组，数组的地0个位置来时，size，实际装入的长度)   最后一次之后4个字节，向外只写4个字节即可
        }
        in.close();
        out.close();

字符流
（一次读写一个字符）：只能读纯文本文件 txt java c

 /*
        字符流可以一次读到一个字符内容
        1个汉字三个字节组成，直接读到
         */
        FileReader reader= new FileReader(new File("D:/demo.txt"));
        FileWriter writer =new FileWriter(new File("D:/demo1.txt"));
//        int c=0;
//        while((c=reader.read())!=-1){
//            writer.write(c);
//        }
 		char[] c=new char[10];
        int size=0;
        while ((size=reader.read(c))!=-1){
            writer.write(c,0,size);
        }
        reader.close();
        writer.close();

节点流与处理流
字节流中的节点流和处理流

 
        //节点流
        FileInputStream in =new FileInputStream(new File("D:/demo.txt"));
        FileOutputStream out=new FileOutputStream(new File("D:/api/demo.txt"));


        //处理流
        BufferedInputStream bin=new BufferedInputStream(in);//经过包装
        BufferedOutputStream bout=new BufferedOutputStream(out);

        byte[] b=new byte[1024];//数组大小看具体情况，，不是越大越好  数组是在内存中存储的
        int size=0;
        while ((size= bin.read(b))!=-1){
            bout.write(b,0,size);//虽然每次都调用write方法  但是不是每次都会真正写出
        }

        /*
        数组长度大于等于内部的缓冲数组，直接写出
        缓冲区不足以放得下读到的新内容时，直接写出数据
        缓冲去区可以放得下，发生数组复制，缓冲区总数量增加
         */
        bin.close();
        bout.flush();//刷新缓冲区
        bout.close();

字符流中的节点流和字符流

 //节点流
        FileReader reader= new FileReader(new File("D:/demo.txt"));
        FileWriter writer =new FileWriter(new File("D:/demo1.txt"));
        //处理流
        BufferedReader breader=new BufferedReader(reader);//经过包装
        BufferedWriter bwriter=new BufferedWriter(writer);

       String line=null;
        while ((line=breader.readLine())!=null){
            //System.out.println(line);
           bwriter.write(line);//一次写出一行字符串
            bwriter.newLine();//换行
        }


        breader.close();
        bwriter.flush();
        bwriter.close();

完整代码（以字节流为例，异常）

public class StreamDemo2 {
    public static void main(String[] args) {
        try {
            testIO();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件找不到");
        } catch (IOException ioe) {
            ioe.printStackTrace();
            System.out.println("读写异常");
        }
    }
    //模拟一个文件的读写操作
    public  static void testIO() throws FileNotFoundException, IOException {

        FileInputStream in=null;
        FileOutputStream out=null;
        try {
            in=new FileInputStream(new File("D:/demo.txt"));
            out=new FileOutputStream(new File("D:/api/demo.txt"));

            int b=0;
            while((b=in.read())!=-1){
                out.write(b);
            }
        } finally {
            if(in!=null){
                in.close();
            }
            if(out!=null){
                out.close();
            }
        }

    }
}