【Java】 I/O-CSDN博客

本文链接：https://blog.csdn.net/weixin_45468845/article/details/107319895

File类

这是流对象里面最基础，最根本的一个类。
File类并不只是指定单纯的文件，可能它的名字有一定的误导性。
它既能代表一个特定文件的名称，又能代表一个目录下的一组文件的名称

通过File得到文件信息：

import java.io.*;
/**
 * File类的基本用法
 */
public class UseFile {
    public static void main(String[] args) {
        //创建一个文件对象
        File f = new File("d:\\a.txt");

        //得到文件路径
        System.out.println("文件路径：" + f.getPath());
        System.out.println("文件路径：" + f.getAbsolutePath());

        //得到文件字节大小
        System.out.println("文件大小：" + f.length() + "字节");

        //判断文件是否可读写
        System.out.println("文件可读：" + f.canRead());
        System.out.println("文件可写：" + f.canWrite());
    }
}

在这里插入图片描述

创建文件 createNewFile()

import java.io.*;

public class CreateFile {
    public static void main(String[] args) throws IOException {
        File f = new File("d:\\createfile.txt");
        if (!f.exists()){//如果f不存在
            f.createNewFile();//创建文件
        }else {
            System.out.println("文件已存在！");
        }
    }
}

创建文件夹 mkdir()

import java.io.*;

public class CreateFile {
    public static void main(String[] args) throws IOException {
        File f = new File("d:\\文件夹");
        if (!f.exists()){//如果f不存在
            f.mkdir();//创建文件夹
        }else {
            System.out.println("文件夹已存在！");
        }
    }
}

列出目录下的文件 listFiles()

import java.io.*;

public class ListFile {
    public static void main(String[] args) {
        File f = new File("d:\\英语");
        if (f.isDirectory()){//判断是否为文件夹
            File lists[] = f.listFiles();//列出文件
            for (File file : lists){
                System.out.println(file);
            }
        }
    }
}

在这里插入图片描述

流

文件在程序中是以流的形式来操作的
在这里插入图片描述

如何判断是输入流还是输出流
以内存为参照，如果数据向内存流动，则是输入流
离开内存则是输出流

Java流分为两种流：

字节流
以字节方式读取的流
可以用于读写二进制文件及任何类型文件
字符流
以字符方式读取的流
可以用于读写文本文件（记事本可以打开的文件）

	字节流	字符流
输入	InputStream	Reader
输出	OutputStream	Writer

装饰者模式

Java的I/O体现了装饰者模式：

最基本的FileInputStream中，文件被一个一个读取，再传递到文件中
在这里插入图片描述
BufferedInputStream中，FileInputStream读取后的内容先放到一个BufferedInputStream缓冲区中，最后一起传递到文件中。

下图中，FileInputStream读取后的内容先被InputStreamReader转换为UTF-8格式，然后放入InputStreamReader的缓冲区中。
在这里插入图片描述

常用I/O流

在这里插入图片描述

文件字节流

读取文件

文件字节输入流使用
在这里插入图片描述
File文件不具有读取文件的权力，可以借助InputStream来读取文件，
就好比你拿衣服的时候，有的衣服可能位置比较高，不借助任何工具你是拿不到的，要用衣服撑(我不知道叫什么)才能拿到，FileInputStream就好比是衣服撑，你要借助这个工具才能达到自己的目标。

import java.io.*;

/**
 * FileInputStream 类的使用
 */
