文件操作：

这是我参与8月更文挑战的第31天，活动详情查看：8月更文挑战

文件操作其实就是一个FIle类；我们学习文件操作就是学习File类中的方法；

文件基操：

第一部分：学习文件的基本操作(先扒手册)

Constructor	Description
`File(File parent, String child)`	给定要操作的问价的父路径和子文件名称
`File(String pathname)`	给定一个要操作文件的完整路径

Modifier and Type	Method	Description
boolean	public boolean createNewFile() throws IOException	创建文件
`boolean`	`delete()`	删除文件
`boolean`	`exists()`	判断给定路径是否存在

来个实例：

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

public class FIleDelCre {
    public static void main(String[] args) throws IOException {
        File file = new File("e:\\IOFileSource\\xbhog.txt");
        if(file.exists()){
            file.delete();
        }else{
            System.out.println(file.createNewFile());
        }
    }
}

createNewFile：如果指定的文件不存在且已成功创建，则为True;如果指定的文件已经存在，则为False

知识点(敲黑板)：

路径分隔符：解决不同操作系统下的路径符号问题（windows->“\”;Linux->“/”）;

File file = new File("e:"+File.separator +"IOFileSource"+File.separator+"xbhog.txt");

注：

/**
     * The system-dependent default name-separator character, represented as a
     * string for convenience.  This string contains a single character, namely
     * {@link #separatorChar}.
*/
public static final String separator = "" + separatorChar;

对父路径操作的方法：

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

public class FIleDelCre {
    public static void main(String[] args) throws IOException {
        File file = new File("e:"+File.separator +"IOFileSource"+File.separator+"test"+File.separator+"demo"+File.separator+"xbhog.txt");
        if(!file.getParentFile().exists()){ //如果该文件的父目录不存在
            /*
            file.getParentFile().mkdirs();   //进行创建多级父目录
            mkdirs底层进行递归调用，实现多级目录创建

            file.getParentFile().mkdir();   //进行创建一个父目录
            */
        }
        if(file.exists()){
            file.delete();
        }else{
            System.out.println(file.createNewFile());
        }
    }
}

注：mkdirs与mkdir的区别，最好进入源码中查看

文件列表显示：

流程图：

import java.io.File;
public class FilePwd {
    public static void main(String[] args) {
        File file = new File("D:" + File.separator);
		listDir(file);
    }
    public static void listDir(File file){
        if(file.isDirectory()){
            File[] Dirs = file.listFiles();
            while(Dirs != null){
                for (int i = 0; i < Dirs.length; i++) {
                    listDir(Dirs[i]);  //递归调用
                }
            }
        }
        System.out.println(file);
    }
}

文件批量更名：

情景：

在数据采集的过程中由于操作失误，使得xbhog-log文件夹下的所有文件后缀采用了.java,为了修正这一错误，要求使得该目录下的所有文件后缀统一替换成.txt,同时也需要考虑多级目录下的文件更名操作。

import java.io.File;
public class FIleChangeName {
    public static void main(String[] args) {
        File file = new File("D:" + File.separator + "xbhog-log");
        renameDir(file);

    }
    public static void renameDir(File file){
        if(file.isDirectory()){
            File[] dirs = file.listFiles(); 
            for (int i = 0; i < dirs.length; i++) {
                renameDir(dirs[i]);  //递归调用
            }
        }else {
            if (file.isFile()){ //历经为文件
                String fileName = null;  //文件名称
                if(file.getName().endsWith(".java")){  //判断是否以.java为结尾
                    fileName = file.getName().substring(0,file.getName().lastIndexOf("."))+".txt";
                    File newfile = new File(file.getParentFile(), fileName);  //新的文件名称
                    file.renameTo(newfile);  //重命名
                }
            }
        }
    }
}

字节流与字符流：

字节流：outputStream以及inputStream

字符流：Writer以及Reader

对资源操作的基本步骤：(文件为例)--严格按照下面步骤

如果要操作的资源是文件的话，首先需要通过File类对象找到一个要操作的文件路径
通过字节流或者字符流的子类为字节流或字符流的对象实例化(向上转型)
执行读写操作
关闭资源

OutputStream字节输入流

常用的类普通方法：

Modifier and Type	Method	Description
`void`	`close()`	关闭此输出流并释放与此流关联的任何系统资源。
`void`	`flush()`	刷新此输出流并强制写入任何已缓冲的输出字节。
`void`	`write(byte[] b)`	输出单个字节数据
`void`	`write(byte[] b, int off, int len)`	输出部分字节数据
`abstract void`	`write(int b)`	输出一组字节数据

对文件的操作需要其OutputStream下的子类FileOutputStream来实现对象的实例化；

其常用的构造方法是：

Constructor	Description
`FileOutputStream(File file)`	创建一个文件输出流，以写入由指定file对象表示的文件。
`FileOutputStream(File file, boolean append)`	创建一个文件输出流，以写入由指定file对象表示的文件。如果第二个参数为真，则字节将被写到文件的末尾而不是开头

实例：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;

public class FIleOutputStearm {
    public static void main(String[] args) throws IOException {
        File file = new File("xbhog.txt");
        if(!file.exists()){
            file.createNewFile();
        }
        OutputStream outputStearm = new FileOutputStream(file);
        String str = "欢迎来到xbhog的博客";
        outputStearm.write(str.getBytes(StandardCharsets.UTF_8));
        outputStearm.close();
    }
}

