Java - File、IO流

File类

File是java.io.包下的类，File类的对象，用于代表当前操作系统的文件（可以是文件、文件夹）

File类只能对文件本身进行操作，不能读写文件里面存储的数据。

创建File类的对象：

//创建file对象
        //1.具体某个文件
        File f1 = new File("D:\\DeskTop\\Desktop\\Java\\java.xlsx");
//        File f1 = new File("D:"+File.separator+"DeskTop"+File.separator+"Desktop"+File.separator+"Java"+File.separator+"java.xlsx");//一样，路径分隔符
//        File f1 = new File("D:/DeskTop/Desktop/Java/java.xlsx");//一样
        System.out.println(f1.length());//文件大小

        //2.某个文件夹
        File f2 = new File("D:\\DeskTop\\Desktop\\Java");
        System.out.println(f2.length());

        //3.可以指代一个不存在的文件路径
        System.out.println(f2.exists());//判断文件是否存在

        //文件定位
        //绝对路径
        File f4 = new File("E:\\java\\practice-wzz\\helloWorld-app\\src\\CollectionTest\\item.txt");
        //相对路径
        File f5 = new File("helloWorld-app\\src\\CollectionTest\\item.txt");
        System.out.println(f5.length());

常用方法：

f1.exists():判断文件是否存在

f1.isFile():判断当前文件是否是文件

f1.isDirectory():判断当前文件是否是文件夹

f1.getName():获取文件的名字

f1.length():获取文件的大小（字节个数）

f1.lastModified():获取文件最后修改时间

格式化时间格式：

long time = f1.lastModified();

SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");

System.out.println(sdf.format(time));

f1.getPath():获取创建对象时使用的路径

f1.getAbsolutePath():获取绝对路径

f1.createNewFile():创建文件，成功返回true

f1.mkdir():创建文件夹，成功返回true(注意只能创建一级文件夹)

f1.mkdirs():创建文件夹（可以创建多级文件夹）

f1.delete():删除文件或空文件夹（不能删除非空文件）

遍历文件夹

        //1.获取当前目录下所有”一级文件名称“到一个字符串
        File f1 = new File("D:\\DeskTop\\Desktop");
        String[] names = f1.list();
        for (String name : names) {
            System.out.println(name);
        }
        
        //2.获取当前目录下所有”一级文件对象“到一个File[]
        File[] files = f1.listFiles();
        for (File file : files) {
            System.out.println(file);
        }

//目标：改变文件夹下视频的序号，要求从19开始
    File dir  = new File("E:\\Java00");

    //1.获取文件夹下所有一级文件对象
    File[] files = dir.listFiles();

    //2.一个一个找
    for (File file : files) {
        //3.判断是否是视频
        if(file.getName().endsWith(".mp4")){
            //4.获取视频名称
            String name = file.getName();
            //5.截取视频名称
            String newName = name.substring(0,name.lastIndexOf("."));
            //获取文件尾部
            String endName = name.substring(name.lastIndexOf("."));
            //6.拼接新视频名称
            String newFileName = "19"+newName+".mp4";
            //7.修改视频名称
            file.renameTo(new File(file.getParent(),newFileName));
//            file.renameTo(new File(dir,newFileName));
        }

方法递归

方法调用自身的形式成为方法递归

字符集

IO流

用于读写数据的（可以读写文件，或网络中的数据……）

字节流

文件字节输入流：

每次读取一个字节：

is.read();

        //1.创建一个文件字节输入流管道，与源文件接通
        //InputStream is = new FileInputStream(new File("helloWorld-app\\src\\CollectionTest\\item.txt"));
        //简化写法
        InputStream is = new FileInputStream(("helloWorld-app\\src\\CollectionTest\\item.txt"));

        //2.开始读取文件的字节数据
        int b =is.read();
        System.out.println(b);//97
        System.out.println((char)b);//a

        int b1 =is.read();
        System.out.println((char) b1);//b

        int b2 =is.read();
        System.out.println(b2);//-1
        //每次读取一个字节返回，如果没有数据了，返回-1.

使用循环改造：

        //使用循环改造
        int b;//用于记住读取的字节
        while ((b = is.read())!= -1) {
            System.out.print((char) b);
        }

缺点：

读取数据性能差
读取汉字乱码，无法避免
流使用完毕之后，必须关闭，释放系统资源is.close();

每次读取多个字节：

is.read(buffer);

        byte[] buffer = new byte[3];
        int len = is.read(buffer);
        String rs = new String(buffer);
        System.out.println(rs);
        System.out.println("当次读取的字节数量"+len);

//        int len2 = is.read(buffer);
//        String rs2 = new String(buffer);
//        System.out.println(rs2);
//        System.out.println("当次读取的字节数量"+len2);
        //abqwu
        //输出
        // abq
        //当次读取的字节数量3
        //wuq
        //当次读取的字节数量2
        //因为第一次buffer = [abq],第二次读的wq只占前两个字节，最后一个还是第一次读的

        //读多少，倒多少
        int len2 = is.read(buffer);
        String rs2 = new String(buffer,0,len2);
        System.out.println(rs2);
        System.out.println("当次读取的字节数量"+len2);
        //abq
        //当次读取的字节数量3
        //wu
        //当次读取的字节数量2

循环改造：

        //循环改造
        byte[] buffer = new byte[3];
        int len;
        while ((len = is.read(buffer))!= -1) {
            String rs = new String(buffer, 0, len);
            System.out.println(rs);
            System.out.println("当次读取的字节数量"+len);
        }
        is.close();//关闭流

缺点：

无法避免汉字乱码

一次读取完全部字节：

        //1.一次性全部读完全部字节
        InputStream is = new FileInputStream("helloWorld-app\\src\\CollectionTest\\item.txt");

        //2.准备一个字节数组，大小与文件的大小正好一致
        File f = new File("helloWorld-app\\src\\CollectionTest\\item.txt");
        long size = f.length();
        byte[] b = new byte[(int)size];

        int len = is.read(b);
        System.out.println(new String(b));
        System.out.println(size);
        System.out.println(len);
        is.close();

        byte[] b = is.readAllBytes();
        System.out.println(new String(b));

文件字节输出流：

        //1.创建一个字节输出流管道与目标文件接通
        //覆盖管道，覆盖之前的数据
//        OutputStream os = new FileOutputStream("helloWorld-app\\src\\CollectionTest\\item22.txt");

        //追加管道，追加数据
        OutputStream os = new FileOutputStream("helloWorld-app\\src\\CollectionTest\\item22.txt",true);

        //2.开始写字节数据出去
        os.write(97);//97就是一个字节，代表a
        os.write('b');//'b'也是一个字节
//        os.write('蕾');//汉字是3个字节，但write每次只能写一个字节，所以输入的是乱码

        byte[] bytes = "我爱你中国爱按~~~~~~~~~~".getBytes();//字节数组
        os.write(bytes);

        os.write(bytes,0,15);//写入我爱你中国

        //换行符号
        os.write("\r\n".getBytes());

        //3.关闭输出流
        os.flush(); //刷新缓冲区，保证数据全部写出去

        os.close();

换行： os.write("\r\n".getBytes());

练习：

package FileIOStream;

import java.io.*;

public class CopyFile {
    public static void main(String[] args) throws Exception {
        InputStream is = null;
        OutputStream os = null;
        try {
            //需求：复制照片
            //1.创建一个字节输入流管道与源文件接通
            is = new FileInputStream("D:\\DeskTop\\Desktop\\Java\\QQ.jpg");
            //2.创建一个字节输出流管道与目标文件接通
            os = new FileOutputStream("D:\\DeskTop\\Desktop\\Java\\test\\QQ_copy.jpg");
            //3.定义一个字节数组转移数据
            byte[] buffer = new byte[1024];//1KB
            //4.从字节输入流中读取字节数据，写出去到字节输出流中，读多书写出去多少
            int len;
            while((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
//            os.close();
//            is.close();
            System.out.println("复制完成");
        } catch (IOException e) {
//            throw new RuntimeException(e);
            e.printStackTrace();
        } finally {
            //释放资源操作
            try {
                if(os != null) os.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                if(is != null) is.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

释放资源的方式：

try-catch-finally:

虚拟机终止：System.exit(0);

try-with-resource:

更好更优雅

package FileIOStream;

import java.io.*;

public class CopyFile {
    public static void main(String[] args) throws Exception {
        try(
              //需求：复制照片
             //1.创建一个字节输入流管道与源文件接通
            InputStream  is = new FileInputStream("D:\\DeskTop\\Desktop\\Java\\QQ.jpg");
            //2.创建一个字节输出流管道与目标文件接通
            OutputStream os = new FileOutputStream("D:\\DeskTop\\Desktop\\Java\\test\\QQ_copy.jpg");
            ) {
            //3.定义一个字节数组转移数据
            byte[] buffer = new byte[1024];//1KB
            //4.从字节输入流中读取字节数据，写出去到字节输出流中，读多书写出去多少
            int len;
            while((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
//            os.close();
//            is.close();
            System.out.println("复制完成");
        } catch (IOException e) {
//            throw new RuntimeException(e);
            e.printStackTrace();
        }
    }
}

注意：try()内只能放资源对象，资源都是会实现AutoCloseable接口

字符流

FileReader:

Reader fr = new FileReade("");

FileWriter:

Writer fw = new FileWriter("");

换行直接：fw.write("\r\n");

字符输出流使用时注意：

字符流写输出数据后，必须刷新流，或者关闭流，写出去的数据才能生效。

字符流，字节流的使用场景小结：

字节流适合做一切文件数据的拷贝（音视频、文本）；字节流不适合读取中文内容输出。
字符流适合做文本文件的操作（读，写）。

缓冲流

字节缓冲流：

             //1.创建一个字节输入流管道与源文件接通
            InputStream  is = new FileInputStream("D:\\DeskTop\\Desktop\\Java\\QQ.jpg");
            //定义一个字节缓冲输入流包装原始的字节输入流
              InputStream bis = new BufferedInputStream(is,8192*2);
            
            //2.创建一个字节输出流管道与目标文件接通
            OutputStream os = new FileOutputStream("D:\\DeskTop\\Desktop\\Java\\test\\QQ_copy.jpg");
            //定义一个字节缓冲输出流包装原始的字节输出流
            OutputStream bos = new BufferedOutputStream(os);

字符缓冲流：

字符缓存输入流：

字符缓存输出流：

转换流

InputStreamReader:

不同编码读取时会乱码

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

默认UTF-8