后端开发学习日志（IO流篇）

流是一个抽象、动态的概念，是一连串连续动态的数据集合。
对于输入流而言，数据源就像水箱，流(Stream)就像水管中流动着的水流，程序就是我们最终的用户。我们通过流(A Stream）将数据源（Source)中的数据（information）输送到程序(Program中。
对于输出流而言，目标数据源就是目的地(dest)，我们通过流（A Stream）将程序( Program)中的数据( information)输送到目的数据源(dest)中。

注意：
输入/输出流的划分是相对程序而言的，并不是相对数据源。

Java中四大IO抽象类

InputStream/OutputStream和Reader/Writer类是所有Io流类的抽象父类，我们有必要简单了解一下这个四个抽象类的作用。然后，通过它们具体的子类熟悉相关的用法。

InputStream

此抽象类是表示字节输入流的所有类的父类。InputSteam是一个抽象类，它不可以实例化。数据的读取需要由它的子类来实现。根据节点的不同，它派生了不同的节点流子类。继承自InputSteam的流都是用于向程序中输入数据，且数据的单位为字节(8 bit)。

常用方法

1.int read():读取一个字节的数据,并将字节的值作为int类型返回(0-255之间的一个值)。如果未读出字节则返回-1(返回值为-1表示读取结束)。
2.void close():关闭输入流对象，释放相关系统资源。

OutputStream

此抽象类是表示字节输出流的所有类的父类。输出流接收输出字节并将这些字节发送到某个目的地。

常用方法

1.void write(int n):向目的地中写入一个字节。
2.void close():关闭输出流对象，释放相关系统资源。

Reader

Reader用于读取的字符流抽象类，数据单位为字符。

常用语法

1.int read():读取一个字符的数据，并将字符的值作为int类型返回(0-65535之间的一个值，即Unicode值)。如果未读出字符则返回-1 (返回值为-1表示读取结束)。
2.void close() :关闭流对象，释放相关系统资源。

Writer

Writer用于输出的字符流抽象类，数据单位为字符。

常用语法

1.void write(int n):向输出流中写入一个字符。
2.void close():关闭输出流对象，释放相关系统资源。

Java中流的概念细分

按流的方向分类

输入流:数据流从数据源到程序(以InputStream、Reader结尾的流)。
输出流:数据流从程序到目的地(以 OutPutStream、Writer结尾的流)。

按处理的数据单元分类

字节流:以字节为单位获取数据，命名上以stream结尾的流一般是字节流，如FileInputStream、FileOutputStream。
字符流:以字符为单位获取数据，命名上以Reader/Writer结尾的流一般是字符流，如FileReader、FileWriter。

按处理对象不同分类

节点流:可以直接从数据源或目的地读写数据，如FileInputStream、FileReader、DatalnputStream等。
处理流:不直接连接到数据源或目的地，是”处理流的流”。通过对其他流的处理提高程序的性能，如 BufferedInputStream、BufferedReader等。处理流也叫包装流。

节点流处于lO操作的第一线，所有操作必须通过它们进行;处理流可以对节点流进行包装，提高性能或提高程序的灵活性。

Java中IO流体系图

第一个简单的IO流程序

当程序需要读取数据源的数据时，就会通过lO流对象开启一个通向数据源的流，通过
这个lO流对象的相关方法可以顺序读取数据源中的数据。

先在任意盘中创立一个txt文档，命名为123，在文档中打出abc

    public static void main(String[] args) {
        //创建字节输入流对象
        FileInputStream fis = null;
        try {

            fis = new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\123.txt");
            int s1 = fis.read();//打印输入字符
            int s2 = fis.read();
            int s3 = fis.read();
            int s4 = fis.read();//由于文件内容已经读取完毕，则返回-1
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);

        } catch (Exception e) {
            e.printStackTrace();

        }finally {
            if (fis!= null){
                try {
                    fis.close();
                }catch (Exception e){
                    e.printStackTrace();
                }

            }
        }
    }

这样程序可以读出文档中的abc，但读出来的是字符的ASCII码，下面对这个程序进行改造

 public static void main(String[] args) {
        FileInputStream fis = null;
        StringBuffer sb = new StringBuffer();
        try {
            fis = new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\123.txt");
            int temp = 0;
            while ((temp = fis.read()) != -1) {
                
                sb.append((char) temp);
            }
            System.out.println(sb.toString());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null) ;
            } catch (Exception e) {
            }
        }
    }