public class ReadFile {
    public static void main(String[] args) {
        //得到一个文件对象 f->"d:\\a.txt"
        File f = new File("d:\\a.txt");
        FileInputStream fis = null;
        try {
            //因为File没有读写的能力，所以要使用InputStream流
             fis = new FileInputStream(f);

            //定义一个字节数组,相当于缓存
            byte []bytes = new byte[1024];

            //得到实际读取到的字节数
            int n = 0;

//            if ((n =fis.read(bytes)) != -1){
//                String s = new String(bytes, 0, n);
//                System.out.println(s);
//            }
            //循环读取(因为并不知道文件有多大),当读取到文件末尾时返回-1
            while ((n = fis.read(bytes)) != -1){
                //把字节转成String
                String s = new String(bytes, 0, n);
                System.out.println(s);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流（必须放在这里）
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

写入文件

import java.io.*;

public class WriteFile  {
    public static void main(String[] args) {
        File f = new File("d:\\a.txt");

        //字节输出流
        FileOutputStream fos = null;

        try {
            fos = new FileOutputStream(f);

            String s = "旭哥太帅了！";

            //定义字节数组
            byte [] bytes = new byte[1024];

            //如何把String转换为byte数组
            fos.write(s.getBytes());
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

换行:在字符串后面加上 \r\n

图片拷贝

FileInputStream
FileOutputStream
将D盘下的d.jpg拷贝到E盘并命名为e.jpg

import java.io.*;

/**
 * 图片拷贝
 * 思路：
 * 1.图片读入内存
 * 2.写入到某个文件
 * 3.因为图片是二进制文件，因此只能用字节流完成
 */
public class CopyPic {
    public static void main(String[] args) {
        //File f = new File("c:\\a.jpg");
        //输入流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("d:\\d.jpg");
            fos = new FileOutputStream("e:\\e.jpg");
            byte buf[] = new byte[1024];

            int n = 0;//记录实际读取到的字节数

            while ((n = fis.read(buf)) != -1) {
                //输入出到指定文件
                fos.write(buf);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

文件字符流

FileReader
FileWriter
案例：读取一个文件并写入到另一个文件中

import java.io.*;

/**
 * 演示文件字符流，将一个文件拷贝到另一个位置
 */
public class CopyFile {
    public static void main(String[] args) {
        FileReader reader = null;
        FileWriter writer = null;

        try {
            reader = new FileReader("d:\\a.txt");

            writer = new FileWriter("d:\\to.txt");
            //读入到内存
            char c[] = new char[1024];
            int n = 0;//记录实际读取的字符数
            while ((n = reader.read(c)) != -1){
                //String s = new String(c, 0 ,n);
                //System.out.println(s);
                //将c中0~n个字节的内容写入输出流
                writer.write(c, 0, n);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                writer.close();
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

定义缓存数组时，文件字节流使用byte[] 数组，文件字符流使用char[] 数组，因为一个是字节，一个是字符

缓冲字符流

BufferReader
BufferWriter

可以提高效率，引入了缓冲字符流
可以直接操作String

import java.io.*;

public class BufferStream {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;

        try {
            //先创建一个FileReader，升级为BuuferedReader
            FileReader fr = new FileReader("d:\\a.txt");
            br = new BufferedReader(fr);

            FileWriter fw = new FileWriter("d:\\buffered.txt");
            bw = new BufferedWriter(fw);
            String s = "";

            while ((s = br.readLine()) != null) {
                bw.write(s + "\r\n");//换行
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

readline读取一个文本行。通过下列字符之一即可认为某行已终止：换行 (’\n’)、回车 (’\r’) 或回车后直接跟着换行。
返回：包含该行内容的字符串，不包含任何行终止符（结果不会换行），如果已到达流末尾，则返回 null

解析：

	byte []bytes = new byte[1024];
	int n = 0;
	while ((n = fis.read(bytes)) != -1){   }

先将读取的文件内容放到一个字节数组中，字节数组满，进入下一次读取，直到读取至文件末尾。n就是记录读取了多少字节。

举个例子，在喝可乐的时候，不能直接咕嘟咕嘟一下把一瓶可乐直接喝掉，要先在嘴里含一口，然后再喝下去，把可乐含在嘴里的这一个步骤就相当于缓存。这个过程中，嘴就相当于byte[] 数组。

简单的记事本

可以参考下面的一个案例，熟悉I/O流操作文件
https://blog.csdn.net/weixin_45468845/article/details/107333422