I/O流以及文件的基本操作

文件操作：

文件操作其实就是一个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

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

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

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来实现对象的实例化；

读取文件的固定用法：

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

读取文件内容实例：

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(); 	// 关闭输出流
    }
}

----	----	----