IO流(一)

知名男模zzq

已于 2023-03-31 10:51:56 修改

阅读量61

点赞数

文章标签： servlet myeclipse ide java

于 2023-03-30 17:11:03 首次发布

本文链接：https://blog.csdn.net/A56562379/article/details/129861391

版权

本文详细介绍了Java中的File类，包括其构造方法、属性和操作文件的方法，如创建、删除、重命名以及获取文件信息。此外，还讲解了JavaIO流的基本概念，如输入流、输出流的分类，以及字节流和字符流的区别。文章通过示例代码展示了如何使用FileInputStream、FileOutputStream、FileReader和FileWriter进行文件复制操作。

摘要由CSDN通过智能技术生成

1. File类

1、文件可认为是相关记录或放在一起的数据的集合。文件一般存放在存储介质上：硬盘、u盘、光盘、软盘、云盘等。(云管段)

2、 java.io.File 类是专门对文件进行操作的类。(只能对文件本身进行操作，不能对文件内容操作)

3、 File类是“文件和目录路径名的抽象表示”。而不是指文件的内容。

4、 File类定义了一些与平台无关的方法操作，如：创建、删除文件和重命名等。

5、 Java中目录被看成是一个特殊的文件。List()方法可以返回目录中所有的子目录和文件。

6、在linux下路径分隔符为(/)，而在windos中则是为(\)，在java中可以正确的处理不同系统中的分隔符。

1.1 File类常用构造方法和属性

常用构造方法：

1、public File(Stringpathname)

以pathname为路径创建File对象，如果pathname是相对路径，则是相对于Java的系统属性user.dir中的路径。（对eclipse创建的java工程来说，就是该工程的根目录。）

属性：

2、public static finalString separator　存储了当前系统的名称分隔符

在 LINUX和Mac系统上，此字段的值为 /；在 Windows 系统上，它为 \.为了程序的跨平台特性，文件的路径应该用这个属性值来代表。

3、public static finalchar pathSeparator 存储了当前系统默认路径分割符号

Windows系统是 ;; 即path环境变量中，不同的路径的分割符号。LINUX系统是::

1.2 File类的常用方法

常用方法一(文件属性)：

如下：

package cn.sz.gl.test05;

import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("D:\\java\\Java高级\\myfile\\a.txt");
		System.out.println("file.separator:"+file.separator);
		System.out.println("file.exists()，判断对象所对应的目录或文件是否存在："+file.exists());
		System.out.println("判断对象是否是一个目录(file.isDirectory()):"+file.isDirectory());
		System.out.println("判断是否是一个文件(file.isFile())："+file.isFile());
		System.out.println("判断是否是隐藏文件或目录(file.isHidden()):"+file.isHidden());
		System.out.println("最后修改时间(file.lastModified())："+file.lastModified());
		System.out.println("文件长度（以字节为单位）："+file.length());
		System.out.println("获取文件名字:"+file.getName());
		System.out.println("获取文件路径："+file.getPath());
	}
}

常用方法二（对于文件的操作）:

package cn.sz.gl.test05;

import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("D:\\java\\Java高级\\myfile");
		boolean bool = file.mkdir();//可以创建文件对象的上一级目录
		boolean morebool = file.mkdirs();//判断路径是否存在，如果不存在，就创建对应目录(多级)
		//boolean isDelete = file.delete();
		//System.out.println("是否删除成功："+isDelete);
		if(file.isDirectory()){
			File [] allfile = file.listFiles();//得到目录下所有的直接子目录和文件
			for (int i = 0; i < allfile.length; i++) {
				System.out.println(allfile[i].getPath());
			}
		}else{
			System.out.println("不是一个目录");
		}

	}
}

在获取文件和目录过程中，还可以对文件和目录进行筛选（或者过滤）:

package cn.sz.gl.test05;

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

public class Test {

	public static void main(String[] args) {
		File file = new File("D:\\java\\Java高级\\myfile");
		// 判断是否是一个目录
		if (file.isDirectory()) {
			File[] all = file.listFiles(new FileFilter() {
				@Override
				public boolean accept(File myfile) {
					// 判断是否是一个目录，是就通过
					if (myfile.isDirectory()) {
						return true;
					}
					// 判断文件是否是以.txt结尾的，是就通过
					if (myfile.getName().endsWith(".txt")) {
						return true;
					}
					return false;
				}
			});
			for (int i = 0; i < all.length; i++) {
				System.out.println(all[i].getPath());
			}
		}

	}
}

