File Handling (IO)

1.1介绍

File 类 就是当前系统中文件或者文件夹的抽象表示 

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

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

总之:File:文件对象,用于表示磁盘上的文件夹或数据文件

常用方法:

2.1 基本操作

2.1.1 创建文件的三种方式

		File file = new File("D:/AAA");
        file.mkdir();//创建目录
        /*三种创建方式*/
        //第一种
        File file01 = new File("D:\\AAA\\aaa.txt");
        file01.createNewFile();//创建文件
        /* \\目录层级 在window系统下层级分割符为\ 但是在linux和mac系统上分割符为 / 我们得java代码是一种跨平台得语言. 我们得开发在window 但是我们项目得部署在linux. 我们使我们得代码能在任意系统下来用. 我们有两种解决办法*/
		//第二种(解决的第一种)----因为window 兼容 / 和 \
        File file02 = new File("D:/AAA/bbb.txt");
        file02.createNewFile();
		//第三种(解决的第二种)----File.separator根据当前代码所在得系统自动获取相应得分割符 
        File file03 = new File("D:"+File.separator+"AAA"+File.separator+"ccc.txt");
        file03.createNewFile();//创建文件
        File file04 = new File("D:/AAA/CCC/DDD");
        file04.mkdirs();//创建多级目录

2.1.2删除操作

 		/*删除操作*/
        file03.delete();//删除文件
        file02.deleteOnExit();//程序退出后删除
        file04.delete();//删除空目录 有内容时候不能删除

2.1.3 修改操作

		file01.setReadable(false);//其他不能读取 但是自己可以读取 设置该文件得权限为不能读
        file02.setWritable(false);//设置该文件不能写
        file03.setReadOnly();//设置只读得权限

        file04.renameTo(new File("D:/AAA/CCC/EEE"));//重命名

2.1.3 查询操作

		File file = new File("D:/AAA/BBB/CCC/a.txt");
        file.createNewFile();

        //得到文件的名字
        String name = file.getName();
        System.out.println("文件的名字====>"+name);
        String parent = file.getParent();//得到父级路径
        System.out.println("父级路径====>"+parent);
        String path = file.getPath(); //得到文件路径
        System.out.println("文件路径====>"+path);

        boolean file1 = file.isFile();//判断文件对象是否为文件类型
        System.out.println(file1);
        boolean directory = file.isDirectory();//判断文件对象是否为目录
        System.out.println(directory);

        File file2 = new File("D:/AAA");
        String[] list = file2.list();//列出AAA目录下所有子文件得名称
        System.out.println(Arrays.toString(list));

2.1.4 文件的遍历

		File[] files = file2.listFiles();
        for (File f:files){
    
            System.out.println(f);
        }

2.1.4 文件递归遍历(经典)

 public static void main(String[] args) {
    
        String path = "D:/BBB";
        showAllFiles(path);
    }

    public static void showAllFiles(String path){
    
        File file = new File(path);
        //判断文件是否存在或者是否为目录
        if(!(file.exists())||!(file.isDirectory())){
    
            return; //程序的出口 仅当不存在或者不是目录的时候就退出 若是目录则继续递归调用(是文件就退出)
        }

        File[] files = file.listFiles(); //列出全部文件对象
        int c = 0;
        for (File f:files){
    
            if(f.isDirectory()){
    
                showAllFiles(f.getPath());
            }else{
    
                c++;
                System.out.println("文件"+c+"为:"+f.getName());
            }
        }

    }

总结:
	File文件类: An extraction of files and folders on our system.
       (1)method when an object of this class is created: File file=new File("文件的路径");
   	   (2)方法: 
             list();List all subfile names in this directory.
             listFiles();List all subfile objects in this directory
             getPath():得到文件的路径
             createNewFile()：创建文件
             mkdir();创建单层目录
             mkdirs():创建多层目录
             exists():判断文件是否存在.
             isDirectory():Determine whether the file is a directory.
             delete():删除文件

3.1 IO流

流:   水流(有方向,有基本的构成单位:水滴),车流(有方向,基本单位:车)
数据流:以字节或字符为单位按特定的方向传送就构成了数据流.
	IO: 就是通过IOStreams operate on the contents of a file.   
  	IO按照 方向: 输入流和输出流
  	IO按照 内容: 字节流和字符流.
  	IO功能： 节点流和处理流
