Java--IO字节流

最新推荐文章于 2024-10-06 20:16:20 发布

一只勤劳的小蜜蜂Yy

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量384

点赞数 6

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/2301_77012210/article/details/140824752

版权

Java基础专栏收录该内容

30 篇文章 0 订阅

订阅专栏

一、File

1.1 概述

文件和目录路径名的抽象表示形式。
- 把文件管理系统中的字符串路径创建成为Java中的对象
- 具备了一些属性和方法，方便在程序中操作文件

1.2 创建对象

import java.io.File;

public class Demo02 {
    public static void main(String[] args) {
        /**
         * 构造方法摘要 
            File(String pathname) 
                      通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。 
            File(String parent, String child) 
                      根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。 
            File(File parent, String child) 
                      根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。 
         */
        // 创建File对象,路径指向D:\Files\JavaFiles\Java
        File file = new File("D:\Files\JavaFiles\Java");
        System.out.println(file);
        
        // Java资料文件夹根目录
        String pathname = "D:\Files\JavaFiles\Java";
        
        // 路径拼接
        File file2 = new File(pathname, "Day20");
        System.out.println(file2);
        System.out.println(file2.exists());
        
        File file3 = new File(file, "Day20");
        System.out.println(file3);
        System.out.println(file3.exists());
    }
}

路径的写法

import java.io.File;

public class Demo01 {
    public static void main(String[] args) {
        /**
         * D:\Files\JavaFiles\Java
         *  \   表示文件夹的层级
         *  \  需要偶数次出现
         *  /   一根就行
         */
        String pathName = "D:\Files/JavaFiles\\Java";
        System.out.println();
        
        File file = new File(pathName);
        System.out.println(file.getFreeSpace());
        System.out.println(file.getTotalSpace());
        System.out.println(file.exists());
        
        /**
         *  绝对路径
         *      https://www.baidu.com/
         *      D:\Files/JavaFiles\\Java
         *      把文件或者连接的全部路径都书写出来
         *      需要带有协议或者盘符，绝对路径是唯一的
         *  相对路径
         *      相对于当前的位置中的一个路径
         *      hello.txt
         *      world.txt
         *      不用书写盘符，不是惟一的【其他路径中也可能存在】
         */
        
        File file2 = new File("hello.txt");
        System.out.println(file2.exists());
        System.out.println(file2.getAbsolutePath());
        
    }
}

1.3 常用方法

增删改

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

public class Demo03 {
    public static void main(String[] args) throws IOException, InterruptedException {
        /**
         * 方法摘要 
         * 增
             boolean createNewFile() 
                      当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。 
             boolean mkdir() 
                      创建此抽象路径名指定的目录。 
             boolean mkdirs() 
                      创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。 
         
         * 删
             boolean delete() 
                      删除此抽象路径名表示的文件或目录。 
             void deleteOnExit() 
                      在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。 
         
         * 改
             boolean renameTo(File dest) 
                      重新命名此抽象路径名表示的文件。 
         */
        
        File file = new File("D:\Files\JavaFiles\Java");
        
        // 创建一级目录
        File file2 = new File(file, "Day22");
        System.out.println(file2.exists());
        boolean b = file2.mkdir();
        System.out.println(b);
        
        // 创建多级目录
        File file3 = new File(file, "Day23/笔记");
        System.out.println(file3.exists());
        b = file3.mkdirs();
        System.out.println(b);
        
        // 文件
        File file4 = new File(file, "hehe.txt");
        file4.createNewFile();
        
        // 不经过回收站,慎用
        // file4.delete();
        
        // 程序结束时候删除
        // file4.deleteOnExit();
        System.out.println("10S后删除...");
        
        // Thread.sleep(10000);
        System.out.println("OVER");
        
        File file5 = new File(file, "Day22");
        b = file5.delete();
        System.out.println(b);
        
        // 修改文件名
        File dest = new File(file, "hehehe.txt");
        b = file4.renameTo(dest);
        System.out.println(b);
    }
}

查询

import java.io.File;

