java基础之IO流笔记

流的分类

• 操作数据单位：字节流（操作图片视频文件.jpg.doc.avi.mp4.doc.ppt）复制文本文件时可能会乱码，字符流（文本文件，txt,java,c,c++）
• 数据流的流向：输出流，输入流
• 流的角色：节点流(直接操作文件)，处理流（缓冲流效率高，标准输入输出流，打印流，数据流（特殊流），对象流）

io流体系

InputStreamReader:将一个字的输入流

流体系结构

抽象基类	节点流（文件流）	缓冲流（处理流的一种）
InputStream	FileInputStream	BufferedInputStream
OutputStream	FileOutputStream	BufferedOutputStream
Reader	FilleReader	BufferedReader
Writer	FileWriter	BufferedWriter

简单例子

read()

        FileReader fileReader=new FileReader(new File("a.txt"));
        int data;
        //read();返回读入的一个字符，如果到达文件的末尾返回-1
        while((data=fileReader.read())!=-1){
            System.out.println((char)data);
        }
        fileReader.close();

read(char[] chars),

 FileReader fr=null;
        try{
            File file=new File("a.txt");//a.txt   为：helloworld123
            fr=new FileReader(file);
            char[] chars=new char[5];
            int data;
            //read(char[] chars);返回每次读入数组chars中字符的个数。如果到文件末尾返回-1
            while((data=fr.read(chars))!=-1){
                System.out.print(chars);
                //输出结果helloworld123ld
            }
            fr.close();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if (fr==null)
                    fr.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }

第一次循环

第二次循环

第三次循环：写入chars 3个字符其中123把wor覆盖

正确写法：

while((data=fr.read(chars))!=-1){
//                System.out.print(chars);
                String str =new String(chars,0,data);
                System.out.println(str);
            }

用普通字节流复制a文件的内容到b文件中

        FileInputStream fileInputStream=new FileInputStream("a.txt");
        FileOutputStream fileOutputStream = new FileOutputStream("b.txt");
        int i=0;
        while ((i=fileInputStream.read())!=-1){
            fileOutputStream.write(i);
        }
        fileInputStream.close();
        fileOutputStream.close();

使用高效字符流复制文件

//  a.高效流不能直接对文件进行操作,必须通过普通流操作.高效流是从输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了
//  b.字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的,并且可以使用flush方法强制进行刷新缓冲区
        BufferedReader reader = new BufferedReader(new FileReader("a.txt"));
        BufferedWriter writer = new BufferedWriter(new FileWriter("c.txt"));
        String str = null;
         //readLine使用过在使用该方法就指向下一行
        while ((str=reader.readLine())!=null){                  
            writer.write(str);
            System.out.println(writer.toString());
        }
         reader.close();
        writer.close();

流的关闭

为了保证流资源一定可以执行关闭操作，需要用到try-catch-finally

        FileReader fr=null;
        try{
            File file=new File("a.txt");
            fr=new FileReader(file);
            int data;
            //read();返回读入的一个字符，如果到达文件的末尾返回-1
            while((data=fr.read())!=-1){
                System.out.println((char)data);
            }
            fr.close();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if (fr==null)
                    fr.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }

键盘输入写入文件

 InputStream in =System.in;
        InputStreamReader ir=new InputStreamReader(in);
        BufferedReader bufferedReader=new BufferedReader(ir);
        PrintWriter pw=new PrintWriter(new FileWriter("b.txt",true),true);
        String line=null;
        while((line=bufferedReader.readLine())!=null){
        //输入over结束
            if("over".equals(line)){
                break;
            }
            //PrintWriter启用自动刷新
            pw.println(line);
        }
        pw.close();
        bufferedReader.close();

图片复制

  public void testBuffTest() throws  IOException{
        File srcFile=new File("IO流体系.png");
        File destFile=new File("IO流体系1.png");


            FileInputStream fis=new FileInputStream(srcFile);
            FileOutputStream fos=new FileOutputStream(destFile);

            BufferedInputStream bis=new BufferedInputStream(fis);
            BufferedOutputStream bos =new BufferedOutputStream(fos);

            byte[] buffer=new byte[10];
            int len;
            while ((len=bis.read(buffer))!=-1){
                bos.write(buffer,0,len);
            }
            bis.close();//外层流关闭内存流也关闭
            bos.close();


    }