java学习笔记day20-IO流

File

IO流是什么

1. 可以将数据从本地文件中读取出来
2. 可以将数据从内存保存到本地文件

File类是什么

1. 在读写数据时告诉虚拟机要操作的(文件/文件夹)在哪
2. 对(文件/文件夹)本身进行操作。包括创建、删除等

File类概述和构造方法

File：它是文件和目录路径名的抽象表示

• 文件和目录可以通过File封装成对象
• File封装的对象仅仅是一个路径名，他可以是存在的，也可以是不存在的。

方法名	说明
File(String pathname)	通过将给定的路径名字符转换为抽象路径名来创建新的File实例
File(String parent,String child)	从父路径名字符串和子路径名字符串创建新的File实例
File(File parent,String child)	从父抽象路径名和子路径名字符串创建新的File实例

import java.io.File;

public class FileTest {
    public static void main(String[] args) {
        //File(String pathname) 通过将给定的路径名字符转换为抽象路径名来创建新的File实例
        String path1 = "C:\\ahua\\a.txt";
        File file1 = new File(path1);
        //把字符串表示形式的路径变成File对象就是为了使用File类里面的方法

        //File(String parent,String child) 从父路径名字符串和子路径名字符串创建新的File实例
        String path2 = "C:\\ahua";
        String path3 = "a.txt";
        File file2 = new File(path2,path3); //把两个路径拼接
        System.out.println(file2); //C:\ahua\a.txt

        //File(File parent,String child) 从父抽象路径名和子路径名字符串创建新的File实例
        File file3 = new File("C:\\ahua");
        String path4 = "a.txt";
        File file4 = new File(file3,path4);
        System.out.println(file4); //C:\ahua\a.txt
    }
}

绝对路径和相对路径

• 绝对路径：从盘符开始
• 相对路径：相对当前项目下的路径

File类创建功能

方法名	说明
public boolean createNewFile()	创建一个新的空的文件
public boolean mkdir()	创建一个单级文件夹
public boolean mkdirs()	创建一个多级文件夹

示例：

import java.io.File;
import java.io.IOException;

public class FileTest2 {
    public static void main(String[] args) throws IOException {
        File file1 = new File("C:\\ahua\\a.txt");
        //如果文件存在，则创建失败，返回false
        //如果文件不存在，则创建成功，返回true
        //createNewFile方法不管调用者有没有后缀名，只能创建文件
        boolean result1 = file1.createNewFile();
        System.out.println(result1);

        //只能创建单级文件夹
        //不管调用者有没有后缀名，只能创建单级文件夹
        File file2 = new File("C:\\ahua\\aa");
        boolean result2 = file2.mkdir();
        System.out.println(result2);

        //可以创建单级文件夹，也可以创建多级文件夹
        //不管调用者有没有后缀名，只能创建单级文件夹
        File file3 = new File("C:\\ahua\\bb\\cc\\dd");
        boolean result3 = file3.mkdirs();
        System.out.println(result3);

    }
}

File类删除功能

方法名	说明
public boolean delete()	删除由此抽象路径名表示的文件或目录

示例:

import java.io.File;

public class FileTest3 {
    public static void main(String[] args) {
        //不走回收站
        //只能删除文件和空文件夹
        File file1 = new File("C:\\ahua\\a.txt");
        boolean result1 = file1.delete();
        System.out.println(result1);

        File file2 = new File("C:\\ahua\\aa");
        boolean result2 = file2.delete();
        System.out.println(result2);
    }
}

File类判断和获取功能

方法名	说明
public boolean isDirectory()	测试此抽象路径名表示的File是否为目录
public boolean isFile()	测试此抽象路径名表示的File是否为文件
public boolean exists()	测试此抽象路径名表示的File是否存在
public String getName()	返回此抽象路径名表示的文件或目录的名称

import java.io.File;

public class FileTest4 {
    public static void main(String[] args) {
        File file1 = new File("C:\\ahua\\a.txt");
        boolean result1 = file1.isFile();
        boolean result2 = file1.isDirectory();
        System.out.println(result1); //true
        System.out.println(result2); //false
        boolean result3 = file1.exists();
        System.out.println(result3); //true

        //如果调用者是文件，那么获取的是文件名和后缀名
        //如果调用者是一个文件夹，那么获取的是文件夹的名字
        File file2 = new File("C:\\ahua");
        String name1 = file1.getName();
        String name2 = file2.getName();
        System.out.println(name1); //a.txt
        System.out.println(name2); //ahua
    }
}

