文件管理与I/O流

最新推荐文章于 2023-04-21 15:43:06 发布

qfsx

最新推荐文章于 2023-04-21 15:43:06 发布

阅读量373

点赞数

分类专栏：文件管理与I/O流文章标签： java

本文链接：https://blog.csdn.net/qq_41019779/article/details/107574024

版权

文件管理与I/O流专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文件管理与I/O流

程序经常需要访问文件和目录，读取文件信息或写入信息到文件，在Java语言中对文件的读写是通过 I/O流技术实现的。存储数据是靠文件，移动数据是靠流，使用一个一个的移动数据也可以但是时间需要花费很多，而流的使用就更加方便的使用数据。

文件管理

Java语言使用File类对文件和目录进行操作，查找文件时需要实现FilenameFilter或FileFilter接口。另外，读写文件内容可以通过FileInputStream、FileOutputStream、FileReader和FileWriter类实现。

总的来说就是通过File类对文件进行查找和读写。

File类

File类表示一个与平台无关的文件或目录。File类名很有欺骗性，初学者会误认为是File对象只是一个文件，但它也可能是一个目录。

File类中常用的方法如下。

构造方法

File(String path)：如果path是实际存在的路径，则该File对象表示的是目录；如果path是文件名，则该File对象表示的是文件。

File(String path, String name)：path是路径名，name是文件名。

File(File dir, String name)：dir是路径对象，name是文件名。

获得文件名

String getName( )：获得文件的名称，不包括路径。

String getPath( )：获得文件的路径。

String getAbsolutePath( )：获得文件的绝对路径。

String getParent( )：获得文件的上一级目录名。

文件属性测试

boolean exists( )：测试当前File对象所表示的文件是否存在。

boolean canWrite( )：测试当前文件是否可写。

boolean canRead( )：测试当前文件是否可读。

boolean isFile( )：测试当前文件是否是文件。

boolean isDirectory( )：测试当前文件是否是目录。

文件操作

long lastModified( )：获得文件最近一次修改的时间。

long length( )：获得文件的长度，以字节为单位。

boolean delete( )：删除当前文件。成功返回 true，否则返回false。

boolean renameTo(File dest)：将重新命名当前File对象所表示的文件。成功返回 true，否则返回false。

boolean mkdir( )：创建当前File对象指定的目录。

String[] list()：返回当前目录下的文件和目录，返回值是字符串数组。

String[] list(FilenameFilter filter)：返回当前目录下满足指定过滤器的文件和目录，参数是实现FilenameFilter接口对象，返回值是字符串数组。

File[] listFiles()：返回当前目录下的文件和目录，返回值是File数组。

File[] listFiles(FilenameFilter filter)：返回当前目录下满足指定过滤器的文件和目录，参数是实现FilenameFilter接口对象，返回值是File数组。

File[] listFiles(FileFilter filter)：返回当前目录下满足指定过滤器的文件和目录，参数是实现FileFilter接口对象，返回值是File数组。

案例：文件过滤

package com.a51work6;

import java.io.File;
import java.io.FilenameFilter;

public class HelloWorld {
	public static void main(String[] args) {
		// 用File对象表示一个目录,.表示当前目录
        File file = new File("./file");
     // 创建txt文件过滤器
        Filter ft =new Filter("txt");
        String list[] = file.list(ft);
     // 遍历文件列表
        for (String fileName:list) {
        	// 为目录file下的文件或目录创建File对象
            File f = new File(file, fileName);
         // 如果该f对象是文件，则打印文件名
            if (f.isFile()){
                System.out.println("文件名:"+ f.getName());
            }

        }
    
    }

}
//自定义基于文件扩展名的文件过滤器
class Filter implements FilenameFilter{
	// 文件扩展名
    String extent;
 // 构造方法
    Filter(String extent){
        this.extent = extent;
    }
    @Override
    public boolean accept(File dir, String name) {
    	// 测试文件扩展名是否为extent所指定的
        return name.endsWith("."+ extent);
    }
}

I/O流概述

Java将数据的输入输出（I/O）操作当作“流”来处理，“流”是一组有序的数据序列。“流”分为两种形式：输入流和输出流，从数据源中读取数据是输入流，将数据写入到目的地是输出流。

Java流设计理念

Java流数据输入的数据源有多种形式，如文件、网络和键盘等，键盘是默认的标准输入设备。而数据输出的目的地也有多种形式，如文件、网络和控制台，控制台是默认的标准输出设备。

流类继承层次

以字节为单位的流称为字节流，以字符为单位的流称为字符流。Java SE提供4个顶级抽象类，两个字节流抽象类：InputStream和OutputStream；两个字符流抽象类：Reader和Writer。

主要的字节输入流

类	描述
FileInputStream	文件输入流
ByteArrayInputStream	面向字节数组的输入流
PipedInputStream	管道输入流，用于两个线程的数据传输
FilerInputStream	过滤输入流，它是一个装饰器扩展其他输入
BufferedInputStream	缓冲区输入流，它是FilterInputStream的子类
DateInputStream	面向基本数据类型的输入流