文件内容的追加：

    OutputStream stream = new FileOutputStream(file, true);
    String addStr = "-----这是追加的内容------";
    stream.write(addStr.getBytes());
    stream.close();

InputStream字节输入流：

该类的常用方法：

Modifier and Type	Method	Description
`void`	`close()`	关闭输出流
`abstract int`	`read()`	读取单个字节数据，如果现在已经读取到底了，返回-1
`int`	`read(byte[] b)`	读取一组字节数据，返回的是读取的个数，如果没有数据已经读取到底则返回-1
`int`	`read(byte[] b, int off, int len)`	读取一组字节数据（只占数组的部分）
`byte[]`	`readAllBytes()`	读取输入流全部字节数据，JDK 1.9后新增
`long`	`transferTo(OutputStream out)`	输入流转存到输出流，JDK 1.9之后新增

对文件的操作需要其InputStream下的子类FileInputStream来实现对象的实例化；

读取文件的固定用法：

创建文件输入流---InputStream input = new FileInputStream(file)
设置数据的读取缓存区----new byte[1024]
读取数据，将数据读取到缓存区中并放回读取的字节个数 ----int len = input.read(data)
字节转换为字符流----new String(data,0,len)
关闭资源

读取文件内容实例：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class FileInputStreamTest {
    public static void main(String[] args) throws IOException {
        File file = new File("xbhog.txt"); // 输出文件路径
        if (file.exists()) {    // 文件存在
            InputStream input = new FileInputStream(file);// 文件输入流
            byte data[] = new byte[1024]; // 数据读取缓冲区
            // 读取数据，将数据读取到缓冲区之中，同时返回读取的字节个数
            int len = input.read(data);
            System.out.println("【" + new String(data, 0, len) + "】");// 字节转为字符串
            input.close();    // 关闭输入流

        }
    }
}

读取文件中的全部内容：

byte[] bytes = input.readAllBytes();
System.out.println(new String(bytes));

Writer字符流：

为了简化输出的操作，提供了Writer与Reader字符流;

该类的常用方法：

Modifier and Type	Method	Description
`Writer`	`append(char c)`	将指定的字符写入。
`Writer`	`append(CharSequence csq)`	将指定的字符序列附加到此编写器。
`Writer`	`append(CharSequence csq, int start, int end)`	将指定字符序列的子序列追加到此编写器
`abstract void`	`close()`	关闭资源
`abstract void`	`flush()`	刷新资源流
`void`	`write(char[] cbuf)`	写入一组字符数组
`abstract void`	`write(char[] cbuf, int off, int len)`	写入一组字符数组的一部分
`void`	`write(int c)`	写入一个字符
`void`	`write(String str)`	写入一个字符串
`void`	`write(String str, int off, int len)`	写入一个字符串的一部分

在进行文件流的写入时，需要引入Writer下的FileWriter子类；

类的项目结构：

java.lang.Object

java.io.Writer

java.io.OutputStreamWriter

java.io.FileWriter

FileWriter常用构造方法：

Constructor	Description
`FileWriter(File file)`	给定File对象，构造一个FileWriter对象。
`FileWriter(String fileName, boolean append)`	构造一个给定文件名的FileWriter对象，该文件名带有一个布尔值，该布尔值表示是否追加写入的数据。

实例：

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("FileWriter.txt"); // 输出文件路径
        if(!file.exists()){
            file.createNewFile();
        }
        Writer out = new FileWriter(file) ; // 实例化Writer类对象
        out.write("欢迎来到xbhog");	// 输出字符串
        out.write("\n");
        out.append("Test\n");
        out.append("www.cblog.cn/xbhog") ;// 追加输出内容
        out.close();// 关闭输出流
    }
}

Reader字符输入流：

该类常用的方法：

Modifier and Type	Method	Description
`abstract void`	`close()`	关闭资源
`int`	`read()`	读取单个字符
`int`	`read(char[] cbuf)`	将字符放入数组
`long`	`skip(long n)`	跳过字符(几个)
`boolean`	`ready()`	判断这个流是否已准备好了读取了

实例测试：

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("FileWriter.txt");// 输出文件路径
        if (file.exists()) {// 文件存在
            Reader in = new FileReader(file);  // 实例化输入流
            char data[] = new char[1024];  // 缓冲区
            //“欢迎没有了”
            in.skip(2);// 跨过2个字符长度
            int len = in.read(data); // 读取数据
            System.out.println(new String(data, 0, len));
            in.close();// 关闭输入流
        }
    }
}

转换流：

转换流	OutputStreamWriter	InputStreamReader
继承结构	public class OutputStreamWriterextends Writer {}	public class InputStreamReaderextends Reader
构造方法	public OutputStreamWriter(OutputStream out)	public InputStreamReader(InputStream in)

实现两者的转换操作：

将字节输入流转换成字符输入流

import java.io.*;
public class ConversionOperations {
    public static void main(String[] args) throws IOException {
        File file = new File("FileWriter1.txt"); 	// 输出文件路径
        OutputStream output = new FileOutputStream(file) ;// 字节流
        Writer out = new OutputStreamWriter(output) ; 	// 字节流转字符流
        out.write("测试两者之间的转换"); // 字符流输出
        out.close();	// 关闭输出流
        output.close(); 	// 关闭输出流
    }
}

结束：

如果你看到这里或者正好对你有所帮助，希望能点个👍或者⭐感谢；

有错误的地方，欢迎在评论指出，作者看到会进行修改。

Java基础之文件以及流操作