IO流

标签：操作   缓冲区   文本   一起   版本   size   obj   ade   number   

• 1.概念
  • IO流用来处理设备之间的数据传输
  • Java对数据的操作是通过流的方式
  • Java用于操作流的类都在IO包中
  • 流按流向分为两种：输入流，输出流
  • 流按操作类型分为两种：
    • 字节流 : 字节流可以操作任何数据，因为在计算机中任何数据都是以字节的形式存储的
    • 字符流 : 字符流只能操作纯字符数据，比较方便
• 2.IO流常用父类
  • 字节流的抽象父类：
    • InputStream
    • OutputStream
  • 字符流的抽象父类：
    • Reader
    • Writer
• 3.IO程序书写
  • 使用前，导入IO包中的类
  • 使用时，进行IO异常处理
  • 使用后，释放资源

    read()一次读取一个字节

        FileInputStream fis = new FileInputStream("乌合之众.txt");  
        //创建一个文件输入流对象，并关联乌合之众.txt
        int b;                                                  
        //定义变量，记录每次读到的字节
        while((b = fis.read()) != -1) {                         
        //将每次读到的字节赋值给b并判断是否是-1
            System.out.println(b);                              
            //打印每一个字节
        }
        
        fis.close();                                            
    //关闭流释放资源

     

     

    read()方法返回值为什么是int

    • read()方法读取的是一个字节，为什么返回是int，而不是byte
    • 因为字节输入流可以操作任意类型的文件，比如图片音频等，这些都是以二进制形式的存储的，如果每次读取都返回byte，有可能在读到中间的时候遇到11111111，那么这11111111是byte类型的-1，程序是遇到-1就会停止，后面的数据就读不到了。所以在读取的时候用int类型接收，会在其前面补上24个0凑足4个字节，那么byte类型的-1就变成int类型的255了这样可以保证整个数据读完，而结束标记的-1就是int类型。

    ---

    
    
    

    定义小数组实现缓冲

    • write(byte[] b)

    • write(byte[] b， int off， int len)写出有效的字节个数

    • 定义小数组的标准格式

            FileInputStream fis = new FileInputStream("李志 - 梵高先生.flac");
            FileOutputStream fos = new FileOutputStream("梵高先生.flac");
            int len;
            byte arr[] = new byte[8*1024];
            //自定义字节数组
            while((len=fis.read(arr))!=-1){
                fos.write(arr， 0， len);
                //写出字节数组写出有效个字节个数
            }
            fis.close();
            fos.close();

    ---

    
    
    

    实现了缓冲区的BufferedInputStream和BufferOutputStream

    • BufferedInputStream
      • BufferedInputStream内置了一个缓冲区(数组)
      • 从BufferedInputStream中读取一个字节时，BufferedInputStream会一次性从文件中读取8192个， 存在缓冲区中， 然后返回给程序一个字符。
      • 程序再次读取时， 就不用找文件了， 直接从缓冲区中获取。
      • 直到缓冲区中所有的都被使用过， 才重新从文件中读取8192个
    • BufferedOutputStream
      • BufferedOutputStream也内置了一个缓冲区(数组)
      • 程序向流中写出字节时， 不会直接写到文件， 先写到缓冲区中，
      • 直到缓冲区写满， BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。
    • 组合流过滤器实现拷贝

    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("李志 - 梵高先生.flac"));
            //创建缓冲区对FileInputStream对象的装饰
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("2004-梵高先生.flac"));
            //创建缓冲区对FileOutputStream对象的装饰
    int b;
    while((b = bis.read()) != -1) {     
        bos.write(b);
    }
            
    bis.close();//只关装饰后的对象即可
    bos.close();

    • 小数组的读写和带Buffered的读取哪个更快?
      • 定义小数组如果是8192个字节大小和Buffered比较的话，定义小数组会略胜一筹，因为读和写操作的是同一个数组，而Buffered操作的是两个数组.

    ---

    
    
    

    flush方法和close方法

    • flush()方法
      • 用来刷新缓冲区的，刷新后可以再次写出
    • close()方法
      • 用来关闭流释放资源的的，如果是带缓冲区的流对象的close()方法，不但会关闭流，还会再关闭流之前刷新缓冲区，关闭后不能再写出

    ---

    
    
    

    字节流读写中文

    • 字节流读取中文的问题
      • 字节流在读中文的时候有可能会读到半个中文，造成乱码
    • 字节流写出中文的问题
      • 字节流直接操作的字节，所以写出中文必须将字符串转换成字节数组
      • 写出回车换行 write("\r\n".getBytes());

    ---

    
    
    
    流的标准处理异常代码1.6版本及其以前

    • try finally嵌套

    FileInputStream fis = null;
            FileOutputStream fos = null;
            try {
                fis = new FileInputStream("from.txt");
                fos = new FileOutputStream("to.txt");
                int b;
                while((b = fis.read()) != -1) {
                    fos.write(b);
                }
            } finally {
                try {
                    if(fis != null)
                        fis.close();
                }finally {
                    if(fos != null)
                        fos.close();
                }
            }

    
    
    

    流的标准处理异常代码1.7版本之后

    • try close

    try(
        FileInputStream fis = new FileInputStream("from.txt");
        FileOutputStream fos = new FileOutputStream("to.txt");
    ){
        int b;
        
        while((b = fis.read()) != -1) {
            fos.write(b);
        }
        
    }

    • 在try()中创建的流对象必须实现了AutoCloseable这个接口，如果实现了，在try后面的{. . .}执行后就会自动调用流对象的close方法将流关掉.

    ---

    
    
    

    拷贝文件

    • 在控制台录入文件的路径，将文件拷贝到当前项目下

    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个文件路径");
    String line = sc.nextLine();                //将键盘录入的文件路径存储在line中
    File file = new File(line);                 //封装成File对象
    FileInputStream fis = new FileInputStream(file);
    FileOutputStream fos = new FileOutputStream(file.getName());
    
    int len;
    byte[] arr = new byte[8192];                //定义缓冲区
    while((len = fis.read(arr)) != -1) {
        fos.write(arr，0，len);
    }
    
    fis.close();
    fos.close();

    ---

    
    
    
    录入数据拷贝到文件

    • 将键盘录入的数据拷贝到当前项目下的text.txt文件中，键盘录入数据当遇到quit时就退出

    Scanner sc = new Scanner(System.in);
    FileOutputStream fos = new FileOutputStream("text.txt");
    System.out.println("请输入:");
    while(true) {
        String line = sc.nextLine();
        if("quit".equals(line))
            break;
        fos.write(line.getBytes());
        fos.write("\r\n".getBytes());
    }
    
    fos.close();

    ---

    
    
    
    字符流 FileReader

    • 字符流是什么
      • 字符流是可以直接读写字符的IO流
      • 字符流读取字符， 就要先读取到字节数据， 然后转为字符. 如果要写出字符， 需要把字符转为字节再写出.
    • FileReader
      • FileReader类的read()方法可以按照字符大小读取

     FileReader fr = new FileReader("from.txt"); 
     //创建输入流对象，关联from.txt 
     int ch; 
     while((ch = fr.read()) != -1) { 
     //将读到的字符赋值给ch 
     System.out.println((char)ch); 
     //将读到的字符强转后打印 
     }
    
     fr.close();
     //关流 

    
    
    
    字符流 FileWriter

    • FileWriter类的write()方法可以自动把字符转为字节写出

    FileWriter fw = new FileWriter("to.txt");
    fw.write("write");
    fw.close();

    
    
    
    字符流的拷贝

    FileReader fr = new FileReader("from.txt");
    FileWriter fw = new FileWriter("to.txt");
    
    int ch;
    while((ch = fr.read()) != -1) {
        fw.write(ch);
    }
    
    fr.close();
    fw.close();

    
    
    

    什么情况下使用字符流

    • 字符流也可以拷贝文本文件， 但不推荐使用。因为读取时会把字节转为字符， 写出时还要把字符转回字节。
    • 程序需要读取一段文本， 或者需要写出一段文本的时候可以使用字符流。读取的时候是按照字符的大小读取的，不会出现读取半个中文，造成乱码的情况。写出的时候可以直接将字符串写出，不用转换为字节数组。

    
    字符流是否可以拷贝非纯文本的文件

    • 不可以拷贝非纯文本的文件
      • 因为在读的时候会将字节转换为字符，在转换过程中，可能找不到对应的字符，就会用"?"代替，写出的时候会将"?"字符转换成字节写出去。如此这般，写出之后的文件就错乱了。

    
    
    

    自定义字符数组的拷贝

    FileReader fr = new FileReader("form.txt");          
    //创建字符输入流，关联aaa.txt
    FileWriter fw = new FileWriter("to.txt");          
    //创建字符输出流，关联bbb.txt
    
    int len;
    char[] arr = new char[1024*8];                      
    //创建字符数组
    while((len = fr.read(arr)) != -1) {                 
    //将数据读到字符数组中
        fw.write(arr， 0， len);                          
        //从字符数组将数据写到文件上
    }
    
    fr.close();
    //关流释放资源
    fw.close(); 

    ---

    
    
    
    带缓冲的字符流

    • BufferedReader的read()方法读取字符时会一次读取若干字符到缓冲区， 然后逐个返回给程序， 减少读取次数， 以期提高效率。
    • BufferedWriter的write()方法写出字符时会先写到缓冲区， 缓冲区写满时才会写到文件， 减少写入次数， 以期提高效率。

    BufferedReader br = new BufferedReader(new FileReader("form.txt")); 
    //创建字符输入流对象，关联aaa.txt 
    BufferedWriter bw = new BufferedWriter(new FileWriter("to.txt")); 
    //创建字符输出流对象，关联bbb.txt
    
    int ch;             
    while((ch = br.read()) != -1) {
    //read一次，会先将缓冲区读满，从缓冲去中一个一个的返给临时变量ch
        bw.write(ch);
        //write一次，是将数据装到字符数组，装满后再一起写出去
    }
        
    br.close(); 
    //关流
    bw.close();  
    

    对象操作流ObjecOutputStream

    • 1.什么是对象操作流
      • 该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是序列化和反序列化的操作.
    • 2.使用方式
      • 写出: new ObjectOutputStream(OutputStream)，writeObject()

IO流

标签：操作   缓冲区   文本   一起   版本   size   obj   ade   number   

原文地址：https://www.cnblogs.com/mms912/p/8900654.html