Java IO流

最新推荐文章于 2023-06-11 20:05:01 发布

野人小哥哥

最新推荐文章于 2023-06-11 20:05:01 发布

阅读量336

点赞数 2

分类专栏： JavaSE 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/pf6668/article/details/123012360

版权

JavaSE 专栏收录该内容

31 篇文章 1 订阅

订阅专栏

File类的使用

路径分隔符

路径中的每级目录之间用一个路径分隔符隔开。
路径分隔符和系统有关：
windows和DOS系统默认使用 \ 来表示；
UNIX和URL使用 / 来表示。
Java程序支持跨平台运行，因此路径分隔符要慎用。
为了解决路径问题，File类提供了一个常量：
public static final String separator，可以根据操作系统动态的提供分隔符。

创建File类的实例

package file;

import java.io.File;
import org.junit.Test;

public class FileTest{
	@Test
	public void test1() {
		//构造器1
		File file1 = new File("hello.txt");//在当前项目目录下（相对路径）
		File file2 = new File("D:\\test\\hello.txt");//绝对路径
		//构造器2
		File file3 = new File("D:\\test\\JavaSenior");//绝对路径
		//构造器3
		File file4 = new File(file3,"hi.txt");//绝对路径
	}
}

注意：以上三种File类的构造方式仅仅是在内存层面创建了File类对象，并没有实际的在硬盘上把这些文件/文件夹创建出来！

File类的常用方法

File类的属性方法

package file;

import java.io.File;
import org.junit.Test;

public class FileTest{
	@Test
	public void test1() {
		//文件构造器
		File file1 = new File("hello.txt");//在当前项目目录下（相对路径）
		File file2 = new File("D:\\test\\hello.txt");//绝对路径
		//获取绝对路径
		System.out.println(file1.getAbsolutePath());
		//获取路径
		System.out.println(file1.getPath());
		//获取名称
		System.out.println(file1.getName());
		//获取上层文件目录路径，若无，返回null
		System.out.println(file1.getParent());
		//获取文件长度（即，字节数）。不能获取目录的长度
		System.out.println(file1.length());
		//获取文件最后一次的修改时间，返回毫秒值
		System.out.println(file1.lastModified());
		
		File file = new File("D:\\360解压\\360zip");
		//获取file文件目录下所有的文件和文件夹
		String[] list = file.list();
		File[] listFiles = file.listFiles();
		/*
		 * 把文件重命名为指定的文件路径
		 * public boolean renameTo(File dest){}
		 * File file1 = new File("hello.txt");
		   File file2 = new File("D:\\test\\hello.txt");
		   boolean renameTo = file1.renameTo(file2);
		   注意：要想保证返回true，也就是重命名成功，
		   需要保证file1在硬盘中存在，且file2不存在。
		 */
	}
}

File类的判断功能

package file;

import java.io.File;
import org.junit.Test;

public class FileTest{
	@Test
	public void test() {
		//文件构造器
		File file = new File("hello.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());
	}
}

File类的创建功能

package file;

import java.io.File;
import java.io.IOException;
import org.junit.Test;

public class FileTest{

