Java-IO流-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45019986/article/details/120084606

本文详细介绍了Java中的File类，包括构造方法和成员方法，如创建、删除文件及目录，获取文件信息等。同时，讲解了IO流的基本概念、分类，如字节流、字符流、输入流、输出流，并提供了使用InputStream、OutputStream、Reader、Writer的实例。此外，还展示了如何使用Buffered流提高效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这里写目录标题

File类和IO

在这里插入图片描述

File类

说明

	File类对文件进行操作，不涉及文件的读写。
	构造方法
		File(File path,String child)
		根据parent抽象路径名和child路径名字符串创建一个新File实例
				范例：File file1=new File("/Volume/user/wuyanzhu");
        File file2=new File(file,”a.txt");
		File(String pathname)
		通过将给定路径名字符串转换为抽象路径名来创建一个新File实例
				范例1：File file=new File("/Volume/user/wuyanzhu/a.txt");
				范例2:File file=new File("/Volume/user/wuyanzhu");
		File(String parent,String child)
		根据parent路径名字符串和child路径名字符串创建一个新File实例
				范例：File file=new File("/Volume/user/wuyanzhu”，”a.txt”);

成员方法

		创建文件和目录
			boolean mkdir()
				创建单级目录
			boolean mkdirs()
				创建多级目录
			boolean createNewFile()
				在指定的目录下创建文件
		删除文件或目录
			boolean delete()
				删除此抽象路径名表示的文件或目录
		获取文件路径的方法
			File getAbsoluteFile()
				获取觉渡路径返回File类型
			String getAbsolutePath()
				获取绝对路径返回String类型
			String getParent()
				获取当前文件的父路径
			File getParentFile()
				获取当前文件的父路径，返回一个File类型
			String getPath()
				获取当前路径，返回一个String类型
			String getName()
				获取文件的名称和后缀
			long length()
				获取指定文件的总字节长度
		关于文件和目录的判断
			boolean exists()
				判断当前目录或文件是否存在
			boolean isDirectory()
				判断当前抽象路径是否为目录
			isFIle()
				判断当前抽象路径是否为文件
			isHidden()
				判断当前抽象路径下的文件是否为隐藏文件
			isAbsolute()
				判断当前抽象路径是否为绝对路径
			canRead()
				判断当前抽象路径下的文件是否为只读文件
			canWrite()
				判断当前抽象路径下的文件是否为只写文件
				获取指定目录下的所有子文件或者子目录绝对路径的File类型数组
		获取子目录或子文件
			String[] list()
				获取指定目录下的所有子文件或者子目录的名称，返回字符串数组
			File[] listFiles()
			static File() listRoots()
				返回当前操作系统下的所有盘符

案例

	案例一：删除指定目录下的所有文件，包括其子目录中的文件

public static void deleteAll(File file){
    if(file==null) return ;
    if(file.isDirectory()) {
        File[] files = file.listFiles();
        if (files !=null) {
            for (File ele : files) {
                deleteAll(ele);
            }
        }
    }
    file.delete();
}

public static void main(String[] args) {
    File file=new File("/Volumes/project/IdealProject/11");
    deleteAll(file);
}

	案例二:拷贝指定目录下的所有文件（不包括其子目录中的文件）到另一个目标目录中

public static void copyFile(File file,File target) throws IOException {
    if(file.isDirectory()){
        File[] files=file.listFiles();
        if(files!=null){
            for(File ele:files){
                if(ele.isFile()) {
                    File newFile=new File(target,ele.getName());
                    newFile.createNewFile();
                }
            }
        }
    }
}

public static void main(String[] args) throws IOException {
    File file=new File("/Volumes/project/IdealProject/testFIle");
    File target=new File("/Volumes/project/IdealProject/11");
    copyFile(file,target);
}

//这里只能创建文件，复制文件内容需要用到IO流，下面会讲到
案例三：列出某个文件夹下的所有文件，包括子目录的文件

			public void list(){
    //列出目录下的所有文件，并且子目录的文件。递归实现。
    File file=new File(File.separator+"Users"+File.separator+"zhaolonghui");//文件，父目录。
    listDir(file);
}
public  void listDir(File file){
    if(file.isDirectory()) {
        File[] files = file.listFiles();
        if (files != null) {//因为有些文件是列不出来的，所以判断一下。
            for (File ele : files) {//循环遍历
                listDir(ele);//递归
            }
        }
    }
        System.out.println(file);//如果是文件直接输出
}

	案例四：批量修改文件名称，并把该目录下的所有文件名后缀修改为.txt

			@Test
public void list(){
    //修改指定目录下的文件名，后缀统一为.txt
    File file=new File(File.separator+"Volumes"+File.separator+"project"+ File.separator+"test");
    long start=System.currentTimeMillis();
    rename(file);
    long end=System.currentTimeMillis();
    System.out.println("共用了："+(end-start)+"毫秒");
}

public  void rename(File file){
    if(file.isDirectory()) {
        File[] result=file.listFiles();
        if(result!=null){
            for(File ele:result){
                rename(ele);
            }
        }
    }else if(file.isFile()){
        String fileName=null;
        if(file.getName().contains(".")){
            fileName=file.getName().substring(0,file.getName().lastIndexOf("."));
        }else{
            fileName=file.getName();
        }
        fileName+=".txt";
        File newFile=new File(file.getParentFile(),fileName);
        file.renameTo(newFile);
        System.out.println(fileName);
    }

IO流的概述

IO流即输入（Input）输出流(Output)
输入输出是相对的概念，对于我的计算机来说，读取就是输入，写入文件就是输出
我们在实例化输入输出流的对象时，通常采用多态的方法（父类引用指向之类对象）

IO流的分类

按照处理数据的单位划分

 字节流（byte）
 	InputStream
 		实现类：FileInputStream
 	OutputStram
 		实现类：FileOutputStream
 字符流(char)
 	Reader
 		实现类：FileReader
 	Writer
 		FIleWriter

按照流向划分

 输入流（Input）
 	InputStream
 		实现类：FileInputStream
 	Reader
 		实现类：FileReader
 输出流（Output）
 	OutputStram
 		实现类：FileOutputStream
 	Writer
 		FIleWriter

按照功能的不同划分

 节点流（低级流）
 	InputStream
 		实现类：FileInputStream
 	OutputStram
 		实现类：FileOutputStream
 	Reader
 		实现类：FileReader
 	Writer
 		FIleWriter
 处理流（高级流）
 	BufferInputStream
 	BufferOutputStream
 	BufferReader
 	BufferWriter

IO详解

InputStream

	类定义
		Public abstract class InputStream extends Object implements Closeable;
	构造方法
		public void FileInputStream(File file)
		public void FileInputStream(String FilePath)
	成员方法
		public abstract int read() throws IOException();
		public int read(byte[] b)throws IOException();
			读取单个字节数据,如果现在已经读取到低了，返回-1;
			读取一组字节数据，返回值是读取的个数，如果数据读取到底返回-1;
		public int read(byte[] b,int off,int len) throws IOException();
			读取一组数据的部分内容。（只占数组的一部分）,返回读取个数。
		public int avaliable();
			获取文件字节数。

Outputstream

	类定义
		Public abstract class OutputStream extends Object implements Closeable,Flushable
	构造方法
		public void FileOutputStream(File file)
		public void FileOutputStream(String FilePath)
	成员方法
		public abstract void write(int b)throws IOException
			输出一个字节数据
		public void write(byte[] b)throws IOException;
			输出一组字节数据
		public void write(byte[] b,int off,int len)throws IOException;
			输出部分字节数据

Reader

	构造方法
		FileReder(String filepath);
		FileReader(File file);
	成员方法
		Skip(int length);
			跳过多少个字节
		Abstract void close();
			关闭流对象
	应用
		方式一：

Int len=0;
	while((len=fr.read())!=-1){
	System.out.println(len);
	}

			方式二:

char[] chs=new char[1024];//存放读取数组
	Int len;
	Whlie((len=fr.read(chs))!=-1){//一次性读取1024个字符保存到chs数组中
	{
			System.out.println(new String(chs));
	}

			方式三:

char[] chs=new char[1024];//存放读取数组
	Int len;
	Whlie((len=fr.read(chs，3，8))!=-1){//一次性读取8个字符从chs的第三个位置开始保存。
	{
			System.out.println(new String(chs));
	}

Writer

	构造方法
		FileWriter(String filepath);
		FileWriter(File file);
	成员方法
		write(String str);
		Write(String ,int index,int length);
		flush();
BufferInputStream
	BufferedInputStream(InputStream in);
	BufferedInputStream(InputStream in,int sz);//可以设置缓冲区大小
	范例1:

FileInputStream in=new File(path);
	BufferedInputStream bi=new BufferedInputStream(in);
	BufferedOutputStream bo=new BufferedOutputStream(new FileOutputStream(“path”));
	
	Int len;
	While((len=bi.read())!=-1){
	Bo.write(len);
	}

BufferOutputStream

	BufferedOutputStream(InputStream in);
	BufferedOutputStream(InputStream in,int sz);//可以设置缓冲区大小
BufferReader
	构造方法
		BufferedReader(Read read);
		BufferedReader(Read read,int sz);
			sz可以指定默认缓冲区大小
	成员方法
		readLine()
			一次读一行
		read();
			一次读一个字符
		Read(byte[] )
			一次读多个字节
	范例

FileReader fr=new FileReader(filePath);
//...进行文件目录判断是否存在
	BufferedReader br=new BufferedReader(fr);
	//String str=br.readLine();//一次性读取文件中的一行，返回字符串。
	//System.out.println(str);
	
	//使用循环把文件中的所有内容读取出来
	String line=null;
	while((line=br.line)!=null){
	System.out.println(line);
	}

BufferWriter

	构造方法
		BufferedWriter(Write writer);
		BufferedWriter(Write writer,int sz);
			sz可以指定默认缓冲区大小
	成员方法
		write();
			一次写一个字符
		writerLine()
			一次写一行，但是换行并没有写到文件中。
		write(byte[])
			一次写一个字符数组
		newLine()
			写入一个换行符