File类的高级获取功能

方法名	说明
public File[] listFiles()	返回此抽象路径名表示的目录中的文件和目录的File对象数组

listFiles方法注意事项：

• 当调用者不存在时，返回null
• 当调用者是一个文件时，返回null
• 当调用者是一个空文件夹时，返回一个长度为0的数组
• 当调用者是一个有内容的文件夹时，将里面所有文件和文件夹路径放在File数组中返回
• 当调用是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在Flie数组中返回，包含隐藏文件
• 当调用者是一个需要权限才能进入的文件夹时，返回null

案例：File的练习

练习一：在当前模块下的aaa文件夹中创建一个a.txt文件

练习二：删除一个多级文件

练习三：统计一个文件夹中每种文件的个数并打印

import java.io.File;
import java.io.IOException;
import java.util.HashMap;

public class FileTest6 {
    public static void main(String[] args) throws IOException {
        //在当前模块下的aaa文件夹中创建一个a.txt文件
        //注意：文件所在的文件夹必须要存在
        File file = new File("day20\\aaa");
        if(!file.exists()){
            //如果文件夹不存在，就创建出来
            file.mkdirs();
        }
        File newFile = new File(file,"a.txt");
        newFile.createNewFile();

        //删除一个多级文件
        File file1 = new File("C:\\users\\windows\\Desktop\\src");
        deleteDir(file1);

        //统计一个文件夹中每种文件的个数并打印
        File file2 = new File("day20");
        HashMap<String,Integer> hm = new HashMap<>();
        getCount(hm,file2);
        System.out.println(hm);
    }

    private static void getCount(HashMap<String, Integer> hm, File file2) {
        File[] files = file2.listFiles();
        for (File file : files) {
            if(file.isFile()){
                String fileName = file.getName();
                String[] fileNameArr = fileName.split("\\.");
                if(fileNameArr.length == 2){
                    String fileEndName = fileNameArr[1];
                    if(hm.containsKey(fileEndName)){
                        //已经存在，将以出现的次数获取出来
                        Integer count = hm.get(fileEndName);
                        count++;
                        //把已经出现的次数覆盖掉
                        hm.put(fileEndName,count);
                    }else{
                        //不存在，表示当前文件夹是第一次出现
                        hm.put(fileEndName,1);
                    }
                }
            }
        }
    }

    private static void deleteDir(File file1) {
        //先删除掉这个文件夹里面所有的内容
        //递归 方法在方法体中自己调用自己
        //递归解决所有文件夹和递归相结合的题目
        //进入 得到src文件夹里所有内容的File对象
        File[] files = file1.listFiles();
        //遍历 得到src文件夹里每一个文件和文件夹的File对象
        for (File file : files) {
            if(file.isFile()){
                //若File是一个文件直接删除
                file.delete();
            }else {
                //递归
                deleteDir(file);
            }
        }
    }
}

IO

分类

• 按流向分
  • 输入流；硬盘到内存，即读；
  • 输出流；内存到硬盘，即写；
• 按数据类型分
  • 字节流；操作所有类型的文件，包括音频视频图片等
  • 字符流；只能操作纯文本文件，包括java文件，txt文件等

纯文本文件：用Windows记事本打开能读的懂，那么这样的文件就是纯文本文件；如office不是纯文本文件。

字节流

字节流写数据

示例：

import java.io.FileOutputStream;
import java.io.IOException;

public class OutPutTest1 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流的对象，即告诉虚拟机要往哪个文件写数据
        //如果文件不存在会帮我们自动创建出来
        //如果文件存在会把文件清空
        FileOutputStream fos = new FileOutputStream("C:\\a.txt");
        //写数据  传递一个整数时，实际上写到文件中的是这个整数在码表中对应的那个字符
        fos.write(97);
        //释放资源
        fos.close(); //告诉操作系统，现在已经不再用这个文件了
    }
}

字节流写数据的三种方式

方法名	说明
void write(int b)	一次写一个字节数据
void write(byte[] b)	一次写一个字节数组数据
void write(byte[] b,int off,int len)	一次写一个字节数组中的部分数据

import java.io.FileOutputStream;
import java.io.IOException;

public class OutPutTest2 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("day20\\src\\zijieliu\\a.txt");
        byte[] bys = {97,98,99};
        fos.write(bys);
        fos.close();

        FileOutputStream fos2 = new FileOutputStream("day20\\src\\zijieliu\\b.txt");
        byte[] bys1 = {97,98,99,100,101,102};
        fos2.write(bys1,2,3); //第三个参数为个数
        fos2.close();
    }
}

