Java基础进阶_day10_(File类,IO,字节流)

最新推荐文章于 2023-07-17 16:45:05 发布

Sunmos

最新推荐文章于 2023-07-17 16:45:05 发布

阅读量624

点赞数

分类专栏： Java进阶文章标签： java io流 file

本文链接：https://blog.csdn.net/L631106040120/article/details/70188520

版权

Java进阶专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Java基础进阶_day10_(File类,IO,字节流)

1. File类

File类:文件和目录(文件夹)路径名的抽象表示.

1.1 构造方法

public File(String pathname):根据路径名得到File对象,不论指向的文件是否存在都会创建对象;
public File(String parent,String child):根据一个目录和一个子文件夹/目录得到File对象;
public File(File parent,String child):根据一个父File对象和一个子文件夹/目录得到File对象.

# 注意事项:
    当参数没有盘符路径时,默认是在当前项目路径下;
    File的方法都是无参数的,则表示创建File对象时要指向要进行具体操作的文件或文件夹.

1.2 成员方法

1.2.1 创建功能

public boolean createNewFile():在指定文件夹下创建一个文件,指定的文件夹必须存在(否则报错),如果文件不存在就创建并返回true,如果文件已经存在,不创建并返回false;
public boolean mkdir():创建File对象指定的目录,父级目录必须存在(否则返回false),如果指定目录不存在就创建并返回true,如果目录已经存在,就不创建并返回false;
public boolean mkdirs():创建File对象指定的目录,包括所有必需但不存在的父目录,如果指定目录不存在就创建并返回true,如果目录已经存在,就不创建并返回false;

# 注意事项:
    File对象指向要创建的文件或目录名,调用对象的方法创建相应的文件或目录;
    File对象的创建功能的方法只能创建对应的文件或文件夹,mkdir和mkdirs方法只能创建文件夹.

1.2.2 删除功能

public boolean delete():删除File对象指定的文件或文件夹,删除成功返回true,否则返回false

# 注意:Java程序中删除文件是不进入回收站的,当要删除的文件夹还有子文件或文件夹时,不能删除(必须是空文件夹才能删除).

1.2.3 重命名功能

public boolean renameTo(File dest):对文件进行重命名

# 注意:当两个文件路径相同,就是对文件重命名,如果两个文件路径不同(dest对象中不能有不存在的目录,否则返回false),就是文件重命名并剪切移动到新的目录下.

1.2.4 判断功能

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

1.2.5 获取功能

public String getAbsolutePath():获取文件或文件夹绝对路径
public String getPath():获取文件或文件夹相对路径
public String getName():获取文件或文件夹的名称
public long length():获取文件的长度,字节数
public long lastModified():获取文件最后一次被修改的时间
public String[] list():获取指定目录下所有文件或者文件夹的名称的数组,相对路径
public File[] listFiles():获取指定目录下所有文件或文件夹的File数组,文件的绝对路径
public String[] list(FilenameFilter filter):按照指定文件名过滤器过滤后的文件名数组
public File[] listFiles(FilenameFilter filter):按照指定文件名过滤器过滤后的文件对象数组

1.3 文件过滤器

FilenameFilter类:文件过滤器接口:该接口只有一个抽象方法.

boolean accept(File dir,String name):测试指定文件是否应该包含在某一文件列表中.

1.4 案例代码