2. IO流

2.1 什么是IO流

IO指的是Input/Output，IO流：输入输出流。统称为数据流。(IO Stream)

在Java程序中，对于数据的输入 / 输出操作以流的方式进行；流是从起源到接收的有序数据。JDK提供了各种各样的流类，用以获取不同种类的数据；

2.2 IO流的分类

按流向分：

◦ 输入流：程序可以从中读取数据的流

◦ 输出流：程序能向其中写入数据的流

按数据传输单位分：

◦ 字节流：以字节为单位传输数据的流

◦ 字符流：以字符为单位传输数据的流

按功能分：

◦ 节点流：用于直接操作目标设备的流

◦ 处理流：是对一个已存在的流的连接和封装，通过对数据的处理为程序提供更强大、灵活的读写功能。

2.3.1 InputStream字节输入流

继承自InputStream的流都是用于向程序中输入数据的，且数据的单位为字节(8位)，下图中深色为节点流，浅色为处理流

InputStream基本方法：

public abstract int read() throwsIOException

从输入流中读取数据的下一个字节, 返回读到的字节值.若遇到流的末尾,返回-1

public int read(byte[] b) throwsIOException

从输入流中读取 b.length 个字节的数据并存储到缓冲区数组b中.返回的是实际读到的字节总数

public int read(byte[] b, int off, int len)throws IOException

读取 len 个字节的数据,并从数组b的off位置开始写入到这个数组中

public void close() throws IOException

关闭此输入流并释放与此流关联的所有系统资源

public int available() throws IOException

返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数

public skip(long n) throws IOException

跳过和丢弃此输入流中数据的 n 个字节，返回实现路过的字节数。

2.3.2 OutputStream字节输出流

继承自OutputStream的流是程序用于向外输出数据的，且数据的单位为字节(8位)，下图中深色为节点流，浅色为处理流

OutputStream主要方法：

public abstract void write(int b) throwsIOException

将指定的字节写入此输出流

public void write(byte[] b) throwsIOException

将 b.length 个字节从指定的 byte 数组写入此输出流

public void write(byte[] b, int off, intlen) throws IOException

将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流

public void flush() throws IOException

刷新此输出流并强制写出所有缓冲的输出字节

pulbic void close() throws IOException

关闭此输出流并释放与此流有关的所有系统资源

2.3.3 Reader字符输入流

继承自Reader的流都是用于向程序中输入数据的，且数据的单位为字符(16位)，下图中深色为节点流，浅色为处理流

public int read() throws IOException

读取单个字符，返回作为整数读取的字符，如果已到达流的末尾返回-1

public int read(char[] cbuf) throwsIOException

将字符读入数组，返回读取的字符数

public abstract int read(char[] cbuf,int off, int len) throws IOException

读取 len 个字符的数据，并从数组cbuf的off位置开始写入到这个数组中

public abstract void close() throwsIOException

关闭该流并释放与之关联的所有资源

public long skip(long n) throwsIOException

跳过n个字符。

2.3.4 Writer字符输出流

继承Writer的流都是向程序中输出数据，且数据的单位为字符(16 bit)；下图中深色为节点流，浅色为处理流

public void write(int c) throwsIOException

写入单个字符

public void write(char[] cbuf) throws IOException

写入字符数组

public abstract voidwrite(char[] cbuf, int off, int len) throws IOException

写入字符数组的某一部分

public void write(String str) throwsIOException

写入字符串

public void write(String str,int off, int len) throws IOException

写字符串的某一部分

public abstract void close() throwsIOException

关闭此流，但要先刷新它

public abstract void flush() throwsIOException

刷新该流的缓冲，将缓冲的数据全写到目的地

2.4 节点流

节点流为可以从一个特定的数据源（节点）读写数据（如：文件，内存）

2.4.1 FileInputStream

FileInputStream 类创建一个能从文件读取字节的InputStream类，它的两个常用的构造方法如下：

FileInputStream(Stringfilepath)

FileInputStream(FilefileObj)

这两个构造方法都能引发FileNotFoundException异常。这里，filepath是文件的绝对路径，也可是相对路径。fileObj是描述该文件的File对象。

