java中IO练习题

蔚落 2022-02-24 04:44 218阅读 0赞

转载链接：[https://www.cnblogs.com/biehongli/p/6074713.html][https_www.cnblogs.com_biehongli_p_6074713.html]

**Java中IO流，输入输出流概述与总结**

1：Java语言定义了许多类专门负责各种方式的输入或者输出，这些类都被放在java.io包中。其中，

所有输入流类都是抽象类InputStream(字节输入流)，或者抽象类Reader(字符输入流)的子类；

而所有输出流都是抽象类OutputStream(字节输出流)或者Writer(字符输出流)的子类。

【首先需要明白的是：流是干什么的？？？（为了永久性的保存数据）

根据数据流向的不同分为输入流和输出流；

根据处理数据类型的不同分为字符流和字节流；

】

【然后需要明白的是输入模式和输出模式是谁流向谁：

InputStream(字节输入流)和Reader(字符输入流)通俗的理解都是读（read）的。

OutputStream(字节输出流)和Writer(字符输出流)通俗的理解都是写(writer)的。

】

最后下面搞清楚各种流的类型的该怎么用，谁包含谁，理清思路。

2：InputStream类是字节输入流的抽象类，是所有字节输入流的父类，InputStream类具有层次结构如下图所示；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70]  
3：java中的字符是Unicode编码的，是双字节的。InputStream是用来处理字节的，在处理字符文本时很不方便。Java为字符文本的输入提供了专门的一套类Reader。Reader类是字符输入流的抽象类，所有字符输入流的实现都是它的子类。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 1]  
4:输出流OutputStream类是字节输入流的抽象类，此抽象类表示输出字节流的所有类的超类。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 2]  
5:Writer类是字符输出流的抽象类，所有字符输出类的实现都是它的子类。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 3]  
6：File类是IO包中唯一代表磁盘文件本身的对象。通过File来创建，删除，重命名文件。File类对象的主要作用就是用来获取文本本身的一些信息。如文本的所在的目录，文件的长度，读写权限等等。（有的需要记忆，比如isFile(),isDirectory(),exits();有的了解即可。使用的时候查看API）