	  @Test 
	  public void test() throws IOException { //文件构造器 
		  File file = new File("hello.txt");//在当前项目目录下（相对路径）
		  if(!file.exists()) { //文件的创建
			  file.createNewFile(); 
			  System.out.println("文件创建成功！"); 
		  }else {//文件存在的情况下
			  if(file.delete()) System.out.println("文件删除成功！"); 
		  } 
	  }
	@Test
	public void test2() throws IOException {
		File file = new File("D:\\Java_test\\hello");//在当前项目目录下（相对路径）
		//文件目录的创建
		boolean mkdir = file.mkdir();
		if(mkdir) {
			System.out.println("文件创建成功！");
		}
		boolean mkdirs = file.mkdirs();
		if(mkdir) {
			System.out.println("文件创造成功！");
		}
	}
	/**
	 * public boolean mkdir():创建文件目录。如果此文件目录存在，就不创建了。
	 *                        如果此文件目录的上层目录不存在，则不创建。
	 * public boolean mkdirs():创建文件目录。如果此文件目录的上层目录不存在，一并创建。
	 */
}

Java为我们封装好了创建文件的方法，我们直接调用即可创建，我们要分清内存当中的文件对象、实际硬盘上的文件这两个概念，请看下图便于理解：

说明： 当硬盘中真有一个真实的文件或者文件目录（文件夹）存在时，创建File对象时，各个属性会显示赋值。如上图的file1。
当硬盘中没有真实的文件或者文件目录（文件夹）存在时，那么创建File对象时，除了指定的目录和路径之外，其他的属性都是取的成员变量的默认值。如上图的file2。

IO流原理及流的分类

Java IO原理

File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用I/O流来完成。
I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
Java程序中，对于数据的输入输出操作以“流(stream)”的方式进行。
java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

流的分类

按操作数据单位不同分为：字节流(8bit)，字符流(16bit)；
按数据流的流向不同分为：输入流，输出流；
按流的角色不同分为：节点流，处理流。

Java的IO流共涉及40多个类，实际上非常规则，都是从如下抽象基类派生的。
由这四个类派生出来的子类名称都是以其类名作为子类名后缀。

抽象基类	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

IO流体系结构

下面👇是一个庞大的关于IO流信息的表格：

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件	FileInputStream	FileOutputStream	FileReader	FileWriter
访问数组	ByteArrayInputStream	ByteArrayOutputStream	CharArrayReader	CharArrayWriter
访问管道	PipedInputStream	PipedOutputStream	PipedReader	PipedWriter
访问字符串			StringReader	StringWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流			InputStreamReader	OutputStreamWriter
对象流	ObjectInputStream	ObjectOutputStream
过滤流	FilterInputStream	FilterOutputStream	FilterReader	FilterWriter
打印流		PrintStream		PrintWriter
推回输入流	PushbackInputStream		PushbackReader
特殊流	DataInputStream	DataOutputStream

表格当中加粗样式的流是我们需要重点学习掌握的！
流的体系结构

/**
 * 字节流（或文件流）       缓冲流（处理流的一种）
 * FileInputStream        BufferedInputStream 
 * FileOutputStream       BufferedOutputStream 
 * FileReader             BufferedReader
 * FileWriter             BufferedWriter
 */

字节流

FileReader

读入数据的基本操作

package io;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import org.junit.Test;

public class IOTest {
	/**
	 * 读取hello.txt文件内容，并输出到控制台
	 */
	@Test
	public void testFileReader(){
		FileReader fr = null;
		try {
			//1.实例化
			File file = new File("hello.txt");
			//2.提供具体的流
			fr = new FileReader(file);
			//3.数据的读入
			int data;
			while((data = fr.read())!=-1) {
				System.out.print((char)data);
			}
		} catch (IOException e) {
		}finally {
			//流的关闭操作
			try {
				if(fr!=null)
					fr.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

FileWriter

写入数据的基本操作

/**
	 * 将一个文件的内容读取后写入到另一个文件
	 */
	@Test
	public void testFileWrtier() throws IOException{
		File file1 = new File("hello1.txt");
		File file2 = new File("hello2.txt");
		FileReader fr = new FileReader(file1);
		FileWriter fw = new FileWriter(file2);
		int len;
		while((len=fr.read())!=-1) {
			fw.write((char)len);
		}
		fw.close();
		fr.close();
	}

FileInputStream & FileOutputStream

	/**
	 * 实现对图片的复制操作
	 * @throws FileNotFoundException 
	 */
	@Test
	public void testFileInputStreamOutputStream() throws IOException {
		File srcFile = new File("C:\\Users\\HPF\\Pictures\\Camera Roll\\WIN_20210612_22_56_19_Pro.jpg");
		File destFile = new File("C:\\Users\\HPF\\Pictures\\Camera Roll\\hpf.jpg");
		FileInputStream fis = new FileInputStream(srcFile);
		FileOutputStream fos = new FileOutputStream(destFile);
		//复制的过程
		byte[] buffer = new byte[5];
		int len;
		while((len=fis.read(buffer))!=-1) {
			fos.write(buffer,0,len);
		}
		fos.close();
		fis.close();
	}

结论：
1.对于文本文件，使用字符流处理；
2.对于非文本文件，使用字节流处理;
3.对于文本文件，我们仅仅想复制一份，那么我们也可以使用字节流来处理，如果我们在内存层面去看文本文件内容的话，可能出现乱码。

处理流

BufferedInputStream & BufferedOutputStream

缓冲流的作用：提供流的读取、写入的速度。
提高读写速度的原因：内部提供了一个缓冲区。
处理流就是“套接”在已有的流的基础上。

package io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import org.junit.Test;

public class BufferedTest {
	@Test
	public void test() throws IOException {
		//1.造文件
		File srcfile = new File("赞.png");
		File destfile = new File("赞1.png");
		//2.造流
		//2.1造节点流
		FileInputStream fis = new FileInputStream(srcfile);
		FileOutputStream fos = new FileOutputStream(destfile);
		//2.2造缓冲流
		BufferedInputStream bis = new BufferedInputStream(fis);
		BufferedOutputStream bos = new BufferedOutputStream(fos);
	    //3.复制的细节：读取、写入
		byte[] buffer = new byte[10];
		int len;
		while((len=bis.read(buffer))!=-1) {
			bos.write(buffer,0,len);
		}
		//要求：先关闭外层的流，再关闭内层的流
		bos.close();
		bis.close();
		//说明：关闭外层流的同时，内层流也会自动关闭。
		//	        那么对于内层流的关闭，我们可以省略。
		/*
		 * fos.close(); fis.close();
		 */
	}ReaderWriter
}

BufferedReader & BufferedWriter

	@Test
	public void testBufferedReaderBufferedWriter() throws IOException {
		// 1.造文件
		File srcfile = new File("hello.txt");
		File destfile = new File("hello1.txt");
		// 2.造流
		// 2.1造节点流
		FileReader fr = new FileReader(srcfile);
		FileWriter fw = new FileWriter(destfile);
		// 2.2造缓冲流
		BufferedReader br = new BufferedReader(fr);
		BufferedWriter bw = new BufferedWriter(fw);
		// 3.复制的细节：读取、写入
		/*
		 * char[] buffer = new char[10]; int len; while ((len = br.read(buffer)) != -1)
		 * { bw.write(buffer, 0, len); }
		 */
		String data;
		while((data=br.readLine())!=null) {
			bw.write(data);
			bw.newLine();
		}
		bw.close();
		br.close();
	}

例：图片加密解密

思路：异或运算

package io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import org.junit.Test;

/**
 * 图片的加密与解密
 * @author HPF
 *
 */
public class JiamiJiemi {
	@Test
	public void testJiami() throws IOException {
		FileInputStream fi = new FileInputStream("赞.png");
		FileOutputStream fo = new FileOutputStream("加密的赞.png");
		byte[] buffer = new byte[10];
		int len;
		while((len=fi.read(buffer))!=-1) {
			//加密操作
			for(int i=0;i<len;++i) {
				buffer[i] ^=9;
			}
			fo.write(buffer,0,len);
		}
		fo.close();
		fi.close();
	}
	@Test
	public void testJiemi() throws IOException {
		FileInputStream fi = new FileInputStream("加密的赞.png");
		FileOutputStream fo = new FileOutputStream("解密的赞.png");
		byte[] buffer = new byte[10];
		int len;
		while((len=fi.read(buffer))!=-1) {
			//加密操作
			for(int i=0;i<len;++i) {
				buffer[i] ^=9;
			}
			fo.write(buffer,0,len);
		}
		fo.close();
		fi.close();
	}
}

例：统计文本文件中每个字符出现的次数

/**
	 * 统计文本文件中每个字符出现的次数，将次数保存在map中
	 * @throws IOException 
	 */
	@Test
	public void test() throws IOException {
		FileReader fr = new FileReader("hello.txt");
		HashMap<Character, Integer> hashMap = new HashMap<Character,Integer>();
		int len;
		while((len = fr.read())!=-1) {
			char c = (char)len;
			hashMap.put(c, hashMap.getOrDefault(c, 0)+1);
		}
		fr.close();
		Set<Character> keySet = hashMap.keySet();
		for (Character character : keySet) {
			System.out.println(character+":"+hashMap.get(character)+"个");
		}
	}

转换流

转换流提供了在字节流和字符流之间的转换。
Java API提供了两个转换流：

InputStreamReader：将InputStream转换为Reader
OutputStreamWriter：将OutputStream转换为Writer
字节流中的数据都是字符时，转换成字符流操作更高效。
很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。

package io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import org.junit.Test;

/**
 1. @author HPF
 *1.转换流：属于字符流
 2.  InputStreamReader:将一个字节的输入流转换为字符的输入流
 3.  OutputStreamWriter：将一个字符的输出流转换为字节的输出流
 *2.作用：提供字节流与字符流之间的转换
 *3.解码：字节、字节数组--->字符数组、字符串
 4.  编码：字符数组、字符串--->字节、字节数组
 */
public class InputStreamReaderTest {

	@Test
	public void test() throws IOException {
		FileInputStream fis = new FileInputStream("hello.txt");
		//使用系统默认的字符集
		InputStreamReader isr = new InputStreamReader(fis);
		//参数2指明了字符集，具体使用哪个字符集，取决于hello.txt保存时使用的字符集
		//InputStreamReader isr = new InputStreamReader(fis, "utf-8");
		char[] buffer = new char[2];
		int len;
		while((len=isr.read(buffer))!=-1) {
			String str = new String(buffer,0,len);
			System.out.print(str);
		}
		isr.close();
		fis.close();
	}
	@Test
	public void test2() throws IOException {
		FileInputStream fis = new FileInputStream("hello.txt");
		FileOutputStream fos = new FileOutputStream("hell0_gbk.txt");
		InputStreamReader isr = new InputStreamReader(fis,"utf-8");
		OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
		//读写过程
		char[] cbuff = new char[2];
		int len;
		while((len=isr.read(cbuff))!=-1) {
			osw.write(cbuff, 0, len);
		}
		//关闭资源
		osw.close();
		isr.close();
	}
}

字符集(字符编码)

ASCII： 美国标准信息交换码
用一个字节的7位表示，首位默认都是0.
ISO8859-1： 拉丁码表(欧洲码表)
用一个字节的8位表示。
GB2312： 中国的中文码表
最多两个字节编码所有字符。
GBK： 中国的中文编码表升级版本，融合了更多的中文文字符号。最多两个字节编码。
Unicode： 国际标准码
融合了目前人类使用的所有字符，为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
UTF-8： 变长的编码方式，可用1-4个字节来表示一个字符。

Unicode的编码设计并不完美，其中就有以下三个问题：
1.我们已经知道，英文字母只用一个字节表示就够了。
2.如何才能区别Unicode和ASCII？计算机底层怎么知道两个字节表示一个符号，而不是分别表示两个符号呢？
3.如果和GBK等双字节编码方式一样，用最高位是0/1表示一个字节/两个字节，那么整体Unicode可以表示的字符就少了一半，导致很多值无法用于表示某些字符，就不够去表示所有字符了。
综上问题，导致Unicode在很长一段时间内无法推广。
ANSI编码： 通常指的是平台的默认编码，例如英文操作系统中是ISO-8859-1，中文系统是GBK。

标准输入、输出流

package io;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import org.junit.Test;

public class OtherStreamTest {
	/**
	 * 1.标准的输入、输出流
	 * 1.1
	 * System.in:标准的输入流，默认从键盘输入
	 * System.out:标准的输出流，默认从控制台输出
	 * 1.2
	 * System类的setIn/setOut方式重新指定输入和输出的流
	 * 1.3 练习：
	 * 从键盘输入字符串，要求将读取到的整行字符串转成大写输出。
	 * 然后继续进行输入操作，直到输入的字符串是exit。
	 * @throws IOException 
	 */
	@Test
	public void test1() throws IOException {
		InputStreamReader isr = new InputStreamReader(System.in);
		BufferedReader br = new BufferedReader(isr);
		while(true) {
			System.out.println("请输入字符串：");
			String data = br.readLine();
			if(data.equalsIgnoreCase("exit")) {
				System.out.println("程序结束！");
				br.close();
				return;
			}
			System.out.println(data.toUpperCase());
		}
	}
}

打印流

打印流实现将基本数据类型的数据格式转化为字符串输出。
打印流：PrintStream和PrintWriter

提供了一系列重载的print()和println()方法，用于多种数据类型的输出；
PrintStream和PrintWriter的输出不会抛出IO异常；
PrintStream和PrintWriter有自动flush功能；
PrintStream打印的所有字符都是用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用PrintWriter类；
System.out返回的是PrintStream的实例。

package io;

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

import org.junit.Test;

public class OtherStreamTest {
	@Test
	public void test1() throws IOException {
		FileOutputStream fos = new FileOutputStream("hello.txt");
		PrintStream ps = new PrintStream(fos,true);
		if(ps!=null) {
			System.setOut(ps);
		}
		for(int i=0;i<=255;++i) {
			System.out.println((char)i);
		}
		fos.close();
	}
}

说明：上面的代码执行后就不会在控制台输出结果了，而是把结果保存到我们写好的文件当中。

数据流

作用：用于读取或写出基本数据类型的变量或字符串。

package io;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import org.junit.Test;

public class OtherStreamTest {
	@Test
	public void test() throws IOException {
		FileOutputStream fos = new FileOutputStream("hello.txt");
		DataOutputStream dos = new DataOutputStream(fos);
		dos.writeUTF("小黄同学");
		dos.flush();//刷新操作，将内存中的数据写入到文件当中
		dos.writeInt(26);
		dos.flush();
		dos.close();
	}
	/**
	 * 将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。
	 * @throws IOException
	 * 注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！
	 */
	@Test
	public void test1() throws IOException {
		InputStream fos = new FileInputStream("hello.txt");
		DataInputStream dis = new DataInputStream(fos);
		String name = dis.readUTF();
		int age = dis.readInt();
		System.out.println(name+age);
		dis.close();
	}
}

对象流

ObjectInputStream和ObjectOutputStream
用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
序列化： 用ObjectInputStream类保存基本类型数据或对象的机制。
反序列化： 用ObjectOutputStream类读取基本类型数据或对象的机制。
ObjectInputStream和ObjectOutputStream不能序列化static和transient修饰的成员变量。

对象的序列化

对象序列化机制允许把内存中的Java对象转换成与平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象。
序列化的好处在于可以将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原。
序列化时RMI（远程方法调用）过程的参数和返回值都必须实现的机制，而RMI是JavaEE的基础。因此序列化机制是JavaEE平台的基础。
如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现下面的两个接口之一：
1.Serializable
2.Externalizable

package io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import org.junit.Test;
/**
 * @author HPF
 *对象流的使用
 */
public class OtherStreamTest {
	@Test
	public void test() throws IOException {
		//序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
		FileOutputStream fos = new FileOutputStream("hello.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(new String("我爱北京天安门"));
		oos.flush();
		oos.close();
	}
	@Test
	public void test2() throws IOException {
		//反序列化过程：将java对象写入到内存层面
		FileInputStream fis = new FileInputStream("hello.txt");
		ObjectInputStream ois = new ObjectInputStream(fis);
		try {
			Object obj = ois.readObject();
			String str = (String)obj;
			System.out.println(str);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(ois!=null)
				ois.close();
		}
	}
}

一个类可以序列化需要满足的条件：
1.需要实现接口Serializable；
2.当前类需要声明一个静态变量serialVersionUID；
3.除了当前类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的。（默认情况下，基本数据类型都是可以序列化的）
对serialVersionUID的理解：
凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量serialVersionUID。
serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
如果类没有显示定义这个静态变量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID可能发生改变，我们建议显式声明。
简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传过来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。（InvalidCastException）