Java IO流与文件操作详解-优快云博客

本文详细介绍了Java中的File类，包括创建、删除、重命名、判断文件属性等操作。接着讲解了IO流的基本概念，如字节流、字符流、输入流、输出流、节点流和处理流，并通过示例展示了FileReader、FileWriter、FileInputStream和FileOutputStream的使用。此外，还涉及到了缓冲流、转换流和对象流的应用，如文件复制、字符编码转换和对象的序列化与反序列化。最后讨论了RandomAccessFile的使用，包括数据的读写和插入操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

IO流

1.File类

1.File类的使用

/*
File类的使用
1. File类的一个对象，代表一个文件或一个文件目录(俗称:文件夹)
2. File类声明在java.io包下
3. File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，
并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用Io流来完成。4．后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点".

 */

2.File类的创建

/*
1.如何创建File类的实例:
三种方式：
File(String filepath)
FiLe(String parentPath,String chiLdPath)
File(File parentFile, String childPath)

2.路径
相对路径:相较于某个路径下，指明的路径。
绝对路径:包含盘符在内的文件或文件目录的路径（show in explore）

3.路径分隔符:
      windows : \
      unix: /
 */

    @Test
    public  void test1(){
        //创建File类的实例:
        //构造器一：
        File file1=new File ("1.text");//相对路径：这里是指在在module下
        File file2=new File ("C:\\Users\\86173\\IdeaProjects\\os\\collection\\src");//绝对路径
        System.out.println (file1); //1.text
        System.out.println (file2);//C:\Users\86173\IdeaProjects\os\collection\src


        //构造器二：
        File file3=new File ("C:\\Users\\86173\\IdeaProjects","os");
        System.out.println (file3);//C:\Users\86173\IdeaProjects\os

        //构造器三：
        File file4=new File (file3,"1.text");
        System.out.println (file4);//C:\Users\86173\IdeaProjects\os\1.text

    }

3.File类的常用方法

1.获取功能

public String getAbsolutePath()	获取绝对路径
public String getPath()	获取路径
public String getName()	获取名称
public String getParent()	获取上层文件目录路径。若无，返回null
public long length()	获取文件长度（即:字节数)。不能获取目录的长度。
public long lastModified()	获取最后一次的修改时间，毫秒值
如下的两个方法适用于文件目录	———————————————————————
public String[] list()	获取指定目录下的所有文件或者文件目录的名称数组
public File[]listFiles()	获取指定目录下的所有文件或者文件目录的File数组


@Test
    public  void test2(){
    File file1=new File ("Hi.txt");//此时目录下有存在的文件
    File file2=new File ("E:\\Text");
    System.out.println (file1.getAbsolutePath ());
    System.out.println (file1.getPath ());
    System.out.println (file1.getName ());
    System.out.println (file1.getParent ());
    System.out.println (file1.length ());
    System.out.println (new Date (file1.lastModified ()));
    //C:\Users\86173\IdeaProjects\os\collection\Hi.txt
    //Hi.txt
    //Hi.txt
    //null
    //15
    //Thu Feb 10 15:44:20 CST 2022
    System.out.println ("***************");
    System.out.println (file2.getAbsolutePath ());
    System.out.println (file2.getPath ());
    System.out.println (file2.getName ());
    System.out.println (file2.getParent ());
    System.out.println (file2.length ());
    System.out.println (new Date (file2.lastModified ()));
    //E:\Text
    //E:\Text
    //Text
    //E:\
    //0
    //Thu Feb 10 15:32:51 CST 2022
}


    @Test
    public  void test3(){
    File file=new File("E:\\学习\\自学笔记");
        String[] list = file.list ();
        for (String s:list
             ) {
            System.out.println (s);
        }
        System.out.println ("**********************************");
        File[] files = file.listFiles ();
        for (File f:files
             ) {
            System.out.println (f);
        }
    }

2.重命名功能

public boolean renameTo(File dest)	把文件重命名为指定的文件路径