链接：[https://blog.csdn.net/qq\_40303031/article/details/88988094][https_blog.csdn.net_qq_40303031_article_details_88988094]

7：下面以一些字节输入输出流具体的案例操作（操作的时候认清自己使用的是字节流还是字符流）：

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

FileOutputStream的单个字节写入：

package com.ningmeng;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class FileTest { 
    
        public static void main(String[] args) throws Exception{ 
            FileInputStream fis=new FileInputStream("aaa.txt");
            FileOutputStream fos=new FileOutputStream("bbb.txt",true);
            //FileOutputStream()后面加true指文件后面可追加
            
            int a=fis.read();//read()一次读取一个字节
            System.out.println(a);//读取的一个字节输出
            
            fos.write(101);//write()一次写一个字节
            fis.close();//一定记得关闭流，养成好习惯
            fos.close();
        }
    }

FileInputStream和FileOutputStream进行拷贝文本或者图片或者歌曲：

package com.ningmeng;
     2 
     3 import java.io.FileInputStream;
     4 import java.io.FileOutputStream;
     5 
     6 public class FileTest { 
     7 
     8     public static void main(String[] args) throws Exception{ 
     9         FileInputStream fis=new FileInputStream("aaa.txt");
    10         FileOutputStream fos=new FileOutputStream("bbb.txt");
    11         //如果没有bbb.txt,会创建出一个
    12         
    13         int b;
    14         while((b=fis.read())!=-1){ 
    15             fos.write(b);
    16         }
    17         fis.close();
    18         fos.close();
    19     }
    20 }

FileInputStream和FileOutputStream定义小数组进行读写操作：

package com.ningmeng;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class FileTest { 
    
        public static void main(String[] args) throws Exception{ 
            FileInputStream fis = new FileInputStream("aaa.txt");
            FileOutputStream fos = new FileOutputStream("bbb.txt");
            int len;
            byte[] arr = new byte[1024 * 8];//自定义字节数组
            
            while((len = fis.read(arr)) != -1) { 
                //fos.write(arr);
                fos.write(arr, 0, len);//写出字节数组写出有效个字节个数
            }
            //IO流(定义小数组)
            //write(byte[] b)
            //write(byte[] b, int off, int len)写出有效的字节个数
    
            fis.close();
            fos.close();
        }
    }

IO流(BufferedInputStream和BufferOutputStream拷贝)

*  A:缓冲思想  
    　　\* 字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，  
    　　\* 这是加入了数组这样的缓冲区效果，java本身在设计的时候，  
    　　\* 也考虑到了这样的设计思想，所以提供了字节缓冲区流
 *  B.BufferedInputStream  
    　　\* BufferedInputStream内置了一个缓冲区(数组)  
    　　\* 从BufferedInputStream中读取一个字节时  
    　　\* BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个  
    　　\* 程序再次读取时, 就不用找文件了, 直接从缓冲区中获取  
    　　\* 直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个
 *  C.BufferedOutputStream  
    　　\* BufferedOutputStream也内置了一个缓冲区(数组)  
    　　\* 程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中  
    　　\* 直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里

package com.ningmeng;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class FileTest { 
    
        public static void main(String[] args) throws Exception{ 
            FileInputStream fis = new FileInputStream("aaa.txt");
            FileOutputStream fos = new FileOutputStream("bbb.txt");
            
            BufferedInputStream bis=new BufferedInputStream(fis);
            //使用装饰模式，把fis装饰进去bis中。使用缓冲读取速度变快
            BufferedOutputStream bos=new BufferedOutputStream(fos);
            
            int b;
            while((b=bis.read())!=-1){ 
                bos.write(b);
            }
            bis.close();
            bos.close();
        }
    }

面试题：小数组的读写和带Buffered的读取哪个更快?

\* 定义小数组如果是8192个字节大小和Buffered比较的话  
　　\* 定义小数组会略胜一筹,因为读和写操作的是同一个数组  
　　\* 而Buffered操作的是两个数组  
IO流(flush和close方法的区别)  
flush()方法： 用来刷新缓冲区的,刷新后可以再次写出（字节缓冲流内置缓冲区，如果没有读取出来，可以使用flush()刷新来）  
close()方法：用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出  
8：字符流FileReader和FileWriter  
字符流是什么  
　　\* 字符流是可以直接读写字符的IO流  
　　\* 字符流读取字符, 就要先读取到字节数据, 然后转为字符. 如果要写出字符, 需要把字符转为字节再写出.　　　　  
IO流(什么情况下使用字符流)

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

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

*  不可以拷贝非纯文本的文件
 *  因为在读的时候会将字节转换为字符,在转换过程中,可能找不到对应的字符,就会用?代替,写出的时候会将字符转换成字节写出去
 *  如果是?,直接写出,这样写出之后的文件就乱了,看不了了

package com.ningmeng;
    
    import java.io.FileReader;
    import java.io.FileWriter;
    
    public class FileTest { 
    
        public static void main(String[] args) throws Exception{ 
            //FileReader类的read()方法可以按照字符大小读取
            FileReader fr=new FileReader("aaa.txt");
            int b;
            while((b=fr.read())!=-1){ 
                System.out.println((char)b);//int类型转为字符型
            }
            fr.close();
            
            //FileWriter类的write()方法可以自动把字符转为字节写出
            FileWriter fw = new FileWriter("aaa.txt",true);
            fw.write("aaa");
            fw.close();
            
            //字符流的拷贝
            FileReader fr2 = new FileReader("aaa.txt");
            FileWriter fw2 = new FileWriter("bbb.txt");
            
            int ch;
            while((ch = fr2.read()) != -1) { 
                fw2.write(ch);
            }
    
            fr2.close();
            fw2.close();
        }
    }

package com.ningmeng;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    
    public class FileTest { 
    
        public static void main(String[] args) throws Exception{ 
            BufferedReader br=new BufferedReader(new FileReader("aaa.txt"));
            BufferedWriter bw=new BufferedWriter(new FileWriter("bbb.txt"));
            //BufferedReader和BufferedWriter的使用：
            int b;
            while((b=br.read())!=-1){ 
                bw.write((char)b);
            }
            br.close();
            bw.close();
        }
    }

[https_www.cnblogs.com_biehongli_p_6074713.html]: https://www.cnblogs.com/biehongli/p/6074713.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70]: /images/20220224/15481d294f664c1ebd6565fe69f39840.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 1]: /images/20220224/47c63ae242d943669e2a721339287144.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 2]: /images/20220224/286bebefbe744c4cb0fd32bbe60f9895.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 3]: /images/20220224/49d3fcffce7942a4913b90ff53501aab.png
[https_blog.csdn.net_qq_40303031_article_details_88988094]: https://blog.csdn.net/qq_40303031/article/details/88988094