public class MyFileDemo {
    public static void main(String[] args) throws IOException {
        // 构造方法测试
        // test01();
        // 创建功能和删除功能测试
        // test02();
        // 重命名功能
        // test03();
        // 判断功能
        // test04();
        // 获取功能
        // test05();
        // 获取文件过滤器过滤后的文件
        // 获取F:目录下以.java结尾的文件
        // test06();
    }
    public static void test06() {
        File file = new File("F:");
        String[] list = file.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                // dir表示的是获取的文件夹,name表示获取的文件名称
                // 获取该文件的File对象
                // File file2 = new File(dir, name);
                // return file2.isFile() && name.endsWith(".java");
                return new File(dir, name).isFile() && name.endsWith(".java");
            }
        });
        // 输出符合条件的文件名
        for (String string : list) {
            System.out.println(string);
        }
    }
    public static void test05() {
        File file = new File("java\\java.java");
        System.out.println(file.getAbsolutePath());
        System.out.println(file.getParent());
        System.out.println(file.getName());
        System.out.println(file.length());
        long lm = file.lastModified();
        Date d = new Date(lm);
        String string = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(d);
        System.out.println(string);
        // public String[] list()
        File file2 = new File("F:");
        String[] list = file2.list();
        for (String s : list) {
            System.out.println(s);
        }
        // public File[] listFiles()
        File[] listFiles = file2.listFiles();
        for (File file3 : listFiles) {
            System.out.println(file3.getName());
        }
    }
    public static void test04() {
        File file = new File("a.txt");
        System.out.println(file.isDirectory());
        System.out.println(file.isFile());
        System.out.println(file.exists());
        System.out.println(file.canRead());
        System.out.println(file.canWrite());
        System.out.println(file.isHidden());
    }
    public static void test03() {
        File file = new File("java\\java.java");
        // File newFile = new File("F:\\demo\\java.txt"); // F:下没有demo文件夹,false
        // File newFile = new File("F:java\\java.txt"); // F:下没有demo文件夹,false
        File newFile = new File("F:java.txt"); // 将文件重命名并移动到F:根目录下,true
        System.out.println(file.renameTo(newFile));
    }
    public static void test02() throws IOException {
        // public boolean createNewFile()
        File file5 = new File("F:\\java.txt");
        System.out.println(file5.createNewFile()); // true
        // public boolean mkdir()
        File file6 = new File("F:\\demo\\java");
        System.out.println(file6.mkdir());
        // public boolean mkdirs()
        File file7 = new File("F:\\demo\\java\\develop");
        System.out.println(file7.mkdirs());
        File file8 = new File("F:\\demo\\java\\develop.txt");
        System.out.println(file7.mkdirs()); // 创建的是文件名为develop.txt的文件夹
        // public boolean delete()
        File file9 = new File("java");
        System.out.println(file9.delete()); // false
    }
    public static void test01() {
        // public File(String pathname):根据路径名得到File对象;
        // 将F:\\java\\hello.txt封装成File对象,file对象只是抽象的表示,需要调用相应的方法才能操作文件或文件夹
        File file = new File("F:\\java\\hello.txt");
        // public File(String parent,String child):根据一个目录和一个子文件夹/目录得到File对象;
        File file2 = new File("F:\\java", "hello.txt");
        // public File(File parent,String child):根据一个父File对象和一个子文件夹/目录得到File对象.
        File file3 = new File("F:\\java");
        File file4 = new File(file3,"F:\\java");
        // 上述三种创建File对象的效果相同,一般选用第一钟
    }
}

2. IO流

IO:用类处理设备间的数据传输(文件上传和下载)问题.

# 注意:
    Java对数据的操作是通过流的方式;
    Java用于操作流的对象都在IO包中;
    Java中的IO流的方向是相对于Java程序而言的.

2.1 IO流分类

# 按照数据流向:针对Java程序而言.
    输入流:读入数据
    输出流:写出数据
# 按照数据类型:
   * 字节流:
        字节输入流:InputStream抽象类是所有字节输入流的根类;
        字节输入流:OutputStream抽象类是所有字节输出流的根类.
   * 字符流:是在字节流的基础之上添加了编码表
        字符输入流:Reader抽象类是所有字符输入流的根类;
        字符输出流:Writer抽象类是所有字符输出流的根类.
# 注意事项:
    字节流和字符流的基类抽象类的子类均是以对象基类名为后缀(如:XxxInputStream,XxxReader);
    字节输出流写数据是将数据直接写到文件,可以不使用flush()刷新缓冲区的方式;
    字符输出流写数据是先将数据写到缓冲区,可以使用flush()将缓冲区的数据写到文件.
    输入流读取的文件必须先要存在,否则出现FileNotFoundException异常;
    输出流要输出的文件可以不存在,输出时会默认创建该文件,但是不能创建文件夹.