我们通过循环结构输出文档中的字符，并用char将ASCII码转换为字符，最终输出结果为

abc

File类的使用

File类的作用

File类是Java提供的针对磁盘中的文件或目录转换对象的包装类。一个File对象而可以代表一个文件或目录，File对象可以实现获取文件和目录属性等功能，可以实现对文件和目录的创建，删除等功能。

针对文件操作的方法

createNewFile() //创建新文件。
delete() //直接从磁盘上删除
exists() //查询磁盘中的文件是否存在
getAbsolutePath() //获取绝对路径
getPath() //获取相对路径
getName() //获取文件名相当于调用了一个toString方法。
isFile() //判断是否是文件
length() //查看文件中的字节数
isHidden() //测试文件是否被这个抽象路径名是一个隐藏文件。

针对目录操作的方法

exists() //查询目录是否存在
isDirectory() //判断当前路径是否为目录
mkdir() //创建目录
getParentFile() //获取当前目录的父级目录。
list() //返回一个字符串数组，包含目录中的文件和目录的路径名。
listFiles //返回一个File数组，表示用此抽象路径名表示的目录中的文件。

File操作文件

通过createNewFile() 方法我们创建一个新文档

        File file = new File("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\新文档.txt");
        System.out.println(file.createNewFile());

然后用exists() 检测文件是否存在

  System.out.println(file.exists());

打开文档位置，可以发现生成成功

我们可以用delete对其进行删除

 System. out.println (file.delete()) ;

       System.out.println(file.getName());// 利用getName()获取文件名
       System.out.println(file.isFile()); //判断是否是文件
       System. out.println(file.isHidden());//测试文件是否被这个抽象路径名是一个隐藏文件。

输出结果为:

新文档.txt
true
false

File操作目录

代码示例

  public static void main(String[] args) {
        File file = new File(  "C:\\Users\\Lenovo\\Desktop\\java\\IO流\\新文件夹" ) ;
       //System .out.println(file.mkdir());
       //System.out.println (file.mkdirs());
       //System.out.println (file.exists());
       //System.out.println (file. isDirectory());
        System.out.println(file.getParentFile());
        System.out.println(file.getParentFile().getName());

        File file2 = new File ( "C:\\Users\\Lenovo\\Desktop\\java");
        String[ ] arr = file2.list ( ) ;
        for (String temp:arr){
            System.out.println (temp) ;
        }
        System.out.println ( "-----------------------" ) ;
        File[] arr2 = file2.listFiles ( ) ;
        for(File temp :arr2) {
            System.out.println(temp);

        }

    }

文件字节流

FileInputStream通过字节的方式读取文件，适合读取所有类型的文件（图像、视频、文
本文件等）。Java也提供了FileReader专门读取文本文件。

FileOutputStream 通过字节的方式写数据到文件中，适合所有类型的文件。Java也提供了FileWriter专门写入文本文件。