/*
重命名功能
注意：比如: file1.renameTo(file2)为例:
       要想保证返回true,需要file1在硬盘中是存在的，且file2不能在硬盘中存在。
 */
@Test
    public  void test4(){
    File file1=new File("Hi.txt");
    File file2=new File ("E:\\Text\\Hello.txt");
    boolean b = file1.renameTo (file2);
    System.out.println (b);
}

3.判断功能

public boolean isDirectory()	判断是否是文件目录
public boolean isFile()	判断是否是文件
public boolean exists()	判断是否存在
public boolean canRead()	判断是否可读
public boolean canWrite()	判断是否可写
public boolean isHidden()	判断是否隐藏

/*
File类的判断功能
 */
@Test
    public  void test5(){
File file=new File("Hello.txt");//文本内容：Hi,nice to meet you!
    System.out.println (file.isDirectory ());
    System.out.println (file.isFile ());
    System.out.println (file.exists ());
    System.out.println (file.canRead ());
    System.out.println (file.canWrite ());
    System.out.println (file.isHidden ());
    //false
    //true
    //true
    //true
    //true
    //false
}

4.创建和删除功能

创建：
public boolean createNewFile()	创建文件。若文件存在，则不创建，返回false
public boolean mkdir()	创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
public boolean mkdirs()	创建文件目录。如果上层文件目录不存在，一并创建
——————————	——————————————————————————————————
删除：
public boolean delete()	删除文件或者文件夹

/*
File类的创建功能
注意事项:如果你创建文件或者文件目录没有写盘符路径，那么，默认在项目路径下。

File类的删除功能
删除注意事项:
Java中的删除不走回收站。
要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录
 */
@Test
    public  void test7() throws IOException {
    File file1=new File ("E:\\Text\\test1");
    if(!file1.exists ()){
    //文件不存在，则进行创建
        file1.createNewFile ();
        System.out.println ("创建成功");
    }else{
    //文件存在，则进行删除
        file1.delete ();
        System.out.println ("删除成功");
    }

}
@Test
public  void test8(){
    File file=new File ("E:\\Text\\test");
    boolean mkdir = file.mkdir ();
    System.out.println (mkdir);
    boolean mkdirs = file.mkdirs ();
    System.out.println (mkdirs);
    System.out.println ("******************");

    File file1=new File ("E:\\Text\\test1\\IOFile");
    boolean mkdir1 = file1.mkdir ();
    System.out.println (mkdir1);
    boolean mkdirs1 = file1.mkdirs ();
    System.out.println (mkdirs1);
}

2.IO流原理及流的分类

1.流的分类

流的分类:
1.操作数据单位: 字节流、字符流
2.数据的流向: 输入流、输出流
3.流的角色: 节点流、处理流

在这里插入图片描述

2.流的体系结构

抽象基类	节点流（或文件流）	缓冲流（处理流的一种）
InputStream	FileInputStream (read(byte[] buffer))	BufferedInputStream (read(byte[] buffer))
OutputStream	FileOutputStream (write(byte[] buffer,0,len))	BufferedOutputStream (write(byte[] buffer,0,len)) / flush()
Reader	FileReader (read(char[] cbuf))	BufferedReader (read(char[] cbuf))
Writer	FileWriter (write(char[] cbuf,0,len))	BufferedWriter (write(char[] cbuf,0,len)) /flush()

3.***节点流（文件流）

1.FileReader读入数据

read()基本操作

/*
将hello.txt文件内容读入程序中，并输出到控制台说明点:
1. read( )的理解:返回读入的一个字符。如果达到文件末尾，返回-1
2．异常的处理:为了保证流资源一定可以执行关闭操作。需要使用try-catch-final处理
3．读入的文件一定要存在，否则就会报FiLeNotFoundException。
 */

    @Test
    public  void test1(){
        FileReader fr= null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file =new File ("Hello.txt");
            //2.提供具体的流
            fr = new FileReader (file);
            //3.数据的读入
            // read( )的理解:返回读入的一个字符。如果达到文件末尾，返回-1
            int i = fr.read ();
            while (i!=-1){
                System.out.print ((char) i);
                i=fr.read ();
            }
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
        }
        //4.流的关闭：
        if(fr!=null){
            try {
                fr.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            } finally {
            }
        }
    }

