文件相关api

File

代表操作系统的文件对象，它提供了定位文件位置，获取文件中的信息，创建文件，删除文件等,但不能读写内容。

构造器：

public File(String pathname) 根据文件路径，创建文件对象。（只会根据路径来生成一个文件件对象，如果路径是错误的也无法判断）

文件路径：

绝对路径：C:\\Users\\DELL\\Desktop\\javaSE

或C:/Users/DELL/Desktop/javaSE

相对路径（一般定位到模块下）：

Yang-app/src/data.txt

常用API：

public boolean isDirectory() 判断File对象是否为文件夹

@Test
    void filetest1(){
        //空文件，路径为错误路径
        File file1 = new File("B:\\workspace\\xuecheng\\1.txt");
        //文件夹文件
        File file2 = new File("B:\\workspace\\xuecheng\\test");
        if (file1.isDirectory()){
            System.out.println("file1文件为文件夹");
        }
        if (file2.isDirectory()){
            System.out.println("file2文件为文件夹");
        }
    }

运行结果：

public boolean ifFile() 判断File对象是否为文件,也可用来判断文件是否存在

 @Test
    void filetest1(){
        //空文件，路径为错误路径
        File file1 = new File("B:\\workspace\\xuecheng\\1.txt");
        //文件夹文件
        File file2 = new File("B:\\workspace\\xuecheng\\test");
        //文本文件对象
        File file3 = new File("B:\\workspace\\xuecheng\\test\\1.txt");
        if (file1.isFile()){
            System.out.println("file1是文件");
        }
        if (file2.isFile()){
            System.out.println("file2是文件");
        }
        if (file3.isFile()){
            System.out.println("file3是文件");
        }
    }

运行结果：

public boolean exists() 判断File中储存的路径是否存在

@Test
    void filetest1(){
        //空文件，路径为错误路径
        File file1 = new File("B:\\workspace\\xuecheng\\1.txt");
        //文件夹文件
        File file2 = new File("B:\\workspace\\xuecheng\\test");
        //文本文件对象
        File file3 = new File("B:\\workspace\\xuecheng\\test\\1.txt");
        if (file1.exists()){
            System.out.println("file1的路径存在");
        }
        if (file2.exists()){
            System.out.println("file2的路径存在");
        }
        if (file3.exists()){
            System.out.println("file3的路径存在");
        }
    }

运行结果

public String getAbsolutePath() 返回绝对路径的字符串

  //空文件，路径为错误路径
        File file1 = new File("B:\\workspace\\xuecheng\\1.txt");
        //文件夹文件
        File file2 = new File("B:\\workspace\\xuecheng\\test");
        //文本文件对象
        File file3 = new File("B:\\workspace\\xuecheng\\test\\1.txt");
        System.out.println(file1.getAbsoluteFile());
        System.out.println(file2.getAbsoluteFile());
        System.out.println(file3.getAbsoluteFile());

运行结果

public String getPath() 返回File中存储的路径的字符串

//空文件，路径为错误路径
        File file1 = new File("B:\\workspace\\xuecheng\\1.txt");
        //文件夹文件
        File file2 = new File("B:\\workspace\\xuecheng\\test");
        //文本文件对象
        File file3 = new File("B:\\workspace\\xuecheng\\test\\1.txt");
        System.out.println(file1.getPath());
        System.out.println(file2.getPath());
        System.out.println(file3.getPath());

运行结果：

public String getName() 获取文件名

//空文件，路径为错误路径
        File file1 = new File("B:\\workspace\\xuecheng\\1.txt");
        //文件夹文件
        File file2 = new File("B:\\workspace\\xuecheng\\test");
        //文本文件对象
        File file3 = new File("B:\\workspace\\xuecheng\\test\\1.txt");
        System.out.println(file1.getName());
        System.out.println(file2.getName());
        System.out.println(file3.getName());

运行结果：

public long lastModified() 返回文件最后修改的毫秒值

Public long length() 返回文件的字节数（大小）

创建文件

public boolean createNewFile() 创建一个空文件

    @Test
    void filetest1() throws IOException {
        //空文件，路径为错误路径
        File file1 = new File("B:\\workspace\\xuecheng\\1.txt");
        //文件夹文件
        File file2 = new File("B:\\workspace\\xuecheng\\test");
        //文本文件对象
        File file3 = new File("B:\\workspace\\xuecheng\\test\\1.txt");
        file1.createNewFile();
    }

运行结果：

public boolean mkdir() 只能创建一级文件夹

 @Test
    void filetest1() throws IOException {

        File file = new File("B:\\workspace\\xuecheng\\test\\2");
        file.mkdir();
    }

public boolean mkdirs() 可以创建多级文件夹

 @Test
    void filetest1() throws IOException {

        File file = new File("B:\\workspace\\xuecheng\\test\\3\\4\\5");
        file.mkdirs();
    }