IO中的4个基类:
  InputStream:字节输入流
  OutputStream:字节输出流
  Reader: 字符输入流
  Writer: 字符输出流

3.1.1分类

解释:written by usJavaprogram-centric,因此
文件—>Java程序 This is called an input stream
Java程序---->文件 This is called an output stream

3.1.2字符输出流

//字符输出流 ---指定对哪个文件（路径）进行写操作
        //true:表示允许追加内容到文件中
        FileWriter fileWriter = new FileWriter("D:/AAA/aaa.txt");
        String str = "世界你好！";
        fileWriter.write(str);
        fileWriter.flush();//刷新流
        fileWriter.close();//关闭流

3.1.3字符输入流

		//这种方式是每次只读取一个字符
		//创建字符输入流对象. 作用：就是读取aaaa.txt里的内容
        Reader reader = new FileReader("D:/AAA/aaa.txt");
        /*int read = reader.read(); System.out.println((char)read);//读取第一个字符 int read1 = reader.read(); System.out.println((char)read1);//读取第二个字符*/
        int r=0;
        /*循环读取全部字符*/
        while ((r = reader.read())!=-1){
    
            System.out.print((char)r);
        }
    }
	//但是这种效率会很慢 因为每次只读取一个字符.
	//我们可以利用字符数组每次读取几个字符
		char[] chars = new char[10];//自定义数组长度
        int c = reader.read(chars);//每次读取的两个字符存入数组中且返回读取的个数
        String s = new String(chars, 0, c);//把读取到的数组转换为字符串
        System.out.println(s);
       
  //之后可以循环遍历读出全部字符
  //可以循环读出所有的字符 当读不到数据时此时c==-1,程序退出
       char[] chars = new char[10];
       int readC=0;//记录读取字符的个数
        while ((readC=reader.read(chars))!=-1){
    
            String s = new String(chars, 0, readC);
            System.out.print(s);
        }
	

3.1.4使用字符流完成文件内容的复制

【这里的代码都是用junit测试单元进行编写(方便书写)】
要求: 将 D:/AAA/aaa.txt 中的内容复制到 D:/BBB/b.txt

 	@Test
   	 public void test1() throws Exception {
    
        //创建一个字符输入流
        FileReader fr = new FileReader("D:/AAA/aaa.txt");
        //创建一个字符输出流
        FileWriter fw = new FileWriter("D:/BBB/b.txt");

        int c=0;//读取字符的个数
        
        char[] chars = new char[10];//保存数据
        /*没有读到内容时则返回-1*/
        while ((c=fr.read(chars))!=-1){
    
            fw.write(chars,0,c); //将内容写到D:/BBB/b.txt中
            fw.flush();
        }

        fr.close();
        fw.close();
    }

注:但是上面的字符流没法对图片和电影或压缩文件等进行操作.因为电影、音乐、图片等时二进制文件,而字符流只能对文本进行操作.

3.1.5字节输出流(OutputStream)

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

//将数据写入文件中
@Test
    public void outPutStreamTest() throws IOException {
    
        FileOutputStream fos = new FileOutputStream("D:/AAA/aaa.txt");
        String str="生活很简单,过了今天就是明天";
        byte[] bytes = str.getBytes();//将字符串转化为数组
        fos.write(bytes);//写入
        fos.close();//关闭资源
    }

3.1.6字节输入流(InputStream)

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

	//一次一次读
    @Test
    //输入流必须要存在文件 否则无法读取
    public void inPutStreamTest() throws IOException{
    
        InputStream fis = new FileInputStream("D:/AAA/aaa.txt");
        byte[] bytes = new byte[3];
        int c=0;//记录读取的个数
        //读第一次的数据
        c = fis.read(bytes); //将读取的内容存入到byte数组中
        System.out.println(bytes+"=====>第一次读取的个数:"+c);

        //d读第二次的数据
        c = fis.read(bytes); //将读取的内容存入到byte数组中
        System.out.print(bytes+"=====>第二次读取的个数:"+c);
    }

	//读全部
	 @Test
    //输入流必须要存在文件 否则无法读取
    //如果文件中内容非常大 使用循环来读取
    public void inPutStreamTestMore() throws IOException{
    
        InputStream fis = new FileInputStream("D:/AAA/aaa.txt");
        byte[] bytes = new byte[3];//数组大小根据实际需求 可变
        int c=0;//记录读取的个数
        while ((c=fis.read(bytes))!=-1){
    
            //将byte数组转化为字符串
            String s = new String(bytes, 0, c);
            System.out.print(s);
        }
        fis.close();//关闭资源
    }