使用read(char[] cbuf )

 /*
read(char[] cbuf):返回每次读入cbuf数组中的字符的个数如果达到文件末尾，返回-1
 */
 @Test
 public  void test2(){
     FileReader  fr = null;

     try {
         //1.实例化File类的对象，指明要操作的文件
         File file =new File ("Hello.txt");
         //2.提供具体的流
         fr = new FileReader (file);
         //3.数据的读入
         //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数如果达到文件末尾，返回-1
         char[] cbuf=new char[5];//每5个读一次，相较于之前一次读一个更好
         int len;
         while((len= fr.read (cbuf))!=-1){
     //写法一：
     //错误写法：
             //HiNiceToMeetYouTooou
//             for (int i = 0; i <cbuf.length ; i++) {
//                 System.out.print (cbuf[i]);
//             }
     //正确写法：
             //注意这里应该读到len
//             for (int i = 0; i <len ; i++) {
//                 System.out.print (cbuf[i]);
//             }
       //写法二：
       //错误写法：
             //HiNiceToMeetYouTooou
//             String str=new String (cbuf);
//             System.out.print (str);
     //正确写法：
//             String str=new String (cbuf,0,len);
//             System.out.print (str);

         }
     } catch (IOException e) {
         e.printStackTrace ();
     } finally {
     //4.流的关闭：
         if(fr!=null){
             try {
                 fr.close ();
             } catch (IOException e) {
                 e.printStackTrace ();
             }

         }
     }

 }

2.FileWriter写出数据

/*
从内存中写出数据到硬盘的文件里。
说明:
1．输出操作，对应的File可以不存在的。并不会报异常
2.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
  FiLe对应的硬盘中的文件如果存在:
       如果流使用的构造器是:FileWriter(file,false) / FileWriter(file):
            则会覆盖原文件。
       如果流使用的构造器是:FileWriter(file,true):
            不会对原有文件覆盖，而是在源文件的基础上，向后继续添加

 */
@Test
    public void test()  {
        FileWriter fw= null;
        try {
            File file=new File ("Hello1.txt");
            fw = new FileWriter (file,false);
            fw.write ("Happy New Year\n ");
            fw.write ("I am proud of you");
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            try {
                if(fw!=null){
                    fw.close (); 
                }
   
            } catch (IOException e) {
                e.printStackTrace ();
            } finally {
            }
        }
    }

3.混合使用实现文本文件的复制

 /*
使用FileReader和FileWriter实现文本文件的复制
 */