public static File createTempFile（） 在默认目录创建临时文件

 @Test
    void filetest1() throws IOException {
                                            //前缀         //后缀
        File tempFile = File.createTempFile("123", ".txt");
        File absoluteFile = tempFile.getAbsoluteFile();
        System.out.println(absoluteFile);
        tempFile.delete();
    }

遍历功能：

public String[] list() 获取当前文件夹中所有一级文件的名称返回到字符串数组中。

public File[] listFile() 获取当前文件夹中所有一级文件对象返回到文件对象数组中。

使用listFile()的注意事项：

当调用者不存在时，返回null。

当调用者是一个文件时，返回null。

当调用者是一个空文件夹时，返回长度为0的数组。

当调用者是一个有内容的文件夹时，将里面所有的文件和文件夹的路径返回到File数组。

当调用者是一个有隐藏文件的文件夹时，里面所有的文件和文件夹的路径返回到File数组，包含隐藏内容。

String编码：

byte[] getBytes() 使用平台默认的字符集将String编码为一系列字节，将结果储存到新的字符数组中。

byte[] getBytes(String charsetName) 使用指定的字符集（GBK等）将String编码为一系列字节，将结果储存到新的字符数组中。

String解码：

String(byte[] bytes) 使用平台默认的字符集将指定字节数组解码构造为新的String。

String(byte[] bytes，String charsetName) 使用指定的字符集将指定字节数组解码构造为新的String。

String(byte[] bytes，int offset,int length) 使用平台默认的字符集将指定字节数组解码构造为新的String，并且可以指定开始位置，和读取数据长度。

IO流：

IO流体系结构：

FileInputStream文件字节输入流

构造器：

public FileInputStream(File file)创建字节输入流管道（对象）与源文件对象接通。

public FileInputStream(String pathname)创建字节输入流管道（对象）与源文件路径接通。

常用方法：

public int read（）每次读取一个字节返回，如果没有字节可读返回-1。（读取中文可能会乱码，因为中文每个字符占3个字节，在读取字节的时候会截断）

public int read（byte[] buffer）每次读取一个字节s数组并接收到buffer中，函数返回到读取的字节个数，如果没有字节可读返回-1。（读取中文可能会乱码，因为中文每个字符占3个字节，可能在读取字节的时候会截断）

解决读取中文乱码问题：

1.定义一个与文件大小一样的byte[]数组（使用File.length来获取文件的大小，注意length返回的是long，需要强转）。】

@Test
    void filetest1() throws IOException {
        File file = new File("B:\\workspace\\xuecheng\\test\\1.txt");
        FileInputStream fileInputStream = new FileInputStream(file);
        byte[] bytes = new byte[(int)file.length()];
        fileInputStream.read(bytes);
        String s = new String(bytes);
        System.out.println(s);
        fileInputStream.close();
    }

2.JDK9中FileInputStream添加了读取全部字节的API。

public byte[] readAllBytes()将文件中的字节数据装到一个字节数组返回。

FileOutputStream文件字节输出流

构造器：

public FileOutputStream(File file) 创建一个字节输出流管道，与文件对象建立连接。（会直接覆盖源文件内容）

public FileOutputStream(String file) 创建一个字节输出流管道，与文件的路径建立连接。（会直接覆盖源文件内容）

public FileOutputStream(File file，boolean append) 创建一个追加的字节输出流管道，与文件的对象建立连接。

public FileOutputStream(String file，boolean append) 创建一个追加的字节输出流管道，与文件的路径建立连接。

常用方法：

public void write(int a) 写一个字节出去。

public void write(byte[] buffer) 写一个字节数组出去。

public void write(byte[] buffer，int pos，int len) 写一个字节数组的一部分出去。（pos是起始索引，len是长度）

释放资源：文件字节输入流和文件字节输出流都非常的消耗资源，使用完毕后一定要释放资源。

方法：

1.使用 try{

}catch{

}finally{

}

来释放资源，释放资源的语句要写在finally中，且释放前要判断对象是否为空。（释放语句为close）

2.JDK7添加了改进方案

try（）{

}catch{

}

将资源定义try后的括号内，可以实现自动释放。（JDK9改良后，括号内可以直接接收输入流对象和输出流对象，不过要抛出异常）

资源：指的是实现Closeable/AutoCloseable接口对象的类。

字符输入流Reader：

构造器:

public FileReader(File file)创建字符输入流管道（对象）与源文件对象接通。

public FileReader(String pathname)创建字符输入流管道（对象）与源文件路径接通。

方法：

public int read（）每次读取一个字符（字符的编码）返回，没有字符可读就返回-1。

public int read（char[] buffer）每次读取一个字符数组，返回读取的字符个数，没有字符可读就返回-1。