public class Demo04 {
    public static void main(String[] args) {
        /**
         * 查
             boolean exists() 
                      测试此抽象路径名表示的文件或目录是否存在。 
             boolean isAbsolute() 
                      测试此抽象路径名是否为绝对路径名。 
             boolean isDirectory() 
                      测试此抽象路径名表示的文件是否是一个目录。 
             boolean isFile() 
                      测试此抽象路径名表示的文件是否是一个标准文件。 
             boolean isHidden() 
                      测试此抽象路径名指定的文件是否是一个隐藏文件。 
                      
             File getAbsoluteFile() 
                      返回此抽象路径名的绝对路径名形式。 
             String getAbsolutePath() 
                      返回此抽象路径名的绝对路径名字符串。 
             String getName() 
                      返回由此抽象路径名表示的文件或目录的名称。 
             String getParent() 
                      返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。 
                      
             long length() 
                      返回由此抽象路径名表示的文件的长度。 
             long getFreeSpace() 
                      返回此抽象路径名指定的分区中未分配的字节数。 
             long getTotalSpace() 
                      返回此抽象路径名指定的分区大小。 
             long getUsableSpace() 
                      返回此抽象路径名指定的分区上可用于此虚拟机的字节数。 

             File[] listFiles() 【重点】
                      返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。 
             File[] listFiles(FileFilter filter) 
                      返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。 
         */
        
        File file = new File("D:\Files\JavaFiles\Java");
        File file2 = new File(file, "hehehe.txt");
        System.out.println(file2.exists());
        System.out.println(file2.isDirectory());
        System.out.println(file2.isFile());
        System.out.println(file2.isHidden());
        System.out.println(file2.getName());
        System.out.println(file2.getParent());
        
        // 文件大小,字节
        System.out.println(file2.length());
        // 获取目录中所有的文件和文件夹
        File[] files = file.listFiles();
        for (File file3 : files) {
            System.out.println(file3);
        }
    }
}

二、文件过滤器

2.1 概述

筛选符合要求的文件或者文件夹

2.2 案例

import java.io.File;
import java.io.FileFilter;

public class Demo05 {
    public static void main(String[] args) {
        /**
         * 文件过滤器
         */
        
        File file = new File("D:\Files\JavaFiles\Java");
        
        // 创建文件过滤器
        FileFilter filter = new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.getName().endsWith(".txt");
            }
        };
        
        // 获取目录中所有符合过滤器要求的文件和文件夹
        File[] files = file.listFiles(filter);
        for (File f : files) {
            System.out.println(f);
        }
        
    }
}

2.3 递归获取文件和文件夹【考题】

import java.io.File;

public class Demo06 {
    public static void main(String[] args) {
        /**
         * 获取指定目录和子级目录中所有的文件和文件夹【阶段考试题目】
         */
        File file = new File("D:\Files\JavaFiles\Java2306");
        
        getFiles(file);
    }
    
    /**
     * 获取指定文件对象中所有的文件和文件夹
     * @param file  目标路径
     */
    public static void getFiles(File file) {
        // 获取file中所有的文件和文件夹
        File[] files = file.listFiles();
        
        // 遍历files
        for (File f : files) {
            // 判定f是文件还是文件夹
            if (f.isFile()) {
                System.out.println("\t文件:" + f);
            } else {
                System.out.println("文件夹:" + f);
                // 文件夹,调用方法查看所有文件和文件夹
                getFiles(f);
            }
        }
    }
}

三、字节输入流

3.1 概述

以字节为单位读取数据的流

3.2 继承体系

InputStream

抽象类
所有字节输入流对象的父类

FileInputStream

可以以字节为单位读取任意类型文件的输入流

3.3 FileInputStream

1、创建流对象，指定读取的文件
2、读取数据
    read(byte[] b)
3、关闭流

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

public class Demo02 {
    public static void main(String[] args) throws IOException {
        /**
         *  1、创建流对象
         *  2、读取数据
         *  3、关闭流
         */
        
        FileInputStream fis = new FileInputStream("hello.txt");
        
        byte[] b = new byte[4];
        
        /**
         * 读取数据，把读取得到的数据放入byte数组，返回读取字节的数量
         */
        int len = fis.read(b);
        System.out.println("读取内容的数量:" + len);
        System.out.println("第一次读取的数据:" + Arrays.toString(b));
        
        len = fis.read(b);
        System.out.println("读取内容的数量:" + len);
        System.out.println("第二次读取的数据:" + Arrays.toString(b));
        
        len = fis.read(b);
        System.out.println("读取内容的数量:" + len);
        System.out.println("第三次读取的数据:" + Arrays.toString(b));
        
        len = fis.read(b);
        System.out.println("读取内容的数量:" + len);
        System.out.println("第四次读取的数据:" + Arrays.toString(b));
        
        // 关闭流
        fis.close();
    }
}

四、字节输出流

4.1 概述

以字节为单位输出【写入】数据的流

4.2 继承体系

OutputStream

此抽象类是表示输出字节流的所有类的超类。

FileOutputStream

文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。
FileOutputStream 用于写入诸如图像数据之类的原始字节的流。

4.3 FileOutputStream

1、创建流对象，指明数据写入的文件
2、写入数据
3、关闭流

import java.io.FileOutputStream;
import java.io.IOException;