@Test
    public  void test()  {
        FileReader fr= null;
        FileWriter fw= null;
        try {
            File file=new File ("Hello1.txt");
            fr = new FileReader (file);
            fw = new FileWriter ("Hello2.txt");
            char[] sbuf=new char[5];
            int len;
            while((len=fr.read (sbuf))!=-1){
                fw.write (sbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            if(fr!=null){
                try {
                    fr.close ();
                } catch (IOException e) {
                    e.printStackTrace ();
                } finally {
                }
            }
            if(fw!=null){
                try {
                    fw.close ();
                } catch (IOException e) {
                    e.printStackTrace ();
                } finally {
                }
            }
        }

    }

4. 混合使用读非文本文件

/*
使用FileInputStream和FileOutputStream读非文本文件
结论:
1、对于文本文件(.txt..java,.c,.cpp)，使用字符流处理
2.对于非文本文件(.jpg ,.mp3 ,.mp4 ,.avi,.doc ,.ppt, ...),使用字节流处理
3.使用字节流FileInputStream处理文本文件，可能出现乱码。
 */
@Test
    public  void test()  {
        FileInputStream fis= null;
        FileOutputStream fos= null;
        try {
            //1.new File读取文件
            File file1=new File ("MVC+Dao.png");
            File file2=new File ("MVC+Dao222.png");
            //2.new FileInputStream和FileOutputStream读非文本文件
            fis = new FileInputStream (file1);
            fos = new FileOutputStream (file2);

            //3.读入和写出
            byte[] buffer=new byte[5];
            int len;
            while((len=fis.read (buffer))!=-1){
                  fos.write (buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
        //4.流的关闭
            try {
                if(fis!=null){
                fis.close ();
                }
            } catch (IOException e) {
                e.printStackTrace ();
            } finally {
                try {
                    if(fos!=null){
                    fos.close ();
                    }
                } catch (IOException e) {
                    e.printStackTrace ();
                } finally {
                }
            }
        }
    }

4.***处理流之一：缓冲流

1.字节型实现非文本文件的复制

包括：BufferedInputStream、BufferedOutputStream、BufferedReader、Bufferedwriter

作用:提供流的读取、写入的速度
提高读写速度的原因:内部提供了一个缓冲区

处理流，就是套接”在已有的流的基础上。

    @Test
   public void test2()  {
        long start=System.currentTimeMillis ();
    String src="MVC+Dao.png";
    String desc="MVC+Dao666.png";
    TimeTest1 (src,desc);
     long end=System.currentTimeMillis ();
     System.out.println ("字节型花费的时间为："+(end-start));
    }
    //缓冲流：
    public  void TimeTest1(String src,String desc){
        BufferedInputStream bis= null;
        BufferedOutputStream bos= null;
        try {
            //1.造文件
            File file1=new File(src);
            File file2=new File(desc);

            //2.造流
            //1.造字节流
            FileInputStream fis=new FileInputStream (file1);
            FileOutputStream fos=new FileOutputStream (file2);
            //2.造缓冲流
            bis = new BufferedInputStream (fis);
            bos = new BufferedOutputStream (fos);
            //3.复制过程
            byte[] buffer=new byte[5];
            int len;
            while((len=bis.read (buffer))!=-1){
                bos.write (buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            //4.资源关闭
            //要求：先关大的，再关小的

            try {
                if(bis!=null){
                    bis.close ();
                }if(bos!=null){
                    bos.close ();
                }
            } catch (IOException e) {
                e.printStackTrace ();
            } finally {
            }
            //说明：关了大的之后，小的会自动关闭
//        fis.close ();
//        fos.close ();
        }
    }

2.字符型实现文本文件的复制

@Test
public void test2()  {
    long start=System.currentTimeMillis ();
    String src="Hello.txt";
    String desc="Hello999.txt";
    TimeTest1 (src,desc);
    long end=System.currentTimeMillis ();
    System.out.println ("字符型花费的时间为："+(end-start));
}
    //缓冲流：
    public  void TimeTest1(String src,String desc) {
        BufferedReader  bis = null;
        BufferedWriter    bos = null;

        try {
            //1.造文件
            File file1=new File(src);
            File file2=new File(desc);

            //2.造流
            //1.造字节流
            FileReader fis=new FileReader (file1);
            FileWriter fos=new FileWriter (file2);
            //2.造缓冲流
            bis = new BufferedReader (fis);
            bos = new BufferedWriter (fos);
            //3.复制过程
            char[] buffer=new char[5];
            int len;
            while((len=bis.read (buffer))!=-1){
                bos.write (buffer,0,len);
                 bos.flush ();
            }
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
        //4.资源关闭
            //要求：先关大的，再关小的
                if(bis!=null){
                    try {
                        bis.close ();
                        bos.close ();
                    } catch (IOException e) {
                        e.printStackTrace ();
                    } finally {
                }
            //说明：关了大的之后，小的会自动关闭
//        fis.close ();
//        fos.close ();
                    }
        }
    }

3.练习题：图片的加密和解密

在这里插入图片描述

    //加密
    @Test
    public  void test()  {
        FileInputStream fis= null;
        FileOutputStream fos= null;
        try {
            fis = new FileInputStream (new File ("MVC+Dao.png"));
            fos = new FileOutputStream (new File ("MVC+DaoSecret.png"));
            byte[] buffer=new byte[5];
            int len;
            while((len=fis.read (buffer))!=-1){
                //对图片进行加密：
                for (int i = 0; i <len ; i++) {
                    buffer[i]= (byte) (buffer[i]^5);
                }
                fos.write (buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            try {
                if(fis!=null){
            fis.close ();

                }
                if(fos!=null){
            fos.close ();

                }
            } catch (IOException e) {
                e.printStackTrace ();
            } finally {
            }
        }

    }
    //解密：
    @Test
    public  void test2()  {
        FileInputStream fis= null;
        FileOutputStream fos= null;
        try {
            fis = new FileInputStream (new File ("MVC+DaoSecret.png"));
            fos = new FileOutputStream (new File ("MVC+Dao999.png"));
            byte[] buffer=new byte[5];
            int len;
            while((len=fis.read (buffer))!=-1){
                //对图片进行解密：
                for (int i = 0; i <len ; i++) {
                    buffer[i]= (byte) (buffer[i]^5);
                }
                fos.write (buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            try {
                if(fis!=null){
                    fis.close ();

                }
                if(fos!=null){
                    fos.close ();

                }
            } catch (IOException e) {
                e.printStackTrace ();
            } finally {
            }
        }

    }

5.***处理流之二：转换流


/*
处理流之二:转换流的使用
1.转换流:属于字符流
         InputStreamReader:将一个字节的输入流转换为字符的输入流
         OutputStreamWriter:将一个字符的输出流转换为字节的输出流
2.作用:提供字节流与字符流之间的转换
3．解码:字节、字节数组--->字符数组、字符串
   编码:字符数组、字符串--->字节、字节数组
4.字符集
ASCII:美国标准信息交换码。     用一个字节的7位可以表示。
IS08859-1:拉丁码表。欧洲码表,  用一个字节的8位表示。
GB2312:中国的中文编码表。      最多两个字节编码所有字符
GBK:中国的中文编码表升级，融合了更多的中文文字符号。    最多两个字节编码
Unicode:国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
UTF-8:变长的编码方式，可用1-4个字节来表示一个字符。


 */

1.InputStreamReader实现字节的输入流到字符的输入流

    @Test
    public  void test() throws IOException {
        FileInputStream fis=new FileInputStream ("Hello.txt");
//        InputStreamReader isr=new InputStreamReader (fis);//是指使用默认的字符集
        InputStreamReader isr=new InputStreamReader (fis,"UTF-8");//是指使用文件需要的字符集
        char[] buffer=new char[5];
        int len;
        while ((len=isr.read (buffer))!=-1){
            String s = new String (buffer, 0, len);
            System.out.print (s);

        }

    }

2.转换流实现文件的读入和写出

   //转换流实现文件的读入和写出：
    @Test
    public  void test2()  {
        FileInputStream fis= null;
        InputStreamReader isr= null;
        FileOutputStream fos= null;
        OutputStreamWriter osw= null;
        try {
            fis = new FileInputStream ("Hello.txt");
            isr = new InputStreamReader (fis);

            fos = new FileOutputStream ("gbk.txt");
            osw = new OutputStreamWriter (fos,"gbk");

            char[] buffer=new char[5];
            int len;
            while ((len=isr.read (buffer))!=-1){
                osw.write (buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {

            try {
                if(osw!=null){
                osw.close ();
                }if(fos!=null){
                fos.close ();
                }
            } catch (IOException e) {
                e.printStackTrace ();
            } finally {
                try {
                    if(isr!=null){
                    isr.close ();
                    }if(fis!=null){
                    fis.close ();
                    }
                } catch (IOException e) {
                    e.printStackTrace ();
                } finally {
                }
            }

        }
    }

6.***对象流

***1.对象流的使用

/*
对象流的使用
1.ObjectInputStream 和ObjectOutPutStream
2.作用：用于存储和读取基木数据类型数据或对象的处理流。
它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来.
3.要想一个java对象是可序列化的，需要满足相应的要求。见4中的Per
son.java

*/

2.对象序列化机制:

允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。ll当其它程序获取了这种二进制流，就可以恢复成原来的Java对象

3.对象流序列化与反序列化字符串操作:

   
    /*
    序列化过程:将内存中的java对象保存到磁盘中或通过网络传输出去
                使用ObjectOutputStream实现
     */
    @Test
    public  void test1()  {
        ObjectOutputStream oos= null;
        try {
            oos = new ObjectOutputStream (new FileOutputStream ("lalala.date"));

            oos.writeObject (new String ("北京欢迎您"));
            oos.flush();//刷新操作
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            if(oos!=null){
                try {
                    oos.close ();
                } catch (IOException e) {
                    e.printStackTrace ();
                } finally {
                }
            }
        }



    }
    /*
    反序列化:将磁盘文件中的对象还原为内存中的一个java对象使用ObjectInputStream来实现
     */
    @Test
    public  void test2(){
        ObjectInputStream ois= null;
        try {
            ois = new ObjectInputStream (new FileInputStream ("lalala.date"));
            Object o = ois.readObject ();
            System.out.println (o);
        } catch (IOException e) {
            e.printStackTrace ();
        } catch (ClassNotFoundException e) {
            e.printStackTrace ();
        } finally {
            if(ois!=null){
                try {
                    ois.close ();
                } catch (IOException e) {
                    e.printStackTrace ();
                } finally {
                }

            }
        }
    }

4.自定义类实现序列化与反序列化操作

package io;

import java.io.Serializable;

/*
Person需要满足如下的要求，方可序列化
1.需要实现接口: Serializable
2.当前类提供一个全局常量: serialVersionUID ( public  static  final long )
3.除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的。（默认情况下，基本数据类型可序列化)

补充：ObjectOutputStream和ObjectInputStream不能序列化static利transient修饰的成员变量

 */
public class Person implements Serializable {
    public  static  final long serivalVersionUID=23456L;
   private String name;
    private  int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}

   /*
    序列化过程:将内存中的java对象保存到磁盘中或通过网络传输出去
                使用ObjectOutputStream实现
     */
    @Test
    public  void test1()  {
        ObjectOutputStream oos= null;
        try {
            oos = new ObjectOutputStream (new FileOutputStream ("lalala.date"));

            oos.writeObject (new String ("北京欢迎您"));
            oos.flush();//刷新操作
            
            oos.writeObject (new Person ("霸王花",18));
            oos.flush ();
            
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            if(oos!=null){
                try {
                    oos.close ();
                } catch (IOException e) {
                    e.printStackTrace ();
                } finally {
                }
            }
        }



    }
    /*
    反序列化:将磁盘文件中的对象还原为内存中的一个java对象使用ObjectInputStream来实现
     */
    @Test
    public  void test2(){
        ObjectInputStream ois= null;
        try {
            ois = new ObjectInputStream (new FileInputStream ("lalala.date"));
            Object o = ois.readObject ();

            Person p = (Person) ois.readObject ();
            System.out.println (o);
            System.out.println (p);
        } catch (IOException e) {
            e.printStackTrace ();
        } catch (ClassNotFoundException e) {
            e.printStackTrace ();
        } finally {
            if(ois!=null){
                try {
                    ois.close ();
                } catch (IOException e) {
                    e.printStackTrace ();
                } finally {
                }

            }
        }
    }

7.其他三种处理流

1.标准输入、输出流

BufferedReader的readLine()

/*
1.标准的输入、输出流:
1.1：标准的输入、输出流
   system.in:标准的输入流，默认从键盘输入
   system.out:标准的输出流，默认从控制台输出
1.2：修改默认的输入输出行为
System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流

1.3练习：
从键盘输入字符串，要求将读取到的整行字符串转成大写输出。
然后继续进行输入操作，直至当输入"e”或者“exit”时，退出程序。

方法一:使用Scanner实现，调用next()返回一个字符串
方法二:使用system.in实现。System.in --->转换流--->BufferedReader的readLine()


 */
public class SoutTest {
    public static void main(String[] args)  {
        InputStreamReader isr= null;
        BufferedReader br= null;
        try {
            System.out.println ("请输入你想输入的字符串：");
            isr = new InputStreamReader (System.in);
            br = new BufferedReader (isr);
            while(true){
            String date=br.readLine ();
                if ("e".equalsIgnoreCase (date) || "exit".equalsIgnoreCase (date)) {
                    System.out.println ("程序结束");
                    break;
                }
                System.out.println (date);
            }
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {

            try {
                if(br!=null){
                br.close ();
                }if(isr!=null){
                isr.close ();
                }
            } catch (IOException e) {
                e.printStackTrace ();
            } finally {
            }
        }
    }
}

2.打印流

/*
打印流:
PrintStream 和PrintWriter
1.提供了一系列重载的print()和println()
2.提供了一系列重载的print()和println()方法，用于多种数据类型的输出
3.System.out返回的是PrintStream的实例

 */

3.数据流

/*
数据流
1. DataInputStream和DataOutputStream
2.作用:用于读取或写出基本数据类型的变量或字符串

练习:将内存中的字符串、基本数据类型的变量写出到文件中。
注意:处理异常的话，仍然应该使用try-catch-finally.
 */
@Test
public  void test1()  {
    DataOutputStream dos= null;
    try {
        //1.
        dos = new DataOutputStream (new FileOutputStream ("Hi.txt"));
        //2.
        dos.writeUTF ("霸王花");
        dos.writeInt (18);
        dos.writeBoolean (true);
    } catch (IOException e) {
        e.printStackTrace ();
    } finally {
        try {
            //3.
            if(dos!=null){
        dos.close ();
            }
        } catch (Exception e) {
            e.printStackTrace ();
        } finally {
        }
    }
}

/*
将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中,
注意点:读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致!

 */
    @Test
    public  void test()  {
        DataInputStream dos= null;
        try {
            //1.
            dos = new DataInputStream (new FileInputStream ("Hi.txt"));
            //2.
            //注意：不可随意更改顺序
            String s = dos.readUTF ();
            int i = dos.readInt ();
            boolean b = dos.readBoolean ();
            System.out.println ("name="+s);
            System.out.println ("age="+i);
            System.out.println ("isFemale="+b);
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            try {
                //3.
                if(dos!=null){

                dos.close ();
                }
            } catch (IOException e) {
                e.printStackTrace ();
            } finally {
            }
        }
    }

10.随机存取文件流

1.RandomAccessFile的使用

/*
RandomAccessFile的使用
1.RandomAccessFile直接继承于java.Lang.Object类，实现了DataInput和DataOutput接口
2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
3.>r:以只读方式打开
  >rw:打开以便读取和写入
  >rwd:打开以便读取和写入;同步文件内容的更新
  >rws:打开以便读取和写入;同步文件内容和元数据的更新


4.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建
  如果写出到的文件存在，则会对原有文件内容进行覆盖。(默认情况下，从头覆盖）
5.可以通过相关的操作，实现RandomAccessFiLe"插入”数据的效果
 */

2.RandomAccessFile实现数据的读写操作

    //实现数据的读取操作
    @Test
    public  void test()  {
        RandomAccessFile raf= null;
        RandomAccessFile raff= null;
        try {
            raf = new RandomAccessFile ("MVC+Dao.png","r");
            raff = new RandomAccessFile ("MVC+Dao111.png","rw");

            byte[] buffer=new byte[5];
            int len;
            while ((len=raf.read (buffer))!=-1){
                raff.write (buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            if(raf!=null){

                try {
                    raf.close ();
                } catch (IOException e) {
                    e.printStackTrace ();
                } finally {
                }
            }if(raff!=null){

                try {
                    raff.close ();
                } catch (IOException e) {
                    e.printStackTrace ();
                } finally {
                }
            }
        }


    }

3.RandomAccessFile实现数据的插入

普通覆盖

    @Test
    public  void test2() throws IOException {
     RandomAccessFile raf=new RandomAccessFile ("Hello.txt","rw");

     raf.seek (2);//指针，默认情况下停在0位置处
     raf.writeBytes ("xyz");//默认情况下是覆盖
     //例如：abcdefd————>abxyzfd
     raf.close ();
    }

使用使用stringBuilder数组保存数据

    //RandomAccessFile实现数据的插入
    //方法一：使用stringBuilder数组
    @Test
    public  void test3() throws IOException {
        RandomAccessFile raf=new RandomAccessFile ("Hello.txt","rw");

        raf.seek (2);//指针停在2
        //情况一：
        //保存指针后面的数据到stringBuilder
        StringBuilder stringBuilder=new StringBuilder ((int)new File ("Hello.txt").length ());

        byte [] buffer=new byte[5];
        int len;
        while ((len=raf.read (buffer))!=-1){
            stringBuilder.append (new String (buffer, 0, len));

        }
        //调回指针：
        raf.seek (2);//指针停在2
        raf.writeBytes ("xyz");

        //将stringBuilder的数据写入文件中
        raf.writeBytes (stringBuilder.toString ());
        raf.close ();
    }

使用ByteArrayOutputStream保存数据

    //RandomAccessFile实现数据的插入
    //方法二：使用ByteArrayOutputStream
    @Test
    public  void test4() throws IOException {
        RandomAccessFile raf=new RandomAccessFile ("Hello.txt","rw");

        raf.seek (2);//指针停在2

        ByteArrayOutputStream bos=new ByteArrayOutputStream ();
        byte [] buffer=new byte[5];
        int len;
        while ((len=raf.read (buffer))!=-1){
            bos.write (buffer,0,len);

        }
        //调回指针：
        raf.seek (2);//指针停在2
        raf.writeBytes ("xyz");

        //将存储的数据写入文件中
        raf.writeBytes (bos.toString ());
        raf.close ();
    }

le raf=new RandomAccessFile (“Hello.txt”,“rw”);

    raf.seek (2);//指针停在2
    //情况一：
    //保存指针后面的数据到stringBuilder
    StringBuilder stringBuilder=new StringBuilder ((int)new File ("Hello.txt").length ());

    byte [] buffer=new byte[5];
    int len;
    while ((len=raf.read (buffer))!=-1){
        stringBuilder.append (new String (buffer, 0, len));

    }
    //调回指针：
    raf.seek (2);//指针停在2
    raf.writeBytes ("xyz");

    //将stringBuilder的数据写入文件中
    raf.writeBytes (stringBuilder.toString ());
    raf.close ();
}


### 使用ByteArrayOutputStream保存数据

```java
    //RandomAccessFile实现数据的插入
    //方法二：使用ByteArrayOutputStream
    @Test
    public  void test4() throws IOException {
        RandomAccessFile raf=new RandomAccessFile ("Hello.txt","rw");

        raf.seek (2);//指针停在2

        ByteArrayOutputStream bos=new ByteArrayOutputStream ();
        byte [] buffer=new byte[5];
        int len;
        while ((len=raf.read (buffer))!=-1){
            bos.write (buffer,0,len);

        }
        //调回指针：
        raf.seek (2);//指针停在2
        raf.writeBytes ("xyz");

        //将存储的数据写入文件中
        raf.writeBytes (bos.toString ());
        raf.close ();
    }