字节流写数据的两个小问题

• 字节流写数据换行
  • fos.write("\r\n".getBytes());
• 字节流写数据实现追加写入
  • public FileOutputStream(String name,boolean append)
  • 创建文件输出流以指定的名称写入文件。如果第二个参数为true，不会清空文件里面的内容

字节流写数据加try…catch异常处理

**finally：**在异常处理时提供finally块来执行所有清除操作，比如说IO流中的释放资源

特点：被finally控制的语句一定会执行，除非JVM退出

异常处理标准格式：try…catch…finally

示例：

import java.io.FileOutputStream;
import java.io.IOException;

public class OutPutTest3 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("C:\\a.txt");
            fos.write(97);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字节流读数据

import java.io.FileInputStream;
import java.io.IOException;

public class InputTest1 {
    public static void main(String[] args) throws IOException {
        //如果文件存在，那么就不会报错
        //如果文件不存在，那么就会直接报错
        FileInputStream fis = new FileInputStream("day20\\src\\zijieliu\\a.txt");
        int read = fis.read();
        //一次读取一个字符，返回值就是本次读的那个字节数据
        //也就是字符在码表中对应的那个数字
        //如果我们想要看到的是字符数据，那么一定要强转成char
        //System.out.println((char)read);
        //fis.close();

        //文件中读取多个字节
        int b; //存储读到的字节内容
        while((b = fis.read())!= -1){
            System.out.println((char)b);
        }
        fis.close();
    }
}

案例：复制文件

需求：把“C:\\ahua\\a.avi”复制到当前模块下
分析：
1.复制文件，其实就是把文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)
2.数据源：C:\\ahua\\a.txt 读数据 FileInputStream
3.目的地：模块名称\\copy.avi 写数据 FileOutputStream

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class anli1 {
    public static void main(String[] args) throws IOException {
        //创建了字节输入流，准备读数据
        FileInputStream fis = new FileInputStream("C:\\ahua\\a.avi");
        //创建了字节输出流，准备写数据
        FileOutputStream fos = new FileOutputStream("day20\\a.avi");
        int b;
        while ((b = fis.read())!=-1){
            fos.write(b);
        }
        fis.close();
        fos.close();
    }
}

提高拷贝速度的解决方案

为了解决速度问题，字节流通过创建字节数组，可以一次写多个数据。

一次读一个字节数组的方法：