主要的字节输出流

类	描述
FileOutputStream	文件输出流
ByteArrayOutputStreaam	面向字节数组的输出流
PipedOutputStream	管道输出流，用于两个线程的数据传输
FilerOutputStream	过滤输出流，它是一个装饰器扩展其他输出
BufferedOutputStream	缓冲区输出流，它是FilterOutputStream的子类
DateOutputStream	面向基本数据类型的输出流

字节流

字节流需要掌握的是它的两个抽象类：InputStream 和OutputStream。

InputStream抽象类

InputStream是字节输入流的根类。输入流的主要方法就是读取和流操作完毕后必须关闭。关闭的方法是close；读取的方法是read根据参数的不同读取的方式也不同。其中read(byte b[ ], int off, int len)就是从off位置存放len个字节到b数组当中。返回值为实际读取的字节的数量，如果已经到达流末尾，而且没有可用的字节，则返回值-1。

OutputStream抽象类

OutputStream是字节输出流的根类。输出流的主要方法就是写出和流操作完毕后必须关闭。关闭的方法是close；读取的方法是write根据参数的不同写出的方式也不同。其中write(byte b[ ], int off, int len)就是从off位置存放len个字节到b数组当中。返回值为实际读取的字节的数量，如果已经到达流末尾，而且没有可用的字节，则返回值-1。

需要注意的是流所占用的资源，不能通过JVM的垃圾收集器回收，需要程序员

自己释放。一种方法是可以在finally代码块调用close()方法关闭流，释放流所占用的资源。另一种方法通过自动资源管理技术管理这些流。

案例：文件复制