2.2 转义字符和路径问题

# 转移字符:\\代表单\,\t代表制表符,\r\n代表是回车键
# 路径:
    绝对路径:以盘符开始的完整路径(d:\\a.txt)
    相对路径:相对于当前项目而言,文件会创建在项目的根目录下(a.txt);

2.3 FileOutputStream类

FileOutputStream类:是字节输出流的具体实现类.

2.3.1 构造方法

FileOutputStream(File file):创建指向File对象的字节输出流,如果文件存在则将内容清空,不存在就创建文件;
FileOutputStream(File file, boolean append):创建指向File对象的字节输出流,追加写数据;
FileOutputStream(String name):创建指向具体文件的字节输出流,如果文件存在则将内容清空,不存在就创建文件;
FileOutputStream(String name, boolean append):创建指向具体文件的字节输出流,追加写数据;

2.3.2 字节输出流写文件步骤

# A:创建字节输出流对象(调用系统功能创建文件,创建输出流对象,将输出流对象指向文件)
# B:调用写数据方法(write方法,写字节数据),默认是追加写数据
# C:释放资源(将对象变为垃圾便于回收,通知系统释放与该文件相关的资源)

2.3.3 写数据方法

public void write(int b):写入一个字节,使用的是字符的ASCII值;
public void write(byte[] b):写入一个字节数组;
public void write(byte[] b,int off,int len):写入一个字节数组从off索引开始的len个字节.

2.3.4 注意事项

# 创建输出流对象执行操作:调用系统功能创建文件,创建输出流对象,将输出流对象指向文件
# 写入换行:写入换行符的字节形式(windows:\r\n,Linux:\n,mac:\r)
# 追加写数据:使用带有追加写数据的构造方法,参数为true
# close方法:将对象变为垃圾便于垃圾回收器的回收,通知系统释放与该文件相关的资源.

2.4 FileInputStream类

FileInputStream类:是字节输入流的具体实现类.

2.4.1 构造方法

FileInputStream(File file):创建指向File对象的字节输入流;
FileInputStream(String name):创建指向具体文件名的字节输入流.

2.4.2 字节输入流读取文件步骤

# A:创建字节输入流对象
# B:调用读数据方法
# C:释放资源

2.4.3 读数据方法

public int read():一次读取一个字节数据,没有数据时,返回-1,读取的是字符的ASCII值,要强制类型转换后才能变为字符,读取的中文会乱码,中文占用2个字节,强制转换时将中文拆为2个字节进行转换,会乱码;
public int read(byte[] b):一次读取一个字节数组,返回每次实际读取的字节数.

2.4.4 案例代码

public class MyIODemo01 {
    public static void main(String[] args) throws IOException {
        // 字节输出流测试
        // fileOutPutStreamDemo();
        // 字节输入流测试
        // fileInputStreamDemo();
        // 字节输入流和输出流复制文件案例
        copyFileTest();
    }
    public static void copyFileTest() throws IOException {
        // 将项目根目录下的指定文件的内容复制到指定的文件中
        // 创建输入流对象
        FileInputStream fis = new FileInputStream("IO流的分类.bmp");
        // 创建输出流对象
        FileOutputStream fos = new FileOutputStream("test.bmp");
        // 赋值文件
        // 定义存储读取的字节的数组,一般长度给1024,是1kb
        byte[] bs = new byte[1024];
        // 每次读取字节的实际长度
        int len;
        while((len = fis.read(bs)) != -1) {
            fos.write(bs, 0, len);
        }
        // 释放资源
        fis.close();
        fos.close();
    }
    public static void fileInputStreamDemo() throws IOException {
        // 测试读取数据方法
        FileInputStream fis = new FileInputStream("Demo.java");
        // read方法会每次读取一个字节,并自动移向下一个字节数据
        System.out.println((char)fis.read()); // s
        // 一次读取一个字节
        byte[] b = new byte[1024];
        int len;
        while((len=fis.read(b)) != -1) {
            // 将字节数组数据转换为字符串
            System.out.println(new String(b, 0, len));
        }
    }
    public static void fileOutPutStreamDemo() throws FileNotFoundException,
            IOException {
        // 测试构造方法
        test01();
        // 测试写数据方法
        test02();
        // 测试带有异常处理的字节输出流
        test03();
    }