• public int read(byte[] b):从输入流读取最多b.length个字节的数据
• 返回的是读入缓冲区的总字节数，也就是实际的读取字节的个数

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class anli1 {
    public static void main(String[] args) throws IOException {
        //创建了字节输入流，准备读数据
        FileInputStream fis = new FileInputStream("C:\\ahua\\a.avi");
        //创建了字节输出流，准备写数据
        FileOutputStream fos = new FileOutputStream("day20\\a.avi");
        byte[] bytes = new byte[1024];
        int len; //本次读到的有效字节个数
        while((len = fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        fis.close();
        fos.close();
    }
}

字节流缓冲流

• BufferedOutputStream：字节缓冲输出流
• BufferedInputStream：字节缓冲输入流

构造方法：

• 字节缓冲输出流：BufferedOutputStream(OutputStream out)
• 字节缓冲输入流：BufferedInputStream(InputStream in)

注：

• 字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

import java.io.*;

public class Huanliu1 {
    public static void main(String[] args) throws IOException {
        //创建一个字节缓冲输入流
        //在底层创建了一个默认长度为8192的字节数组
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day20\\src\\a.avi"));
        //创建一个字节缓冲输出流
        //在底层也创建了一个默认长度为8192的字节数组
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day20\\src\\copy.avi"));
        int b;
        while ((b = bis.read())!=-1){
            bos.write(b);
        }
        bis.close();
        bos.close();
    }
}

注：如果不自定义数组，使用缓冲流的效率比字节流高，如果想自定义数组，定义超过8192的数组。

练习1

请在D盘根目录下创建一个文件：test1.txt(随意录入一些内容)，再创建一个目录：测试目录

要求：

1. 获取、打印file1和file2的绝对路径；
2. 获取、打印file1和file2的文件名和目录名；
3. 获取、打印file1和file2的文件大小；
4. 分别判断file1和file2是否存在；
5. 分别判断file1和file2是否是文件？是否是目录？

import java.io.File;

public class Lian1 {
    public static void main(String[] args) {
        File file1 = new File("D:\\text1.txt");
        File file2 = new File("D:\\测试目录");
        //获取打印file1和file2的绝对路径
        System.out.println("文件1的绝对路径是"+file1.getAbsolutePath());
        System.out.println("文件夹2的绝对路径是"+file2.getAbsolutePath());
        //获取、打印file1和file2的文件名和目录名
        System.out.println("文件1的名称是"+file1.getName());
        System.out.println("文件夹2的名称是"+file2.getName());
        //获取、打印file1和file2的文件大小(文件夹获取的不准确)；
        System.out.println("文件1的大小是"+file1.length());
        System.out.println("文件夹2的大小是"+file2.length());
        //分别判断file1和file2是否存在
        System.out.println("file1文件是否存在"+file1.exists());
        System.out.println("file2文件夹是否存在"+file2.exists());
        //分别判断file1和file2是否是文件？是否是目录？
        System.out.println("file1是否是文件"+file1.isFile());
        System.out.println("file2是否是目录"+file2.isDirectory());
    }
}

运行结果：

练习2

请编写main()方法，创建以下File对象：

​ File file1 = new File(“test.txt”);//相对路径

​ File file2 = new File(“一级目录”);

​ File file3 = new File(“目录A/目录B/目录C”);

​ 判断file1是否存在？如果不存在，创建这个文件；判断file2是否存在？如果不存在，创建这个目录；判断file3是否存在？如果不存在，创建这个多级目录。

import java.io.File;
import java.io.IOException;

public class Lian2 {
    public static void main(String[] args) throws IOException {
        File file1 = new File("test.txt"); //相对路径
        File file2 = new File("一级目录");
        File file3 = new File("目录A\\目录B\\目录C");
        //判断file1是否存在，不存在则创建
        if (!file1.exists()){
            file1.createNewFile();
        }
        //判断file2是否存在，不存在则创建
        if (!file2.exists()){
            file2.mkdirs();
        }
        //判断file3是否存在，不存在则创建
        if (!file3.exists()){
            file3.mkdirs();
        }
    }
}

练习3

在F盘下创建一个目录“多级目录”，下面随意创建一些文件和目录；请编写main()方法，创建以下File对象：File file = new File(“D:\多级目录”);

要求：

遍历这个多级文件夹下的所有内容(包含子文件夹的内容)，判断每个File对象是否文件

• 如果是文件，打印：【文件】+ 绝对路径；

• 如果是目录，打印：【目录】+ 绝对路径。

import java.io.File;

public class Lian3 {
    public static void main(String[] args) {
        File file = new File("F:\\a");
        dir(file);
    }

    private static void dir(File file) {
        File[] files = file.listFiles();
        for (File f : files) {
            if (f.isFile()){
                System.out.println("文件："+f.getAbsolutePath());
            }else {
                System.out.println("文件夹："+f.getAbsolutePath());
                dir(f); //f是文件夹递归处理
            }
        }
    }
}

运行结果：

练习4

使用代码计算出你电脑上的任意一个文件夹中的大小。要求必须是一个多层文件夹；

import java.io.File;

public class Lian4 {
    public static void main(String[] args) {
        File file = new File("F:\\2345Pic");
        //处理文件的方法
        dir(file);
        System.out.println(file.getName()+"文件夹的总大小是："+len+"个字节。");
    }
    private static long len = 0; //统计总大小的静态变量
    private static void dir(File file) {
        File[] files = file.listFiles();
        for (File f : files) {
            if (f.isFile()){
                //是文件就获取大小并累加起来
                len += f.length();
            }else{
                dir(f); //是文件夹递归处理
            }
        }
    }
}

运行结果：

练习5

使用键盘输入多个学生的信息,并将这些学生的信息保存到模块的1.txt文件中;

要求：

• 学生信息包含姓名、年龄(用一行字符串表示即可,无需创建学生对象);
• 每个学生信息占一行,学生信息之间使用逗号分隔;
• 至少输入3个学生信息;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class Lian5 {
    public static void main(String[] args) throws IOException {
        //创建文件对象准备写数据
        FileOutputStream fos = new FileOutputStream("1.txt");
        Scanner sc = new Scanner(System.in);
        for(int i = 1;true;i++){
            System.out.println("请输入第"+i+"个学生姓名和年龄,学生信息之间使用逗号分隔(ok表示结束):");
            String s = sc.next();
            if ("ok".equalsIgnoreCase(s)){
                System.out.println("88");
                break;
            }
            fos.write((s+"\r\n").getBytes());
        }
        fos.close();
    }
}

运行结果：