Java-IO流(File操作，字符输入输出流，字节输入输出流，缓冲流，对象流)

File对象

File的介绍

File 类 就是当前系统中 文件或者文件夹的抽象表示
    
通俗的讲  就是 使用File对象 来操作我们电脑系统中的文件或者文件夹

学习File类 其实就是学习 如何通过file对象 对系统中的文件/文件夹进行增删改查

1.创建file对象

File 名字 =new File(路径);

路径path即:"什么盘/什么文件/什么文件/什么文件";

 路径分割符
         *  D:\haha\hehe\123.mp4    称之为路径  其中 \ 就是路径分割符 代表的是 下级目录
         *  在windows系统中 路径分割符为  \   在 Linux 和 Mac 中 路径分割符是 /
         *  我们写的java代码  需要跨平台 多环境运行   开发环境：windows   生成环境：Linux
         *  此时就会出现一个问题  如果我们的路径分隔符 写成 \  在 windows中好使 到了 Linux就不识别
         *  所以我们可以使用以下两种方式解决：

方式一:windows不仅支持\还支持/

File 名字 =new File("D:/abc/a/123.txt");

方式二:使用动态识别的常量,File.separator根据当前代码所在的系统获取相应的分隔符

File 名字=new File("D:"+File.separator+"abc"+File.separator+"a"+File.separator+"123.txt");

2.file的增加操作

我们创建了一个新的file对象并不是在电脑中已经添加了文件,在电脑中创建文件需要file的添加

一定记得要抛出错误

(1)创建相应的文件:

file对象.createNewFile();

(2)创建单层目录:

file对象.mkdir();

mkdir:make directory

(3)创建多层目录:

file对象.mkdirs()

根据你调用的方法不同会创建不同类型的文件

 File file01=new File("D:/Lianxi/hello.text");
 file01.createNewFile();//创建文件
 File file02=new File("D:/Lianxi/aaa");
 file02.mkdir();//创建单层目录
 File file03=new File("D:/Lianxi/A1/A2");
 file03.mkdirs();//创建多层目录

3.file的删除操作

(1)删除文件:

file对象名字.delete();

(2)延迟删除(休眠删除)

file对象名字.deleteOnExit();//当程序退出后 删除

Thread.sleep(毫秒);

记得要抛出异常不然sleep会报错

(3)删除空目录

file对象.delete();

删除目录的前提一定是目录下没有文件即该目录为空目录;

        File file04=new File("D:/Lianxi/eee");
        //删除指定的文件
        file04.delete();
        File file05=new File("D:/Lianxi/hello.text");
        //延迟删除文件也可以叫做休眠删除文件
        file04.deleteOnExit();//程序退出后删除
        //多少毫秒后删除
        Thread.sleep(5000);
        File file06=new File("D:/Lianxi/A1/A2");
        //删除目录文件前提是空目录
        file06.delete();

4.file的修改操作

(1)设置该文件的权限为不能读:

file对象.setRedadable(false);

(2)设置该文件的全选为不能写:

file对象.setWritable(false);

(3)设置文件为只读权限:

file对象.setReadOnly()

(4)重命名

file对象.renameTo(new File(你要修改的路径));

        //创建一个file对象
        File file01=new File("D:/Lianxi/123.txt");
        //对原始文件进行重命名
        file01.renameTo(new File("D:/Lianxi/456.txt"));
        File file02=new File("D:/Lianxi/456.txt");
        //修改路径
        file01.renameTo(new File("D:/Lianxi/A1/A2/789.txt"));

5.file的查询操作

(1)得到当前文件的名称

file对象.getName();

(2)得到父级路径的名称

file对象.getParent();

(3)得到文件的路径名称:

file对象.Path();

(4)判断该对象文件是否为文件类型:

file对象.isFile();

如果是返回true否则返回false;

(5)判断该文件对象是否为目录类型

file对象.isDirectory();

如果是文件目录类型返回true否则返回false;

        File file=new File("D:/Lianxi/A1/A2/789.txt");
        //获取当前文件的文件名
        String str1=file.getName();
       // System.out.println("文件名为："+str1);
        //获取当前文件的父级路径
        String str2=file.getParent();
        //System.out.println("文件的父级路径为："+str2);
        //获取文件的路径
        String str3=file.getPath();
        System.out.println("文件的路径为："+str3);
        //判断是否为文件类型
        boolean b1=file.isFile();
        System.out.println(b1);
        //判断该文件是否为文件目录类型
        boolean b2=file.isDirectory();
        System.out.println(b2);

面试题:显示指定目录下的所有文件

用方法的递归调用

 public static void main(String[] args) {
        showFile("D:/Lianxi");
    }
    public static void showFile(String path){
        //1.创建一个文件对象把路径参数传入
        File file01=new File(path);
        //2.判断文件类型，是否是文件是否是文件目录
        if(!file01.exists() || !file01.isDirectory()){
            return;
        }
        //3.创建一个文件数组来进行循环遍历；
        File[] files=file01.listFiles();
        //4.用for each循环来遍历输出
        for(File f:files){
            //5.判断文件类型是否为文件目录
            //如果是文件目录
            if(f.isDirectory()){
                //输出文件目录所在的路径
                System.out.println(f.getPath()+"<Dir>");
                //继续调用本方法
                showFile(f.getPath());
            }
            else {
                //如果不是则输出文件所在的路径
                System.out.println(f.getPath());
            }
        }
    }