    public static void test03() {
        // 要对fos进行初始化,否则调用close方法可能空,出现编译期异常
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("fos3.txt");
            fos.write(23);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 如果输出流对象不为空才需要关闭
            if(fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void test02() throws FileNotFoundException, IOException {
        FileOutputStream fos = new FileOutputStream("sof.java");
        // 写入数据
        // public void write(int b)
        fos.write('a'); // 代表的是字符a
        fos.write(97); // 代表的也是字符a,97是字符a的值
        // public void write(byte[] b)
        byte[] bs = "somnus".getBytes();
        fos.write(bs);
        // public void write(byte[] b,int off,int len)
        fos.write(bs, 3, 2); // 将字节数组从索引3开始的2个字节写入文件
        // 释放资源
        fos.close();
    }
    public static void test01() throws FileNotFoundException, IOException {
        // FileOutputStream(File file)
        // FileOutputStream fos1 = new FileOutputStream(new File("Demo.java"));
        // FileOutputStream(String name)
        /*
         * 此构造方法执行的操作:
         *  1.调用系统功能创建文件
         *  2.创建fos对象
         *  3.将fos对象指向该文件
         */
        FileOutputStream fos2 = new FileOutputStream("Demo.java");
        // 调用写数据方法,只能写入字节数据
        fos2.write("somnus".getBytes());
        // 释放资源
        /*
         * 1.将字节输出流变为垃圾,便于垃圾回收器的回收;
         * 2.通知系统释放与该文件相关的资源.
         */
        fos2.close();
    }
}

2.5 高效字节缓冲流

高效的字节缓冲流:在基本的字节输入输出流的基础上添加了数组作为缓冲区,本质还是字节输入输出流对象进行操作文件.

2.5.1 BufferedInputStream类

字节输入缓冲流:BufferedInputStream类,是InputStream抽象类的间接子类,是在FileInputStream类基础上封装了数组作为缓冲区.

构造方法

public BufferedInputStream(InputStream in):创建字节输入缓冲流,参数是InputStream抽象类的实现类;
public BufferedInputStream(InputStream in,int size):创建指定缓冲区大小为size的字节输入缓冲流.

读取数据方法

public int read():一次读取一个字节放入输入缓冲流;
public void read(byte[] b,int off,int len):一次读取一个字节数组放入输入缓冲流.

2.5.2 BufferedOutputStream类

字节输出缓冲流:BufferedOutputStream类,是OutputStream抽象类的间接子类,是在FileOutputStream类基础上封装了数组作为缓冲区.

构造方法

public BufferedOutputStream(OutputStream in):创建字节输出缓冲流,参数是OutputStream抽象类的实现类;
public BufferedOutputStream(OutputStream in,int size):创建指定缓冲区大小为size的字节输出缓冲流.

写数据方法

public void write(int b):将一个指定字节写入输出缓冲流;
public void write(byte[] b,int off,int len):将指定字节数组的一部分字节下写入输出缓冲流.

2.5.3 flush方法和close方法的区别

# flush方法是将缓冲区的数据刷新到文件,后面还可以继续文件写入数据,频繁使用会降低程序效率;
# close方法是在关闭流之前执行flush方法,将数据刷新到文件,后面不能再向文件写入数据.

2.5.4 案例代码

public class MyIODemo02 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入缓冲流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Demo.java"));
        // 创建字节输出缓冲流对象
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.java"));
        // 赋值文件
        byte[] bs = new byte[1024];
        int len;
        while((len = bis.read(bs)) != -1) {
            bos.write(bs, 0, len);
        }
        // 释放资源
        bos.close();
        bis.close();
    }
}