File类，IO流

File类

1. 创建于删除;

//如果文件存在返回false;否则返回true
boolean createNewFile();
//创建一个File对象所对应的目录,成功返回true,失败返回false
//必须是路径而不能为文件
//只会创建最后一级目录，如果上级不存在则会抛出异常。
boolean mkdir();
//创建一个File对象所对应的目录,成功返回true,失败返回false
//必须是路径而不能为文件
//创建多级目录，创建路径中所有不存在的目录
boolean mkdirs();
//如果存在返回true并且删除,否则返回false
boolean delete();
//在虚拟机终止，删除File对象所表示的文件或目录
void deleteOnExit();

2. 判断方法;

//判断文件是否可以执行
boolean canExecute();
//判断文件是否可以读取
boolean canRead();
//判断文件是否可以写
boolean canWrite();
//判断文件是否存在
boolean exists();
//判断是否是目录
boolean isDirectory();
//判断是否是文件
boolean isFile();
//判断是否是隐藏文件或者隐藏目录
boolean isHidden();
//判断是否是绝对路径，文件不存在也能判断
boolean isAbsolute();

3. 获取方法;

//返回文件或是目录的名称
String getName();
//返回路径
String getPath();
//返回绝对路径
String getAbsolutePath();
//返回父目录，如果没有父目录则返回NULL
String getParent();
//返回最后一次修改时间
long lastModified();
//返回文件长度
long length();
//列出所有的根目录
File[] listRoots();
//返回一个字符串数组，给定路径下的文件或目录名称字符串
String[] list();
//返回满足过滤器要求的字符串数组
String[] list(FilenameFilter filter);
//返回一个文件对象数组，给定路径下的目录文件
File[] listFiles();
//返回满足过滤器要求的一个文件对象数组
File[] listFiles(FilenameFilter filter);

IO流
__IO流的四中类型：Reader、InputStream、Writer、OutputStream。

1. InputStream
   输入字节流的父类。它是一个抽象类，包含三个方法：

//读取一个字节并以整数的形式返回(0~255),如果返回-1已到输入流的末尾。
int read() ；
//读取一系列字节并存储到一个数组buffer，返回实际读取的字节数，如果读取前已
到输入流的末尾返回-1。
int read(byte[] buffer) ；
//读取length个字节并存储到一个字节数组buffer，从off位置开始存,最多len，
返回实际读取的字节数，如果读取前以到输入流的末尾返回-1。
int read(byte[] buffer, int off, int len) ；

2. Reader
   所有的输入字符流的父类，它是一个抽象类。

//读取一个字符并以整数的形式返回(0~255),如果返回-1已到输入流的末尾。
int read() ；
//读取一系列字符并存储到一个数组buffer，返回实际读取的字符数，如果读取前已
到输入流的末尾返回-1。
int read(char[] cbuf) ；
//读取length个字符,并存储到一个数组buffer，从off位置开始存,最多读取len，
返回实际读取的字符数，如果读取前以到输入流的末尾返回-1。
int read(char[] cbuf, int off, int len)

执行完流操作后要调用 close()方法来关闭输入流，因为程序里打开的IO资源 不属于 内存资源，垃圾回收机制无法回收该资源。所以显示关闭文件IO资源。

移动流中的指针位置

//在此输入流中标记当前的位置
//readlimit - 在标记位置失效前可以读取字节的最大限制。
void mark(int readlimit)
// 测试此输入流是否支持 mark 方法
boolean markSupported()
// 跳过和丢弃此输入流中数据的 n 个字节/字符
long skip(long n)
//将此流重新定位到最后一次对此输入流调用 mark 方法时的位置
void reset(

3. OutputStream
   输出字节流，包含4个方法

//向输出流中写入一个字节数据,该字节数据为参数b的低8位。
void write(int b) ;
//将一个字节类型的数组中的数据写入输出流。
void write(byte[] b);
//将一个字节类型的数组中的从指定位置（off）开始的,len个字节写入到输出流。
void write(byte[] b, int off, int len);
//将输出流中缓冲的数据全部写出到目的地。
void flush();

4. Writer
   输出字符流的父类，它是一个抽象类,主要包含如下六个方法

//向输出流中写入一个字符数据,该字节数据为参数b的低16位。
void write(int c);
//将一个字符类型的数组中的数据写入输出流，
void write(char[] cbuf)
//将一个字符类型的数组中的从指定位置（offset）开始的,length个字符写入到输出流。
void write(char[] cbuf, int offset, int length);
//将一个字符串中的字符写入到输出流。
void write(String string);
//将一个字符串从offset开始的length个字符写入到输出流。
void write(String string, int offset, int length);
//将输出流中缓冲的数据全部写出到目的地。
void flush()

Writer比OutputStream多出两个方法，主要是支持写入字符和字符串类型的数据。

一、RandomAccessFile
RandomAccessFile既可以读取文件内容，也可以向文件输出数据。

import java.io.*;
import java.nio.charset.StandardCharsets;

public class FileMain {
    public static void main(String[] args) {
//        String filePath = "E:" + File.separator +
//                "untitled" + File.separator + "src" + File.separator + "Main.java";
//        fileInput(filePath);
//        bufferInputStream(filePath);
        String filePath = "E:" + File.separator +
                "untitled" + File.separator + "src" + File.separator + "randomAccessFile.java";
//            createFile(filePath);
        randomAccessFile(filePath);
    }

    private static void randomAccessFile(String filePath) {
        String content = "import java.io.*;" +
                "public class randomAccessFile{" +
                "   public static void main(String[]args){" +
                "System.out.println(\"创建文本randomAccessFile\");" +
                "}" +
                "}";

        new FileWriteThread(content.length(), content.getBytes(StandardCharsets.UTF_8), filePath).start();

    }

    static class FileWriteThread extends Thread {
        private int read;
        private byte[] content;
        private String path;

        public FileWriteThread(int read, byte[] content, String path) {
            this.read = read;
            this.content = content;
            this.path = path;
        }

        @Override
        public void run() {
            RandomAccessFile accessFile = null;
            try {
                accessFile = new RandomAccessFile(path, "rw");
//                accessFile.seek(0);
                accessFile.write(content);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (accessFile != null) {
                    try {
                        accessFile.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                }
            }
        }
    }

    private static void createFile(String filePath) {
        String content = "import java.io.*;" +
                "public class DemoTest{" +
                "   public static void main(String[]args){" +
                "System.out.println(\"创建文本DemoTest\");" +
                "}" +
                "}";
        File file = new File(filePath);

        OutputStream outputStream = null;
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            file.setReadable(true);
            file.setWritable(true);
            outputStream = new FileOutputStream(file);
            outputStream.write(content.getBytes());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static void bufferInputStream(String filePath) {
        try {
            File file = new File(filePath);
            if (!file.isFile()) {
                return;
            }
            InputStream fileInputStream = new FileInputStream(file.getPath());
            BufferedInputStream bis = new BufferedInputStream(fileInputStream);
            byte[] bytes = new byte[(int) file.length()];
            int len = 0;
            if ((len = bis.read(bytes)) != -1) {
                System.out.println(new String(bytes, 0, len));
            }
            bis.close();
            fileInputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void fileInput(String filePath) {
        File mainFile = new File(filePath);
        if (!mainFile.isFile()) {
            System.out.println("文件不存在");
            return;
        }
        try {
            FileInputStream fis = new FileInputStream(mainFile.getAbsoluteFile());
            byte[] fLength = new byte[(int) mainFile.length()];
            while (fis.read(fLength) != -1) {
                System.out.println(new String(fLength));
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}