使用方法：

@Test
    void filetest1() throws IOException {
        FileReader fileReader = new FileReader("B:\\workspace\\xuecheng\\test\\1.txt");
        char[] buffer =new char[1024];
        int len;
        while ((len = fileReader.read(buffer))!=-1){
            String s = new String(buffer, 0, len);
            System.out.println(s);
        }
    }

字符输出流 Writer：

public FileWriter(File file)创建字符输出流，与原文件对象连通。

public FileWriter(File file,boolean append)创建字符输出流，与原文件对象连通,可追加数据。

public FileWriter(String filepath)创建字符输出流，与原文件路径连通。

public FileWriter(String filepath,boolean append)创建字符输出流，与原文件路径连通,可追加数据。

常用方法：

void write(int c) 写一个字符。

void write(char[] cbuf) 写一个字符数组。

void write(char[] cbuf，int off,int len) 写一个字符数组的一部分。

void write(String str) 写一个字符串。

void write(String str，int off,int len) 写一个字符串的一部分。

流的关闭与刷新：

flush() 刷新流，可以继续使用。

close(）关闭流，释放资源，但关闭前会刷新，关闭后不能使用。

缓冲流：

体系：

字节缓冲流：

字节缓冲输入流：BufferedInputStream,提高字节输入流读取数据的性能，读写并无变化。

字节缓冲输出流：BufferedOutputStream,提高字节输出流读取数据的性能，读写并无变化。

构造器：

public BufferedInputStream(InputStream is) 可以把低级的字节输入流包装成高级的字节输入缓冲流。

public BufferedOutputStream(OutputStream os) 可以把低级的字节输出流包装成高级的字节输出缓冲流。

字符缓冲流：

字符缓冲输入流BufferedReader：

构造器：

public BufferedReader(Reader r) 可以把低级的字符输入流包装成高级的字符输入缓冲流，从而提高性能。

新增方法：

public String readLine()读取一行并返回，无行可读返回null。

字符缓冲输出流BufferedWriter:

构造器：

public BufferedWriter(Writer w)可以把低级的字符输出流包装成高级的字符输出缓冲流，从而提高性能。

常用方法：

public void newLine() 换行操作。

转化流：

体系：

字符输入转换流InputStreamReader：

构造器：

public InputStreamReader(InputStream is,String charset)

可以把原始的字节输入流按照指定编码方式转化为字符输入流，这样就不会乱码了。

字符输出转换流OutputStreamWriter：

构造器：

public OutputStreamWriter(OutputStream os,String charset)

可以把原始的字节输出流按照指定编码方式转化为字符输出流

对象序列化：

作用：把内存中的对象存储到磁盘文件中，称为对象序列化。（对象如果要序列化，必须实现Serializable序列化接口,序列化的版本号与反序列化的版本号需要相同）

使用的流为对象字节输出流：ObjectOutputStream

体系：

构造器：

public ObjectOutputStream(OutputStream)把低级的字节输出流包装成对象字节输出流。

序列化方法：

public final void writeObject(Object obj)把对象写到对象序列化流的文件中。

对象反序列化：

作用：以内存为基准，把存储到磁盘文件中去的对象数据恢复成内存中的对象，称为对象反序列化。（如果对象的某一属性不想序列化，可以在定义属性前加transient）

使用的流为对象字节输入流：ObjectInputStream

体系：

构造器：

public ObjectInputStream(InputStream out)把低级字节输入流包装成高级的对象字节输入流

方法：

public ObjectreadObject()把存储到磁盘文件中去的对象数据恢复成内存中的对象并返回。

打印流：

作用：打印流可以实现方便，高效的打印数据到文件夹中去。打印流一般指PrintStream和PrintWriter。(可以实现打印什么数据就是什么数据)

体系：

PrintStream：

构造器：

public PrintStream(OutputStream os)打印流直接通向字节输出流管道。

public PrintStream(File file)打印流直接通向文件对象。

public PrintStream(String filepath)打印流直接通向文件路径。

方法：

public void print(XXX xxx)打印任意类型数据出去。

PrintWriter：

构造器：

public PrintWriter(OutputStream os)打印流直接通向字节输出流管道。（要写对文件追加内容，需要在低级管道这里声明，不能直接连接文件路径和对象）

public PrintWriter(Writer w)打印流直接通向字符输出流管道。

public PrintWriter(File file)打印流直接通向文件对象。

public PrintWriter(String filepath)打印流直接通向文件路径。

方法：

public void print(XXX xxx)打印任意类型数据出去。

PrintStream和PrintWriter的区别：

补充：输出语句的重定向

格式：

PrintStream ps = new PrintStream(“文件地址”)

System.setOut(ps);

作用：属于打印流的应用，可以把输出语句的打印位置改到文件。