输入流我们以读取图像为例

    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\preview.jpg");
            int temp = 0;
            while ((temp = fis.read())!= -1){
                System.out.println(temp);
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if(fis != null){
                    fis.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

输出结果过长，在此不便于展示

输出流：

    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\preview.jpg");
            //创建文件字节输出流对象
            fos = new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\123.jpg");
            int temp = 0;
            while ((temp = fis.read())!= -1){
                fos.write(temp);
            }
            //将数据从内存中写入到磁盘中
            fos.flush();

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

可以发现文件夹中确实创建了新的图片

通过缓冲区提高读写效率

方法一

通过创建一个指定长度的字节数组作为缓冲区，以此来提高Io流的读写效率。该方式适用于读取较大图片时的缓冲区定义。注意:缓冲区的长度一定是2的整数幂。（一般情况下1024长度较为适合）

   public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\preview.jpg");
            //创建文件字节输出流对象
            fos = new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\123.jpg");
            //创建缓冲区提高效率
            byte[] buff = new byte[1024];
            int temp = 0;
            while ((temp = fis.read(buff))!= -1){
                fos.write(buff,0,temp);
            }
            //将数据从内存中写入到磁盘中
            fos.flush();

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

方法二

通过创建一个字节数组作为缓冲区，数组长度是通过输入流对象的available()返回当前文件的预估长度来定义的。在读写文件时，是在一次读写操作中完成文件读写操作的。注意:如果文件过大，那么对内存的占用也是比较大的。所以大文件不建议使用该方法。

    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\preview.jpg");
            //创建文件字节输出流对象
            fos = new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\456.jpg");
            //创建缓冲区提高效率
            byte[] buff = new byte[fis.available()];
            fis.read(buff);
            //将数据从内存中写入到磁盘中
            fos.write(buff);
            fos.flush();

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

通过字节缓冲流提高读写效率

Java缓冲流本身并不具有lo流的读取与写入功能，只是在别的流（节点流或其他处理流)上加上缓冲功能提高效率,就像是把别的流包装起来一样,因此缓冲流是一种处理流(包装流)。当对文件或者其他数据源进行频繁的读写操作时，效率比较低，这时如果使用缓冲流就能够更高效的读写信息。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷新时再一次性的读取到程序或写入目的地。因此，缓冲流还是很重要的，我们在IO操作时记得加上缓冲流来提升性能

BufferedInputStream和BufferedOutputStream这两个流是缓冲字节流，通过内部缓存数组来提高操作流的效率。

代码示例：

    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            fis = new FileInputStream("C://Users//Lenovo//Desktop//java//IO流//123.jpg");
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream("C://Users//Lenovo//Desktop//java//IO流//ACG.jpg");
            bos = new BufferedOutputStream(fos);
            //缓冲流中，byte数组长度默认是8192
            int temp = 0;
            while ((temp = bis.read())!= -1){
                bos.write(temp);
            }
            bos.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
//注意：关闭流顺序：“后开的先关闭”
                if (bis != null){
                    bis.close();
                }
                if (fis != null){
                    fis.close();
                }
                if (bos != null){
                    bos.close();
                }
                if (fos != null){
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

定义文件拷贝类

    public static void main(String[] args) {
        copyFile("C://Users//Lenovo//Desktop//java//IO流//123.jpg","C://Users//Lenovo//Desktop//java//IO流//复制.jpg");

        }
    public static void copyFile (String src,String des) {
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;

        try {
            bis = new BufferedInputStream(new FileInputStream(src));
            bos = new BufferedOutputStream(new FileOutputStream(des));
            int temp = 0;
            while ((temp = bis.read())!=-1){
                bos.write(temp);
            }
bos.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bis != null){
                    bis.close();
                }
                if (fis != null){
                    fis.close();
                }
                if (bos != null){
                    bos.close();
                }
                if (fos != null){
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

文件字符流

文件字符输入流

前面介绍的文件字节流可以处理所有的文件，如果我们处理的是文本文件，也可以使用文件字符流，它以字符为单位进行操作。

    public static void main(String[] args) {
        FileReader frd = null;


        try {
            //创建文件字符输入流对象
            frd = new FileReader("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\123.txt");
            int temp = 0;
            while ((temp = frd.read()) != -1) {
                System.out.println((char)temp);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (frd != null) {
                    frd.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

文件字符输出流

    public static void main(String[] args) {


        FileWriter fw = null;
        FileWriter fw2 = null;
        try {
            fw = new FileWriter("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\writer.txt");
            fw.write("你好\r\n");
            fw.write("芸\r\n");
            fw.flush();

            fw2 = new FileWriter("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\writer.txt",true);
            fw2.write("青青子衿\r\n悠悠我心");
            fw2.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if(fw != null){
                    fw.close();
                }
                if (fw2 != null){
                    fw2.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

使用字符流实现文本文件的拷贝处理

    public static void main(String[] args) {
        FileReader fr =null;
        FileWriter fw = null;
        try {
            fr = new FileReader("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\2.txt");
            fw = new FileWriter("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\3.txt");
            char[] buffer = new char[1024];
            int temp = 0;
            while ((temp = fr.read())!=-1){
              fw.write(buffer,0,temp);
            }
            fw.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (fr != null){
                    fr.close();
                }
                if (fw != null){
                    fw.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

字符缓冲流

字符输入缓冲流

BufferedReader是针对字符输入流的缓冲流对象，提供了更方便的按行读取的方法:readLine();在使用字符流读取文本文件时，我们可以使用该方法以行为单位进行读取。

    public static void main(String[] args) {
        FileReader fr = null;
        BufferedReader br =null;
        try {
            fr = new FileReader("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\123.txt");
            br = new BufferedReader(fr);
            String temp = " ";
            while ((temp = br.readLine())!= null){
                System.out.println(temp);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (br != null){
                    br.close();
                }
                if (fr != null){
                    fr.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

字符输出缓冲流

BufferedWriter是针对字符输出流的缓冲流对象，在字符输出缓冲流中可以使用newLine();方法实现换行处理。

    public static void main(String[] args) {
        FileWriter fw = null;
        BufferedWriter bw = null;
        try {
            fw = new FileWriter("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\22.txt");
            bw = new BufferedWriter(fw);
            bw.write("你好");
            bw.write("芸");
            bw.newLine();
            bw.write("何以解忧");
            bw.newLine();
            bw.write("唯有杜康");
            bw.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bw != null){
                    bw.close();
                }
                if (fw !=null){
                    fw.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }

通过字符缓冲流实现文本文件的拷贝

public static void main(String[] args) {
        copyFile("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\22.txt","C:\\Users\\Lenovo\\Desktop\\java\\IO流\\33.txt");

    }
        public static void copyFile (String src,String des){
            BufferedReader br = null;
            BufferedWriter bw = null;
            try {

                br = new BufferedReader(new FileReader(src));
                bw = new BufferedWriter(new FileWriter(des));
                String temp = "";
                while ((temp=br.readLine()) != null){
                    bw.write(temp);
                    bw.newLine();
                }
                bw.flush();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                try {
                    if (br != null){
                        br.close();
                    }
                    if (bw != null){
                        bw.close();
                    }


                }catch (Exception e){
                    e.printStackTrace();
                }
            }



    }

通过字符缓冲流为文件中的内容添加行号

    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\22.txt"));
            bw = new BufferedWriter(new FileWriter("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\44.txt"));
            String temp = " ";
            int i = 1;

            while ((temp = br.readLine())!=null){
                bw.write(i+","+temp);
                bw.newLine();
                i++;
            }
            bw.flush();

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


            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

转换流

InputStreamReader/OutputStreamWriter用来实现将字节流转化成字符流。比如，如下场景:System.in是字节流对象，代表键盘的输入，如果我们想按行接收用户的输入时，就必须用到缓冲字符流BufferedReader特有的方法readLine()，但是经过观察会发现在创建BufferedReader 的构造方法的参数必须是一个Reader对象，这时候我们的转换流InputStreamReader就派上用场了。而System.out也是字节流对象，代表输出到显示器，按行读取用户的输入后，并且要将读取的一行字符串直接显示到控制台，就需要用到字符流的write(String str)方法，所以我们要使用OutputStreamWriter将字节流转化为字符流。

通过转换流实现键盘输入屏幕输出

    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;

        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            bw = new BufferedWriter(new OutputStreamWriter(System.out));

            while (true){
                bw.write("请输入");
                String input = br.readLine();
                if ("exit".equals(input)){
                    break;
                }
                bw.write("您输入的是"+input);
                bw.newLine();
                bw.flush();
            }

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

通过字节流读取文本文件并添加行号

   public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\123.txt")));
            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\369.txt")));
            String temp = " ";
            int i = 1;
            while ((temp = br.readLine()) != null) {
                bw.write(i + "." + temp);

                bw.newLine();
                i++;
            }

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

字符输出流

在Java的lo流中专门提供了用于字符输出的流对象PrintWriter。该对象具有自动行刷新缓冲字符输出流，特点是可以按行写出字符串，并且可通过println();方法实现自动换行。

    public static void main(String[] args) {
        BufferedReader br = null;
        PrintWriter pw = null;
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\2.txt")));
            pw = new PrintWriter("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\4.txt");
            String temp = " ";
            int i = 1;
            while ((temp = br.readLine())!= null ){
                pw.println(i+","+temp);
                i++;
            }


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

            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }

字节数组流

ByteArrayInputStream和 ByteArrayOutputStream经常用在需要流和数组之间转化的情况!

字节数组输入流

说白了，FilelnputStream是把文件当做数据源。ByteArrayInputStream 则是把内存中的”字节数组对象”当做数据源。

    public static void main(String[] args) {
        byte[]arr = "abcdefg".getBytes();
        ByteArrayInputStream bis = null;
        StringBuffer sb = new StringBuffer();
        try {
            //该构造方法的参数是一个字节数组，这个字节数组就是数据源
            bis = new ByteArrayInputStream(arr);
            int temp = 0;
            while ((temp = bis.read())!=-1){
                sb.append((char) temp);

            }
            System.out.println(sb.toString());
        }finally {
            try {
                bis.close();
            }catch (Exception e){
                e.printStackTrace();
            }

        }
    }

字节数组输出流

BvteArrayOutputStream流对象是将流中的数据写入到字节数组中。

    public static void main(String[] args) {
       ByteArrayOutputStream bos = null;
        try {
            StringBuilder sb = new StringBuilder();
            bos = new ByteArrayOutputStream();
            bos.write('a');
            bos.write('b');
            bos.write('c');
            byte[]arr = bos.toByteArray();
            for (int i = 0; i < arr.length; i++) {
               sb.append((char) arr[i]);
                
            }
            System.out.println(sb.toString());


        }finally {
            try {
                if (bos != null){
                    bos.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

数据流

数据流将“基本数据类型与字符串类型”作为数据源，从而允许程序以与机器无关的方式从底层输入输出流中操作Java基本数据类型与字符串类型。DatalnputStream和DataOutputStream提供了可以存取与机器无关的所有Java基础类型数据（如:int、double、String 等)的方法。

数据输出流

    public static void main(String[] args) {
        DataOutputStream dos = null;
        try {
          dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\data.txt")));
          dos.writeChar('a');
          dos.writeInt(10);
          dos.writeDouble(Math.random());
          dos.writeBoolean(true);
          dos.writeUTF("芸");
          dos.flush();
        }catch (Exception e){
            e.printStackTrace();

        }finally {
            try {
                if (dos != null){
                    dos.close();
                }

        }catch (Exception e){
                e.printStackTrace();
            }

        }

    }

数据输入流

        DataInputStream dis = null;
        try {
            dis = new DataInputStream(new BufferedInputStream(new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\data.txt")));
          //直接读取数据，注意：读取的顺序要与写入的顺序一致，否则不能正确读取数据
            System.out.println("chat:"+dis.readChar());
            System.out.println("int:"+dis.readInt());
            System.out.println("double:"+dis.readDouble());
            System.out.println("boolean:"+dis.readBoolean());
            System.out.println("String:"+dis.readUTF());

        }catch (Exception e){
            e.printStackTrace();

        }finally {
            try {
                if (dis != null){
                    dis.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

对象流

对象的本质是用来组织和存储数据的，对象本身也是数据。那么，能不能将对象存储到硬盘上的文件中呢?能不能将对象通过网络传输到另一个电脑呢?我们可以通过序列化和反序列化来实现这些需求。

Java对象的序列化和反序列化

序列化和反序列化是什么

当两个进程远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。比如，我们可以通过http协议发送字符串信息;我们也可以在网络上直接发送Java对象。发送方需要把这个Java对象转换为字节序列，才能在网络上传送;接收方则需要把字节序列再恢复为Java对象才能正常读取。

把Java对象转换为字节序列的过程称为对象的序列化。把字节序列恢复为Java对象的过程称为对象的反序列化。

对象序列化的作用有如下两种:
1.持久化:把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中。
2.网络通信:在网络上传送对象的字节序列。比如∶服务器之间的数据通信、对象传递。

序列化涉及的类和接口

ObjectOutputStream 代表对象输出流，它的writeObject(Object obi)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
只有实现了Serializable接口的类的对象才能被序列化。Serializable接口是一个空接口，只起到标记作用。

操作基本数据类型

我们前边学到的数据流只能实现对基本数据类型和字符串类型的读写，并不能对Java对象进行读写操作（字符串除外)，但是在对象流中除了能实现对基本数据类型进行读写操作以外，还可以对Java对象进行读写操作。

写出基本数据类型数据

    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\5.txt")));
            oos.writeInt(10);
            oos.writeDouble(Math.random());
            oos.writeChar('a');
            oos.writeBoolean(true);
            oos.writeUTF("芸");
            oos.flush();
        }catch (Exception e){
            e.printStackTrace();

        }finally {
            try {
                if (oos != null){
                    oos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

读取基本数据类型数据

    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\5.txt")));
            //直接读取数据，注意：读取的顺序要与写入的顺序一致，否则不能正确读取数据
            System.out.println("int:"+ois.readInt());
            System.out.println("double:"+ois.readDouble());
            System.out.println("char:"+ois.readChar());
            System.out.println("boolean:"+ois.readBoolean());
            System.out.println("String:"+ois.readUTF());

        }catch (Exception e){
            e.printStackTrace();

        }finally {
            try {
                if (ois != null){
                    ois.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

操作对象

将对象序列化到文件

ObjectOutputStream可以将一个内存中的Java对象通过序列化的方式写入到磁盘的文件中。被序列化的对象必须要实现Serializable 序列化接口，否则会抛出异常。

创建对象

public class User implements Serializable {
    private int userid;
    private String username;
    private String userage;

    public User(int userid,String username,String userage){
        this.userid = userid;
        this.username = username;
        this.userage =userage;
    }

    public int getUserid() {
        return userid;
    }

    public void setUserid(int userid) {
        this.userid = userid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getUserage() {
        return userage;
    }

    public void setUserage(String userage) {
        this.userage = userage;
    }

    public User(){

    }
}

    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\6.txt"));
            User user = new User(1,"芸","19");
            oos.writeObject(user);
            oos.flush();

        }catch (Exception e){
            e.printStackTrace();

        }finally {
            try {
                if (oos != null){
                    oos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

将对象反序列化到内存中

    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\6.txt"));
            User user = (User)ois.readObject();
            System.out.println(user.getUserid()+"\t"+user.getUserage()+"\t"+user.getUsername());

        }catch (Exception e){
            e.printStackTrace();

        }finally {
            try {
                if ( ois!= null){
                    ois.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

随机访问流

RandomAccessFile可以实现两个作用:
1．实现对一个文件做读和写的操作。
2．可以访问文件的任意位置。不像其他流只能按照先后顺序读取。

在开发某些客户端软件时，经常用到这个功能强大的可以"任意操作文件内容”的类。比如，软件的使用次数和使用日期，可以通过本类访问文件中保存次数和日期的地方进行比对和修改。Java很少开发客户端软件，所以在Java开发中这个类用的相对较少。学习这个流我们需掌握三个核心方法:1.RandomAccessFile(String name，Stringmode) name用来确定文件; mode取r(读)或rw(可读写)，通过mode可以确定流对文件的访问权限。
2.seek(long a)用来定位流对象读写文件的位置，a确定读写位置距离文件开头的字节个数。
3.getFilePointer()获得流的当前读写位置。

    public static void main(String[] args) {
        RandomAccessFile raf = null;
        try {
            raf = new RandomAccessFile("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\7.txt","rw");
            //将若干数据写入到文件当中
            int [] arr = new int[]{10,20,30,40,50,60,70,80,90,100};
            for (int i = 0; i < arr.length; i++) {
                raf.writeInt(arr[i]);
            }
            raf.seek(4);
            System.out.println(raf.readInt());

            //隔一个读一个数据
            for (int i = 0; i < 10; i+=2) {
                raf.seek(i * 4);
                System.out.print(raf.readInt() + " ");
            }
            System.out.println();
                //在第8个字节位置插入一个新的数据45，替换之前的数据30
                raf.seek(8);
                raf.writeInt(45);
                for (int i = 0; i < 10; i+=2) {
                    raf.seek(i*4);
                    System.out.print(raf.readInt()+" ");

                
            }
        }catch (Exception e){
            e.printStackTrace();

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

File类在IO中的作用

当以文件作为数据源或目标时，除了可以使用字符串作为文件以及位置的指定以外，我们也可以使用File类指定。

    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {

            br = new BufferedReader(new FileReader(new File("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\123.txt")));
            bw = new BufferedWriter(new FileWriter(new File("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\8.txt")));
            String temp = "";
            int i = 1;
            while ((temp = br.readLine())!=null){
                bw.write(i+","+temp);
                bw.newLine();
                i++;
            }
            bw.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (br != null){
                    br.close();
                }
                if (bw != null){
                    bw.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

Apache IO包

JDK中提供的文件操作相关的类，但是功能都非常基础，进行复杂操作时需要做大量编程工作。实际开发中，往往需要你自己动手编写相关的代码，尤其在遍历目录文件时，经常用到递归，非常繁琐。Apache-commons工具包中提供了IOUtils/FileUtils，可以让我们非常方便的对文件和目录进行操作。本文就是让大家对IOUtils/FileUtils类有一个全面的认识，便于大家以后开发与文件和目录相关的功能。Apache lOutils和FileUtils类库为我们提供了更加简单、功能更加强大的文件操作和IO流操作功能。非常值得大家学习和使用。

Apache基金会介绍

Apache软件基金会（也就是Apache Software Foundation，简称为ASF)，是专门为支持开源软件项目而办的一个非盈利性组织。在它所支持的Apache项目与子项目中，所发行的软件产品都遵循Apache许可证(Apache License)。官方网址为:https://www.apache.org/。很多著名的Java开源项目都来源于这个组织。比如: commons、kafka、lucene、maven,shiro、struts 等技术，以及大数据技术中的: hadoop (大数据第一技术)、 hbase、spark、storm、mahout 等。

FileUtils的使用

FileUtils类中常用方法:

打开FileUtils 的api文档，我们抽出一些工作中比较常用的方法，进行总结和讲解。总
结如下:
cleanDirectory:清空目录，但不删除目录。
contentEquals: 比较两个文件的内容是否相同。
copyDirectory:将一个目录内容拷贝到另一个目录。可以通过FileFilter过滤需要拷贝的文件。
copyFile:将一个文件拷贝到一个新的地址。
copyFileToDirectory:将一个文件拷贝到某个目录下。
copylnputStreamToFile:将一个输入流中的内容拷贝到某个文件。
deleteDirectory:删除目录。
deleteQuietly:删除文件。
listFiles:列出指定目录下的所有文件。
openlnputSteam:打开指定文件的输入流。
readFileToString:将文件内容作为字符串返回。
readLines:将文件内容按行返回到一个字符串数组中。
size:返回文件或目录的大小。
write:将字符串内容直接写到文件中。
writeByteArrayToFile:将字节数组内容写到文件中。
writeLines:将容器中的元素的toString方法返回的内容依次写入文件中。
writeStringToFile:将字符串内容写到文件中。

FileUitls的使用一

public class FileUtilsDemo1 {
    public static void main(String[] args)throws Exception {
        String conten = FileUtils.readFileToString(new File("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\4.txt"),"utf-8");
        System.out.println(conten);
    }
}

FileUtils 的使用二

public class FileUtilsDemo2 {
    public static void main(String[] args)throws Exception{
        FileUtils.copyDirectory(new File("C:\\Users\\Lenovo\\Desktop\\java\\a"), new File("C:\\Users\\Lenovo\\Desktop\\java\\IO流"), new FileFilter() {
            //在文件拷贝时的过滤条件
            @Override
            public boolean accept(File pathname) {
                if (pathname.isDirectory() || pathname.getName().endsWith("html")) {
                    return true;
                }
                return false;
            }
        });
    }
}

IOUtils的使用

打开IOUtils的api文档，我们发现它的方法大部分都是重载的。所以，我们理解它的方
法并不是难事。因此，对于方法的用法总结如下:
buffer方法:将传入的流进行包装，变成缓冲流。并可以通过参数指定缓冲大小。
closeQueitly方法:关闭流。
contentEquals方法:比较两个流中的内容是否一致。
copy方法:将输入流中的内容拷贝到输出流中，并可以指定字符编码。
copyLarge方法:将输入流中的内容拷贝到输出流中，适合大于2G内容的拷贝。
linelterator方法:返回可以迭代每一行内容的迭代器。
read方法:将输入流中的部分内容读入到字节数组中。
readFully方法:将输入流中的所有内容读入到字节数组中。
readLine方法:读入输入流内容中的一行。
toBufferedInputStream,toBufferedReader:将输入转为带缓存的输入流。
toByteArray,toCharArray:将输入流的内容转为字节数组、字符数组。
toString:将输入流或数组中的内容转化为字符串。
write方法:向流里面写入内容。
writeLine方法:向流里面写入一行内容。

代码示例：

public class IOUtilsDemo {
    public static void main(String[] args) throws Exception{
        String content = IOUtils.toString(new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\IO流\\123.txt"),"utf-8");
        System.out.println(content);
    }
}