IO流

IO流的介绍

IO都是全大写 说明肯定是两个单词的首字母
I   inputstream 输入流     O  outputstream  输出流

IO 称之为 java的输入输出

        其实学习IO  就是学习  如何通过java代码 对文件内容 进行   读(输入流)  写(输出流)
所以有一话：   读进来 写出去

IO的作用：就是对文件中的内容进行操作。

输入: 读操作（读取文件的内容）   输出: 写操作(往文件中写内容)

 IO流的分类：

 (1)根据流的方向:
    ---输入流: 程序可以从中读取数据的流。
    ---输出流: 程序能向其中写入数据的流。
    
 (2)根据流的单位:
    ---字节流: 以字节为单位传输数据的流
    ---字符流: 以字符为单位传输数据的流
 
 (3)根据功能
    ---节点流: 直接和文件进行交互，用于直接操作目标设备的流。
    ---处理流(过滤流): 不是直接作用在文件上。 是对一个已存在流的链接和封装，通过对数据进行处理为程序提供功能强大、灵活的读写功能。
    
四个基本的流: 其他的流都是在这四个流的基础上进行扩展的
        字节输入流
        字节输出流
    
        字符输入流
        字符输出流

 

字符流

 1.Writer字符输出流

它是所有字符输出流的根类。---FileWriter类

字符输出流 ---指定对哪个文件（路径）进行写操作

1.创建:

Writer write对象=new FileWriter(路径)

2.添加

writer对象.write(内容);

3.刷新流

write对象.flush();

4.关闭流资源

write.close();

5.追加内容

上面每次往文件中写内容时 就会把原来的内容覆盖了。

我们只需要在创建write对象时在路径后加上true即：

Writer write对象=new FileWriter(路径,true)

        //创建writer对象指定路径
        Writer writer=new FileWriter("D:/Lianxi/A1/A2/789.txt");
        String s1="今天是个好日子，好呀么好日子！";
        //调用write方法添加指定的字符串
        writer.write(s1);
        //刷新流
        writer.flush();
        //关闭流
        writer.close();
        //追加内容
        Writer writer1=new FileWriter("D:/Lianxi/A1/A2/789.txt",true);
        String s2="非常适合写代码";
        writer1.write(s2);
        writer1.flush();
        writer1.close();

2.Reader字符输入流

它是所有字符输入流的根类  它的实现类有很多，我们使用FileReader实现类

1.创建字符输入流对象

Reader reader对象=new FileReader(路径);

2.读取元素

Reader对象.read(存储的容器);

使用读取方法后它会返回每次读取的个数

如果已经读取完所有元素或文件里没有元素就会返回-1；

        //定义String类型,此时集合中只能存储String类型的数据而且定义使用的类型必须是对象类型
        List<String> list=new ArrayList<String>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        String s1=list.get(2);
       // System.out.println(s1);
        //循环遍历输出集合里的内容
        for(String s2:list){
            System.out.println(s2);
        }

字节流

1.字节输出流-OutputStream

它可以对任意文件进行操作，对文件进行输出操作。以字节为单位。 它是所有字节输出流的父类，
FileOutputStream

1.字节输出流的创建

OutputStream 名字=new FileOutputStream(路径);

2.字节输出流的添加操作

字符操作流一般使使用字节数组byte[]来存储写入

(1)定义一个字符串来存储将你要写入文件的内容

(2)定义一个byte字节数组把字符串转换为字节数组.用到了字符串的get方法

3.字节流的写入操作

outputstream对象.write(数组名);

        //定义一个字节输出流
        OutputStream outputStream=new FileOutputStream("D:/Lianxi/dd/456.txt");
        String str1="叫偶靓仔";
        //将字符串转换为字节数组
        byte[] bytes=str1.getBytes();
        //调用write方法将数组写入文件
        outputStream.write(bytes);
        //刷新输出流
        outputStream.flush();
        //关闭输出流
        outputStream.close();

2.字节输入流-InputStream

它可以对任意文件进行读操作 ，以字节为单位，它是所有字节输入流的父类，子类有FileInputStream

1.字节输入流的创建

 InputStream 名字=new FileInputStream(路径);

2.字节输入流的读取

(1)首先要先定义一个字节数组byte[]来接收读取的内容

(2)定义一个整型来记录每次读取的返回值即每次读取的数量

(3)调用读取的方法

inputstream对象.read(字节数组);

通常我使用循环来获取文件读取文件里的数据

        //创建一个字节输入流
        InputStream inputStream=new FileInputStream("D:/Lianxi/dd/123.txt");
        //定义一个整型用于记录每次读取的个数
        int num1=0;
        //定义一个字节数组存储读取的的内容长度为10
        byte[] bytes=new byte[12];
        //定义循环来读取内容
        while ((num1= inputStream.read(bytes))!=-1){
            String str1=new String(bytes,0,num1);
            System.out.println(str1);
        }
        //关闭流
         inputStream.close();