文件复制的基本过程是先定义输入流和输出流，然后定义一个数组搬运然后开始读，读的过程中判断是否读完并开始写。

 package File;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    
    public class FileCopy {
        public static void main(String[] args) {
            try (FileInputStream in = new FileInputStream("./1234");
                 FileOutputStream out = new FileOutputStream("./file/1234");
                 ){
                byte[] b = new byte[10];
                int read = in.read(b);
                while (read != -1){
                    out.write(b,0,read);
                    read = in.read(b);
                }
    
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    }

使用字节缓冲流

BufferedInputStream和BufferedOutputStream称为字节缓冲流，使用字节缓冲流内置了一个缓冲区，第一次调用read方法时尽可能多地从数据源读取数据到缓冲区，后续再到用read方法时先看看缓冲区中是否有数据，如果有则读缓冲区中的数据，如果没有再将数据源中的数据读入到缓冲区，这样可以减少直接读数据源的次数。通过输出流调用write方法写入数据时，也先将数据写入到缓冲区，缓冲区满了之后再写入数据目的地，这样可以减少直接对数据目的地写入次数。使用了缓冲字节流可以减少I/O操作次数，提高效率。

package File;

import java.io.*;

public class FileCopyWithBuffer {

        public static void main(String[] args) {
            try (FileInputStream in = new FileInputStream("./1234");
                 BufferedInputStream bin = new BufferedInputStream(in);
                 FileOutputStream out = new FileOutputStream("./file/1234");
                 BufferedOutputStream bout = new BufferedOutputStream(out);
            ){
                byte[] b = new byte[10];
                int read = bin.read(b);
                while (read != -1){
                    bout.write(b,0,read);
                    read = bin.read(b);
                }
    
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }


}

字符流

字符流需要掌握的是它的两个抽象类：Reader和Writer

Reader抽象类

Reader是字符输入流的根类，它定义了很多方法，影响着字符输入流的行为。下面详细介绍一下。

Reader主要方法如下：

int read()：读取一个字符，返回值范围在0_65535(0x000xffff)之间。如果因为已经到达流末尾，则返回值-1。

int read(char[] cbuf)：将字符读入到数组cbuf中，返回值为实际读取的字符的数量，如果因为已经到达流末尾，则返回值-1。

int read(char[] cbuf, int off, int len)：最多读取len个字符，数据放到以下标off开始字符数组cbuf中，将读取的第一个字符存储在元素cbuf[off]中，下一个存储在cbuf[off+1]中，依次类推。返回值为实际读取的字符的数量，如果因为已经到达流末尾，则返回值-1。

void close()：流操作完毕后必须关闭。

上述所有方法都声明了抛出IOException，因此使用时要注意处理异常。

Writer抽象类

Writer是字符输出流的根类，它定义了很多方法，影响着字符输出流的行为。下面详细介绍一下。

Writer主要方法如下：

void write(int c)：将整数值为c的字符写入到输出流，c是int类型占有32位，写入过程是写入c的16个低位，c的16个高位将被忽略。

void write(char[] cbuf)：将字符数组cbuf写入到输出流。

void write(char[] cbuf, int off, int len)：把字符数组cbuf中从下标off开始，长度为len的字符写入到输出流。

void write(String str)：将字符串str中的字符写入输出流。

void write(String str,int off,int len)：将字符串str 中从索引off开始处的len个字符写入输出流。

void flush()：刷空输出流，并输出所有被缓存的字符。由于某些流支持缓存功能，该方法将把缓存中所有内容强制输出到流中。

void close( )：流操作完毕后必须关闭。

上述所有方法都可以会抛出IOException，因此使用时要注意处理异常。

注意 Reader和Writer都实现了AutoCloseable接口，可以使用自动资源管理技术自动关闭它们。

案例：文件复制

package File;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;

public class FileBufferCopy {
    public static void main(String[] args) {
        try (  FileReader in = new FileReader("./1234");
               FileWriter out = new FileWriter("./file/4321");
               ){
            char[] b = new char[10];
            int read = in.read(b);
            while (read!=-1){
                out.write(b,0,read);
                read = in.read(b);
            }


        } catch (Exception e) {
            e.printStackTrace();
        }
    
    }

}

使用字符缓冲流

BufferedReader和BufferedWriter称为字符缓冲流。BufferedReader特有方法和构造方法有：

String readLine()：读取一个文本行，如果因为已经到达流末尾，则返回值null。

BufferedReader(Reader in)：构造方法，通过一个底层输入流in对象创建缓冲流对象，缓冲区大小是默认的，默认值8192。

BufferedReader(Reader in, int size)：构造方法，通过一个底层输入流in对象创建缓冲流对象，size指定的缓冲区大小，缓冲区大小应该是2的n次幂，这样可提高缓冲区的利用率。

BufferedWriter特有方法和构造方法主要有：

void newLine()：写入一个换行符。

BufferedWriter(Writerout)：构造方法，通过一个底层输出流out 对象创建缓冲流对象，缓冲区大小是默认的，默认值8192。

BufferedWriter(Writerout, int size)：构造方法，通过一个底层输出流out对象创建缓冲流对象，size指定的缓冲区大小，缓冲区大小应该是2的n次幂，这样可提高缓冲区的利用率。

package File;

import java.io.*;

public class FileCopyBuffer {
    public static void main(String[] args) {
        try( FileReader fis = new FileReader("./1234");
             BufferedReader bis = new BufferedReader(fis);
             FileWriter fos = new FileWriter("./file/4444");
             BufferedWriter bos = new BufferedWriter(fos);) {
            // 首先读取一行文本
            String s = bis.readLine();
            while (s != null){
                bos.write(s);
                bos.newLine();
                s = bis.readLine();
            }
            System.out.println("复制完成");

        } catch (Exception e) {
            e.printStackTrace();
        }
    
    }

}

字节流转换字符流

有时需要将字节流转换为字符流，InputStreamReader和OutputStreamWriter是为实现这种转换而设计

的。

InputStreamReader构造方法如下：

InputStreamReader(InputStream in)：将字节流in转换为字符流对象，字符流使用默认字符集。

InputStreamReader(InputStream in, String charsetName)：将字节流in转换为字符流对象，

charsetName指定字符流的字符集，字符集主要有：US-ASCII、ISO-8859-1、UTF-8和UTF-16。

如果指定的字符集不支持会抛出UnsupportedEncodingException异常。

OutputStreamWriter构造方法如下：

OutputStreamWriter(OutputStream out)：将字节流out转换为字符流对象，字符流使用默认字符集。

OutputStreamWriter(OutputStream out,String charsetName)：将字节流out转换为字符流对象，charsetName指定字符流的字符集，如果指定的字符集不支持会抛出UnsupportedEncodingException异常。

package File;

import java.io.*;

public class FileCopyWith {
    public static void main(String[] args) {
        try(
                // 创建字节文件输入流对象
                FileInputStream fis = new FileInputStream("./11111.html");

                // 创建转换流对象
                InputStreamReader isr = new InputStreamReader(fis);
                // 创建字符缓冲输入流对象
                BufferedReader bis = new BufferedReader(isr);
                // 创建字节文件输出流对象
                FileOutputStream fos = new FileOutputStream("./file/9999.html");
                // 创建转换流对象
                OutputStreamWriter osw = new OutputStreamWriter(fos);
                // 创建字符缓冲输出流对象
                BufferedWriter bos = new BufferedWriter(osw);) {
            // 首先读取一行文本
            String s = bis.readLine();
            while (s != null){
                // 开始写入数据
                bos.write(s);
                // 写一个换行符
                bos.newLine();
                // 再读取一行文本
                s= bis.readLine();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    
    }

}

qfsx

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
文件管理与I/O流

文件管理与I/O流程序经常需要访问文件和目录，读取文件信息或写入信息到文件，在Java语言中对文件的读写是通过 I/O流技术实现的。存储数据是靠文件，移动数据是靠流，使用一个一个的移动数据也可以但是时间需要花费很多，而流的使用就更加方便的使用数据。文件管理Java语言使用File类对文件和目录进行操作，查找文件时需要实现FilenameFilter或FileFilter接口。另外，读写文件内容可以通过FileInputStream、FileOutputStream、FileReader和FileWri
复制链接

扫一扫