public class Demo03 {
    public static void main(String[] args) throws IOException {
        /**
         * 构造方法摘要 
            FileOutputStream(String name) 
                      创建一个向具有指定名称的文件中写入数据的输出文件流。 
            FileOutputStream(String name, boolean append) 
                      创建一个向具有指定 name 的文件中写入数据的输出文件流。 
         */
        /**
         * 创建字节输出流,指向Hello.txt
         *      1、文件名不区分大小写
         *      2、如果文件不存在，创建新的文件并写入数据
         *      3、boolean append
         *          如果布尔值是false 原文件中的内容被覆盖
         *          如果布尔值是true  在原文件内容后面追加新的内容
         */
        FileOutputStream fos = new FileOutputStream("hello.txt",true);
        
        /**
             void write(int b) 
                      将指定字节写入此文件输出流。 
             void write(byte[] b) 
                      将 b.length 个字节从指定 byte 数组写入此文件输出流中。 
             void write(byte[] b, int off, int len) 
                      将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。 
        
        fos.write(65);
        fos.write(66);
        fos.write(67);
        fos.write(68);
        fos.write(69);
        fos.write(70);
        fos.write(71);
         */
        
        byte[] b = new byte[] {72,73,74,75,76,77,78};
        fos.write(b, 3, 4);
        
        // 关闭流
        fos.close();
        
    }
}

4.4 复制文件

第一版

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo04 {
    public static void main(String[] args) throws IOException {
        /**
         *  1、创建流对象
         *      输入流 源文件
         *      输出流 目标位置和文件
         *  2、循环读写
         *  3、关闭流
         */
        long startTime = System.currentTimeMillis();
        
        FileInputStream fis = new FileInputStream("D:\人牛大战.mp4");
        FileOutputStream fos = new FileOutputStream("C:\Users\dushine\Desktop\人牛大战.mp4");
        
        // 循环读写
        int read = -1;
        while ((read = fis.read()) != -1) {
            fos.write(read);
        }
        
        // 关闭流
        fos.close();
        fis.close();
        
        long endTime = System.currentTimeMillis();
        
        System.out.println(endTime - startTime);
    }
}

第二版【数组】

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo05 {
    public static void main(String[] args) throws IOException {
        /**
         *  1、创建流对象
         *      输入流
         *      输出流
         *  2、循环读写
         *      创建byte数组
         *      创建计数器int len
         *  3、关闭流
         */
        long startTime = System.currentTimeMillis();
        // 创建流对象
        FileInputStream fis = new FileInputStream("D:\人牛大战.mp4");
        FileOutputStream fos = new FileOutputStream("C:\Users\dushine\Desktop\人牛大战.mp4");
        
        // 循环读写
        byte[] b = new byte[1024 * 8];
        int len = -1;
        
        while ((len = fis.read(b)) != -1) {
            fos.write(b, 0, len);
        }
        
        // 关闭流
        fos.close();
        fis.close();
        long endTime = System.currentTimeMillis();
        
        System.out.println(endTime - startTime);
    }
}

第三版【异常处理】【重点】【掌握】

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo06 {
    public static void main(String[] args) {
        /**
         *  1、创建流对象
         *      输入流
         *      输出流
         *  2、循环读写
         *      创建byte数组
         *      创建计数器int len
         *  3、关闭流
         */
        // 声明流变量
        FileInputStream fis = null;
        FileOutputStream fos = null;
        
        try {
            // 创建对象
            fis = new FileInputStream("D:\人牛大战.mp4");
            fos = new FileOutputStream("C:\Users\dushine\Desktop\人牛大战.mp4");
            // 循环读写
            byte[] b = new byte[1024 * 8];
            int len = -1;
            
            while((len = fis.read(b)) != -1) {
                fos.write(b, 0, len);
            }
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭流,关闭之前判定是否为null
            try {
                if (fos != null) {
                    fos.close();
                }
                
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("OVER");
    }
}

五、缓冲流

5.1 概述

减少IO的次数，提高IO性能
在字节流基础上进行包装

5.2 案例代码

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) throws IOException {
        /**
         *  缓冲流：减少IO的次数
         *  1、创建流对象
         *  2、循环读写
         *  3、关闭流
         */
        long startTime = System.currentTimeMillis();
        // 创建对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\software\BigFile.zip"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\Users\dushine\Desktop\BigFile.zip"));
        
        // 循环读写
        byte[] b = new byte[1024 * 1024 * 8];
        int len = -1;
        
        while ((len = bis.read(b)) != -1) {
            bos.write(b, 0, len);
        }
        
        // 清空缓冲区
        bos.flush();
        
        // 关闭流
        bos.close();
        bis.close();
        
        long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime);
        
    }
}