下面的例子创建了两个使用同样磁盘文件且各含一个上面所描述的构造方法的FileInputStreams类：

InputStreamf0 = new FileInputStream("c:\test.txt");

Filef = new File("c:\test.txt");

InputStreamf1 = new FileInputStream(f);

尽管第一个构造方法可能更常用到，而第二个构造方法则允许在把文件赋给输入流之前用File方法更进一步检查文件。当一个FileInputStream被创建时，它可以被公开读取

2.4.2 FileOutputStream

FileOutputStream创建了一个可以向文件写入字节的类OutputStream，它常用的构造方法如下：

FileOutputStream(StringfilePath)

FileOutputStream(FilefileObj)

FileOutputStream(StringfilePath, boolean append)

它们可以引发IOException或SecurityException异常。这里filePath是文件的绝对路径，也可以是相对路径。fileObj是描述该文件的File对象。如果append为true，则表示追加。FileOutputStream 的创建不依赖于文件是否存在。在创建对象时，FileOutputStream会在打开输出文件之前就创建它。这种情况下如果试图打开一个只读文件，会引发一个IOException异常

2.4.3 FileReader

FileReader类创建了一个可以读取文件内容的Reader类。它最常用的构造方法显示如下：

FileReader(StringfilePath)

FileReader(FilefileObj)

每一个都能引发一个FileNotFoundException异常。

2.4.4 FileWriter

FileWriter 创建一个可以写文件的Writer类。它最常用的构造方法如下：

FileWriter(StringfilePath)

FileWriter(StringfilePath, boolean append)

FileWriter(FilefileObj)

它们可以引发IOException或SecurityException异常。这里，filePath是文件的绝对路径，fileObj是描述该文件的File对象。如果append为true，输出是附加到文件尾的。FileWriter类的创建不依赖于文件存在与否。在创建文件之前，FileWriter将在创建对象时打开它来作为输出。如果试图打开一个只读文件，将引发一个IOException异常。

2.5 文件复制

实现文件复制（使用字节流）:

package cn.sz.gl.test05;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class Test {

	public static void copyFileByStream(File source, File target) {
		// 判断源文件是否存在，如果不存在，就退出程序
		if (!source.exists()) {
			System.out.println("源文件不存在,程序退出");
			System.exit(0);
		}
		// target.getParentFile()表示用来获取目标对象的父目录对象
		// 如果目标文件路径不存在，就创建
		if (!target.getParentFile().exists()) {
			target.getParentFile().mkdirs();
		}

		InputStream is = null;
		OutputStream os = null;

		try {
			// 准备输入流
			is = new FileInputStream(source);
			// 准备输出流
			os = new FileOutputStream(target);
			// 准备一个数组，用来存放读写的数据
			byte[] b = new byte[1024];
			int len = 0;
			// read(b)实现读取操作，数据存入b数组，返回读取长度给len，当所有内容都读取完毕，len=-1
			while ((len = is.read(b)) != -1) {
				// 实现写的操作
				os.write(b, 0, len);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null) {
					is.close();
				}
				if (os != null) {
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

	public static void main(String[] args) {
		File source = new File("D:\\java\\Java高级\\myfile\\a.txt");
		File target = new File("D:\\java\\Java高级\\myfile\\b.txt");
		copyFileByStream(source, target);
	}
}

实现文件复制（通过字符流）

package cn.sz.gl.test05;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class Test {

	public static void copyFileByWriter(File source, File target) {
		// 判断源文件是否存在
		if (!source.exists()) {
			System.out.println("源文件不存在，程序退出");
			System.exit(0);
		}

		// 判断目标文件路径是否存在，不存在就创建
		if (!(target.getParentFile().exists())) {
			target.getParentFile().mkdirs();
		}

		Reader reader = null;
		Writer writer = null;
		try {
			reader = new FileReader(source);
			writer = new FileWriter(target);
			char c[] = new char[1024];
			int len = 0;
			while ((len = reader.read(c)) != -1) {
				writer.write(c, 0, len);
			}
			writer.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				// 多个资源需要关闭时，原则上应该是先开的后关
				if (writer != null) {
					writer.close();
				}
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		File source = new File(
				"D:\\java\\Java高级\\myfile\\a.txt");
		File target = new File(
				"D:\\java\\Java高级\\myfile\\b.txt");
		copyFileByWriter(source, target);
	}
}