3.1.7 使用字节输入流和输出流完成文件的复制

说明:InputStream 和 OutputStream 对二进制和字符文件都能进行复制(全能)

 //进行图片的复制 (文本也能换路径即可 以图片为例)
    @Test
    public void fileCopyTest() throws IOException{
    
        //1.创建输入流
        FileInputStream fis = new FileInputStream("D:/AAA/1.jpg");
        //2.创建输出流
        FileOutputStream fos = new FileOutputStream("D:/BBB/2.jpg");

        //3.定义数组 保存读取内容 长度任意
        byte[] bytes = new byte[20];

        int c=0;//记录读取内容的个数

        //4.复制内容
        while ((c=fis.read(bytes))!=-1){
    
            //5.将保存到数组中的内容写到输出流中
            fos.write(bytes,0,c);
        }
        fis.close();
        fos.close();

    }

3.1.8 缓冲流

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

  @Test
    public void BufferTest() throws IOException {
    
        OutputStream os = new FileOutputStream("D:/AAA/e.txt");
        BufferedOutputStream bf = new BufferedOutputStream(os);//缓冲流要作用在基本流上
        String s="aaaaa";
        byte[] bytes = s.getBytes();
        bf.write(bytes);//写入的东西暂时放入缓存池中,并没有直接放入文件,所以文件没有内容
        //bf.flush();//刷新时会显示 但是这部也可以跳过 因为关闭流的时候会有自动的刷新操作(即先刷新后关闭流)
        bf.close();//关闭--->先刷新缓存池后关闭资源
    }

  @Test
    public void BufferInputTest() throws IOException{
    
        FileInputStream fis = new FileInputStream("D:/AAA/e.txt");
        BufferedInputStream bf = new BufferedInputStream(fis);
        byte[] bytes = new byte[2];
        int read = bf.read(bytes);
        String s = new String(bytes, 0, read);
        System.out.println(s);
        bf.close();
    }

3.1.8 对象流

为什么需要对象流？
 我们现在操作IO流的时候,都是将字符串读写操作 ,可不可以将java对象在文件中进行读写呢？ 
 可以的 Student st=new Student();
 将java对象进行读写操作 意义在于持久化信息  例如： 游戏存档.
 //  因为运行的时候 所有的数据都是在运行内存中的   持久化 将运行内存的数据 保存到硬盘上    存档（写）  读档(读)

//public ObjectOutputStream(OutputStream out) throws IOException
    @Test //存档：----序列化:
    public void testObjectStream() throws Exception{
    
        OutputStream out=new FileOutputStream("D:/AAA/a.txt");
        //对象输出流
        ObjectOutputStream oos=new ObjectOutputStream(out);

        //使用对象输出流调用输出方法 输出的类对象 该类必须实现Serializable 序列化接口
        Role r=new Role("吕布","7级",1,"弑父");
        oos.writeObject(r);
        oos.close();
    }
    //测试 读档: ----反序列化:
    @Test
    public void testObjectStream2()throws Exception{
    
        InputStream input=new FileInputStream("D:/AAA/a.txt");
        ObjectInputStream ois=new ObjectInputStream(input);
        Object o = ois.readObject();

        System.out.println(o);
        ois.close();
    }

1.  通过字符流完成文件的复制---->它只能复制文本文件
2.  字节流:---字节输入流和字节输出流.
3.  字节流 我们也可以完成文件的复制功能---它可以复制任意类型的文件.
4.  缓存流--->它基本流的基础上 添加了一个缓存池 
5.  对象流: ObjectInputStream  ObjectOutputStream
6. 序列化: 把内存中的java对象存储到磁盘[网盘]的过程.
     ---java对象所属的类必须实现序列化接口.implements Serializable 
7. 反序列化: 把磁盘中的内容读取到java对象内存中的过程.