3.使用字节输入和输出流完成文件的复制功能

        //1.定义一个读取对象把文件内容读取出来，字符输入流
        Reader reader=new FileReader("D:/Lianxi/A1/A2/789.txt");
        //2.定义一个输出对象把要复制的内容写入，字符输出流
        Writer writer=new FileWriter("D:/Lianxi/dd/123.txt");
        //3.定义一个整型接收读取时的返回值
        int num1=0;
        //4.定义一个char数组用于存储读取的数据
        char[] chars=new char[10];
        //定义循环进进行复制
        while ((num1=reader.read(chars))!=-1){
            writer.write(chars,0,num1);
            writer.flush();
        }
        reader.close();
        writer.close();

缓冲流

缓存流是在基础流[InputStream OutputStream Reader Writer]之上 添加了一个缓存池功能.
BufferInutStream  BufferOutputStream BufferReader  BufferWriter 提高IO的效率，降低IO的次数。

缓存流建立在基础流的基础上

1.缓存流的创建

(1)输出缓冲流:
BufferedOutputStream 名字=new BufferedOutputStream(输出流名字);

(2)输入缓冲流：

BufferedInputStream 名字=new BufferedInputStream(输入流名字);

2.缓冲流的方法

(1)输出缓冲流的用法:

bufferedoutputstream对象.write(字节数组);

(2)输入缓冲流的用法

bufferedInputstream对象.read(字节数组)

        //定义一个输出流
        OutputStream outputStream=new FileOutputStream("D:/Lianxi/A1/A2/789.txt");
        //定义一个输出缓冲流
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(outputStream);
        //定义一个字符串来存你要写进去的东西
        String str1="你是我的小呀小苹果";
        //定义一个字节数组
        byte[] bytes=str1.getBytes();
        //调用缓存流方法存暂时把要写入的数据存入到缓存流中,因为你写的内容暂时放入缓存池中并没有直接放入文件中,所以文件中没有你的内容。
        bufferedOutputStream.write(bytes);
        //关闭缓存流,关闭缓存流时会先先刷新缓存池刷新缓存池时会把池子内的数据写入文件
         bufferedOutputStream.close();

对象流-对java对象进行IO操作

为什么需要对象流
          我们现在操作IO流的时候 都是将字符串读写操作 可不可以将java对象在文件中进行读写呢？ 可以的 Student st=new Student();对象
          将java对象进行读写操作 意义在于持久化信息  例如： 游戏存档。

        因为运行的时候 所有的数据都是在运行内存中的   持久化 将运行内存的数据 保存到硬盘上    存档（写）  读档(读)

1.对象输出流(序列化)

(1)首先你要先定义一个类给定属性和方法并且此类一定要实现Serializable 序列化接口

(2)对象输出流的创建

要先创建一个字节输出流然后创建对象输出流

ObjectOutputStream 名字=new ObjectOutputStream(字节输出流名字);

(3)对象输出流的方法

名字.writeObject(对象);

使用对象输出流调用输出方法 输出的类对象 该类必须实现Serializable 序列化接口

   //使用
        //定义一个字节输出流
        OutputStream outputStream=new FileOutputStream("D:/Lianxi/dd/456.txt");
        //定义一个对象输出流
        ObjectOutputStream objectOutputStream=new ObjectOutputStream(outputStream);
        //调用自己定义的对象进行传参
        Hero h1=new Hero("张三",20,"男","人族");
        //调用对象流的写入方法将自己定义的对象写入文件中
        objectOutputStream.writeObject(h1);
        //关闭对象流
        objectOutputStream.close();

2.对象输入流(反序列化)

(1)对象输入流的创建

首先你要先定义一个字节输入流对象然后创建对象输入流

ObjectInputStream 名字=new ObjectInputStream(字节输入流名字);

(3)对象输入流的方法

名字.readObject();

一定记得要用Object类型来接收数据即:

Object o=名字.readObject();

        //定义一个字节输入对象
        InputStream inp=new FileInputStream("D:/Lianxi/dd/456.txt");
        //定义一个对象流输入对象
        ObjectInputStream objectInputStream=new ObjectInputStream(inp);
        //定义一个对象类型来接收读取的内容
        Object o1=objectInputStream.readObject();
        System.out.println(o1);
        objectInputStream.close();

1. 序列化: 把内存中的java对象存储到磁盘[网盘]的过程。
         ---java对象所属的类必须实现序列化接口.implements Serializable
2. 反序列化: 把磁盘中的内容读取到java对象内存中的过程。

总结

1.  通过字符流完成文件的复制---->它只能复制文本文件
2.  字节流:---字节输入流和字节输出流。
3.  字节流 我们也可以完成文件的复制功能---它可以复制任意类型的文件.
4.  缓存流--->它基本流的基础上 添加了一个缓存池
5.  对象流: ObjectInputStream  ObjectOutputStream
     序列化,反序列化: