【JAVA】|JAVA语言基础----File

File

代表文件或者文件夹的类

练习
1、删除文件（递归）

import java.io.File;

public class P1 {
    public static void main(String[] args) {
        //创建文件类的对象
        File file = new File("F:\\a");
        //调用方法删除文件
        deleteFiles(file);

    }
    //创建删除文件的方法
    public static void deleteFiles(File file){
        //判断是否是文件夹
        if(file.isDirectory()){
            //说明是文件夹需要展开当前文件夹下所有信息
            File[] fs = file.listFiles();
            //遍历数组
            for (File f:fs){
                //递归调用
                deleteFiles(f);
            }
        }
        //删除文件/删除空文件夹
        file.delete();
    }

}

2、统计工程下的.java文件和.class文件

import java.io.File;

//统计.class文件以及.Java文件的个数
//F:\JAVASE
public class FileText {
    //计数变量
    private static int countJava = 0;
    private static int countClass = 0;

    public static void main(String[] args) {
        //创建代表文件类的对象
        File file = new File("F:\\JAVASE");
        //调用方法统计文件
        countFiles(file);
        //
        System.out.println(".java文件="+countJava+"个，.class文件="+countClass+"个");
    }
    //定义方法类统计文件个数
    public static void countFiles(File file){
        //判断是否是文件夹
        if (file.isDirectory()) {
            //把当前文件夹下的所有信息返回
            File[] fs = file.listFiles();
            //遍历数组
            for(File f:fs){
                //递归调用
                countFiles(f);
            }
        }else if(file.getName().endsWith(".java")){
            countJava++;
        }else if (file.getName().endsWith(".class")){
            countClass++;
        }
    }
}

3、找出文件夹下含有数字的文件

import java.io.File;
import java.io.FileFilter;

public class FileDemo4 {
    public static void main(String[] args) {
        //创建代表文件类的对象
        File file = new File("F:\\");

        //把D盘下含有数字的文件或者文件夹输出
        //把过滤后的File类对象返回到数组当中
        File[] fs = file.listFiles(new FileFilter() {
            //重写方法----过滤规则
            @Override
            public boolean accept(File pathname) {
                //正则语法---匹配字符串中含有数字
                return pathname.getName().matches(".*\\d.*");
            }
        });

        //遍历数组
        for(File f:fs){
            System.out.println(f);
        }
    }
}

IO流
本质是一套数据传输的机制
1.根据传输的方向（以内存为参照物）
输入流：往内存来传输数据
输出流：从内存往传输数据
2.根据传输方式不一样
字符流：传输字符形式的数据
字节流：传输字节形式的数据
四大基本流(四个类都是抽象类)

	输出流	输出流
字符流	字符输出流（Writer）	字符输入流（Reader）
字节流	字节流 字节输出流（OutputStream）	字节输入流(InputStream)

根据数据存放/获取位置
硬盘、内存、网络、外设设备

硬盘
字符流
给硬盘上的.txt文件写入数据 文件 字符输出流—FileWriter
从硬盘上.txt文件读取数据 文件 字符输入流—FileReader

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo2 {
    public static void main(String[] args) throws IOException {
        //创建文件类对象
        FileReader reader = new FileReader("F:\\1.txt");
        //自建缓冲区
        //新数组
        char[] cs = new char[5];
        int len = -1;
        //方法返回值就是读取字符的个数，返回-1读取结束
        while ((len = reader.read(cs)) != -1){
            //把读取到的数据放在数组中
            //展示数组内容
            System.out.println(new String(cs,0,len));
        }


    }
}

io流捕获异常
1、在try块中声明流对象并且赋值为null，在try块中进行正真正的初始化
2、保证流对象初始化成功之后才能进行关流
3、无论关流成功与否，流对象都要置为null让系统进行回收
4、如果关流操作失败发生在自动冲刷之前那么需要添加冲刷过程，保证数据不会滞留在缓冲区

练习
1、实现文件复制（捕获异常）

import java.io.*;

public class p1 {


    public static void main(String[] args) {
        //声明流对象并且赋值为null
        FileReader reader = null;
        FileWriter writer = null;
        try {
            //进行真正的初始化
            //指定从哪读取数据
            reader = new FileReader("F:\\1.txt");
            //指定往哪写出数据
            writer = new FileWriter("F:\\2.txt");
            //读取数据
            //自建缓冲区
            char[] cs = new char[1024 * 1024 * 10];
            int len = -1;
            while ((len = reader.read(cs)) != -1) {
                //边读边写
                writer.write(cs, 0, len);
            }
            //冲刷数据
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //保证流对象真正初始化之后才能进行关流
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    //无论关流成功与否都要把对象置为null
                    writer = null;
                }

                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        //无论关流成功与否都要把对象置为null
                        reader = null;
                    }
                }
            }
        }
    }
}

字节流（常见）
给硬盘上的.txt文件写入数据 文件 字节输出流—FileOutputStream

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

public class FileOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建文件字节输出流的对象
        //底层没有自带的缓冲区 
        FileOutputStream fos = new FileOutputStream("F:\\c.txt");

        //调用方法来写出数据
        fos.write("你好".getBytes());
        
        //关流
        fos.close();

    }
}

//如果不指定append那么默认为flase就是每次新建空文件覆盖之前的内容
//如果指定append为true那么每次就是追加数据
FileOutputStream fos = new FileOutputStream("F:\\c.txt",true);

从硬盘上的.txt文件读取数据 文件 字节输入流---FileInputStream
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建文件字节输入流对象
        FileInputStream fis = new FileInputStream("F:\\1.txt");
        //返回一个字节对应的编码值，返回-1是说明读取完毕
        /*System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
*/
        //自建缓冲区
        byte[] bs = new byte[10];
        int len = -1;
        //返回读取到的字节数，遇到-1说明读取完毕
        while((len = fis.read(bs)) != -1){
            System.out.println(new String(bs,0,len));
        }
        //关流
        fis.close();
    }
}

练习2、实现文件复制

缓冲流（给别的流提供缓冲区）
BufferedReader–给字符输入流提供缓冲区 readLine（）读取一行
BufferedWriter—提供更大的缓冲区 newLine()换行

模式：遇到统一的问题是给出统一的解决当时
设计模式：在软件开发中，遇到统一问题给出统一解决方案
装饰者模式：同类对象给本类对象增强（完善）功能

转换流

OutputStreamWriter---字符流转成字节流
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        //创建转换流对象
        //转换流的对象由文件字节输出流对象构建
        //底层真正来进行传输数据的是文件字节输出流对象
        //接收准备数据时用的是字符流，底层真正往外写出数据用的是字节流
        //转换流---字符流转成字节流
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("F:\\1.txt"));

        //写出数据
        //往外写出数据先要准备数据
        //事先需要准备的数据都是字符形式的数据---需要提供字符流在操作数据
        
        osw.write("你好");

        //关流
        osw.close();

    }
}

InputStreamReader---字节流转成字符流
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        //创建转换流的对象
        /*
        转换流对象由文件字节输入流对象来构建
        底层真正读取数据的是文件字节输入流
        先根据文件字节输入流来读取数据
        转换流---字节流转成字符流
         */
        InputStreamReader isr = new InputStreamReader
                (new FileInputStream("F:\\1.txt"));
        //读取数据
        char[] cs = new char[10];//自建缓冲区
        int len = -1;
        //展示数据---字符形式数据
        //展示的数据由字符流来接收
        while((len = isr.read(cs))!=-1){
            //
            System.out.println(new String(cs,0,len));
        }
        
        //关流
        isr.close();

    }
}

系统流
out、err、in（都是字节流）
系统流都是静态的流对象，使用完毕后不能关流

打印流
print方法以及println方法都是定义在打印流里

序列化和反序列化
序列化：把对象以及相关信息转成字节数组 存储到硬盘上（持久化）
反序列化：把字节数组转成对应的对象

注意
1、类实现Serializable产生的对象才能序列化
2、如果属性被static/transient来修饰不能被序列化过去
3、serialVersionUID（序列化版本号）
在序列化之前会根据类里的属性和方法来计算出一个版本号，随着对象一起序列化过去，在反序列化之前会再次根据类里的属性和方法来计算出一个版本号，根据前后两个版本号来进行对比，如果对比结果一致可以进行正常的反序列化如果对比结果不一致，则反序列化失败。（指定版本号—private static final long serialVersionUID）
4、集合对象和映射对象都不能直接进行序列化，只能依次遍历元素对象一一进行序列化