Java基础内容（IO流）

最新推荐文章于 2024-07-20 23:59:39 发布

File~

最新推荐文章于 2024-07-20 23:59:39 发布

阅读量133

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_57259816/article/details/124239659

版权

File

如何创建File类的实例
1. File(String filePath)
2. File(String parentPath,String childPath)
3. File(File parentFile,String childPath)
相对路径和绝对路径

①相对路径：相较于某个路径下，指明的路径

②绝对路径：包含盘符在内的文件或文件目录的路径
路径分隔符

①windows：\\

②unit：\

File类的获取功能

public String getAbsolutePath(); 获取绝对路径
public String getPath()：获取路径
public String getName()：获取名称
public String getParent()：获取上层文件目录路径。若无，返回null
public long length()：获取文件长度（即：字节数）。不能获取目录的长度
public long lastModified()：获取最后一次的修改时间，毫秒数
public String[] list()：获取指定目录下的所有文件或者文件目录下的名称数组
public File[] listFiles()：获取指定目录下的所有文件或者文件目录的File数组

File类的重命名功能

public boolean renameTo(File dest)：把文件重命名为指定的文件路径

File类的判断功能

public boolean isDirectory()：判断是否是文件目录
public boolean isFile()：判断是否是文件
public boolean exists()：判断是否存在
public boolean canRead()：判断是否可读
public boolean canWrite()：判断是否可写
public boolean isHidden()：判断是否隐藏

创建硬盘中对应的文件或文件目录

public boolean createNewFile()：创建文件，若文件存在，则不创建，返回false；
public boolean mkdir()：创建文件目录。如果此文件目录存在，就不创建了，如果此文件目录的上层目录不存在，也不创建。
public boolean mkdirs()：创建文件目录。如果上层文件目录不存在，一并创建。

删除磁盘中的文件或文件目录

public boolean delete()：删除文件或者文件夹

删除注意事项：

Java中的删除不走回收站

File类的使用

File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)
File类声明在java.io包下
File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成
后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点"

流的分类

①按照操作数据单位不同分为：字节流(8 bit) 适用于图片，视频、字符流(16 bit) 适用于内容存储

②按数据流的流向不同分为：输入流、输出流

③按流的角色不同分为：节点流、处理流

抽象基类	节点流	字符流
输入流	InputStream	Reader
	OutputStream	Write

Java的IO流共涉及到40多个类，实际上非常规则，都是从如下4个抽象基类派生的

由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pYFpUWis-1650211438969)(D:\北大青鸟学习文件夹\杨佳涵JavaEE\Java基础笔记\image-20220406103157812.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kBD0e8MY-1650211438970)(D:\北大青鸟学习文件夹\杨佳涵JavaEE\Java基础笔记\image-20220406110851998.png)]

一、流的分类：

操作数据单位：字节流、字符流
数据的流向：输入流、输出流
流的角色：节点流、处理流

二、流的体系结构

抽象基类	节点流（或文件流）	缓冲流（处理流的一种）
InputStream	FileInputStream	BufferedInputStream
OutputStream	FileOutputStream	BufferedOutputStream
Reader	FileReader	BufferedReader
Write	FIleWriter	BufferedWrite

/**
     *  说明点：
     *  1.read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
     *  2.异常的处理：为了保证流的资源一定可以执行关闭操作。需要使用try-catch-finally处理
     *  3.读入的文件一定要存在，否则就会报FileNotFoundException
     */
    @Test
    public void show(){
        FileReader reader = null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file2 = new File("Hello.txt");
            //2.提供具体的流
            reader = new FileReader(file2);
            //3.数据的读入
            //read():返回读入的一个字符，如果达到文件末尾，返回-1
            int read = 0;
            while((read=reader.read()) != -1){
                System.out.print((char)read);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流
            try {
                if(reader != null)
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 读取文件的另一种方式
     */
    @Test
    public void show2(){
        FileReader reader = null;
        try {
            //1.实例化File对象，指明要操作的文件
            File file = new File("Hello.txt");
            //2.提供具体的流
            reader = new FileReader(file);
            //3.数据的读入
            int read;
            char[] cbuf = new char[5];
            while((read=reader.read(cbuf))!= -1){
                /*//第一种方式:通过for循环遍历输出
                for (int i = 0; i < read; i++) {
                    System.out.print(cbuf[i]);
                }
*/
                //第二种方式:通过char[]数组转为字符串输出
                String s = new String(cbuf,0,read);
                System.out.print(s);
            }


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(reader != null){
                //4.关闭流
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     *  写入数据
     */
    @Test
    public void show3(){
        FileWriter fileWriter = null;
        try {
            //1.实例化File对象，指明要操作的文件
            File file = new File("Hello1.txt");
            //2.提供FileWrite的对象，用于数据的写入
            fileWriter = new FileWriter(file,true);
            //3.具体的写入操作
            fileWriter.write("我爱伟大的祖国\n");
            fileWriter.write("中华人民共和国万岁!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileWriter != null){
                //4.关闭流
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    /**
     * 文件的输入输出：复制
     */
    @Test
    public void show4(){
        FileReader reader = null;   //读入
        FileWriter writer = null;  //写出
        try {
            //1.实例化File对象，指明操作的对象
            File file = new File("Hello.txt");  //输出
            File file2 = new File("Hello2.txt");//输入
            //2.提供FileReader和FileWrite对象，用于数据读入写出
            reader = new FileReader(file);
            writer = new FileWriter(file2);
            //3.具体的读入和写出操作
            char[] chars = new char[5]; //用于计算每一次读入的长度
            int len;    //计算读入每一次有多少条数据
            while((len = reader.read(chars)) != -1){    //判断读入的数组中是否有数据
                writer.write(chars,0,len);  //把数组中的数据写入到hello2.txt中
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流
            if(reader != null){ //判断读入流是否为空
                try {
                    reader.close(); //关闭读入流
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(writer != null){ //判断写入流是否为空
                try {
                    writer.close(); //关闭写入流
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }

InputStreamReader：将输入的字节流转换为输入的字符流。解码

OutputStreamWrite：将输入的字符串转换为输出的字节流。编码

序列化与反序列化：

举例：Person需要满足如下要求，方可序列化

需要实现接口：Serializable
当前类提供一个全局常量：serialVersionUID
除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性必须是可序列化的。（默认情况下，基本数据类型可序列化）

对象流的使用

ObjectInputStream 和 ObjectOutputStream
作用：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以吧Java中的对象序列化
要想一个java对象是可序列化的，需要满足相应的要求
序列化机制：

对象序列化允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或者通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以回复成原来的Java对象