Java--IO 文件处理和流传输-CFANZ编程社区

不管是什么开发语言，都要提供对硬盘数据的处理功能，Java自然也不能例外。什么是I/O呢？I/O（input/output）即输入/输出。Java中的I/O操作是通过输入/输出数据流的形式来完成的，因此它也称作数据流操作。

简单来说，I/O实际上就是一种数据的输入/输出方式，其中输入模式是指允许程序读取外部程序（包括来自磁盘、光盘等存储设备的数据）、用户输入的数据。这些数据源都是文件、网络、压缩包或其他数据。下图即为输入模式：

未命名文件 (1)

输出模式与输入模式恰好相反，输出模式是指允许程序记录运行状态，将程序数据输出到磁盘、光盘等存储设备中。

Java I/O操作主要指的是使用 Java 进行输入、输出操作，Java 中的所有操作类都存放在 java.io 包中，在使用时需要导入此包。

在整个 java.io 包中最重要的就是 5 个类和 1个接口，这5个类分别是 File、OutputStream、InputStream、Writer 和 Reader，1个接口是 Serializable。

File 类

在整个 I/O 包中，唯一与文件有关的类就是 File 类。使用 File 类可以实现创建或删除文件等常用的操作功能。File 类的方法如下：

方法/常量	类型	描述
public static final String pathSeparator	常量	路径分隔符，Windows系统中为 “;”
public static final String separator	常量	路径分隔符，Windows系统中为 “\”
public File(String pathname)	构造	创建File类对象，传入完整路径
public boolean createNewFile throws IOException	普通	创建新文件
public boolean delete()	普通	删除文件
public boolean exists()	普通	判断文件是否存在
public boolean isDirectory()	普通	判断给定路径是否是一个目录
public long length()	普通	返回文件的大小
public String[] list()	普通	列出指定目录的全部内容，只列出名称
public File[] listFiles()	普通	列出指定目录的全部内容，会列出路径
public boolean mkdir()	普通	创建一个目录
public boolean renameTo(File dest)	普通	为已有的文件重新命名

代码示例1：在 E盘下创建一个名为 test.txt的文件

import java.io.File;
import java.io.IOException;

public class TestFile {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		File f = new File("E:" + File.separator + "test.txt");
		if(f.exists()) { // 如果文件已存在，则删除原有文件
			f.delete();
		}
		f.createNewFile();
	}
}

代码示例2：在 E盘下创建一个名为 text 的文件夹

import java.io.File;
import java.io.IOException;

public class TestFile {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		File f = new File("E:" + File.separator + "text");
		if(f.exists()) { // 如果目录已存在，则删除原有目录
			f.delete();
		}
		f.mkdir();
	}
}

代码示例3：列出E盘下名为 QQ消息记录文件夹下的全部内容，名称+路径

import java.io.File;
import java.io.IOException;

public class TestFile {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		File f = new File("E:" + File.separator + "QQ消息记录");
		
		// 列出指定目录下的全部内容，只列出名称
		String[] list1 = f.list();
		for(String fileName : list1) {
			System.out.println(fileName);
		}
		
		// 列出指定目录下的全部内容，会列出路径
		File[] list2 = f.listFiles();
		for(File file : list2) {
			System.out.println(file.getAbsolutePath());
		}
	}
}

RandomAccessFile 类

File 类针对文件本身进行操作，不对文件内容进行操作。类 RandomAccessFile 属于随机读取类，可以随机读取一个文件中指定位置的数据。RandomAccessFile 类的常用方法如下：

public RandomAccessFile(File file,String mode) throws FileNotFoundException;
// 接收File 类对象，设置模式，r为只读，w为只写，rw为读写
public RandomAccessFile(String name,String mode) throws FileNotFoundException;
// 输入固定的文件路径，设置模式同上
public void close() throws IOException;
// 关闭操作
public int read(byte[] b) throws IOException;
// 将内容读取到一个字节数组中
public final byte readByte() throws IOException;
// 读取一个字节
public final int readInt() throws IOException;
// 从文件中读取整型数据
public void seek(long pos) throws IOException;
// 设置读指针的位置
public final void writeBytes(String s) throws IOException;
// 将一个字符串写入到文件中，按字节的方式处理
public final void writeInt(int v) throws IOException;
// 讲一个int类型数据写入文件，长度为4位
public int skipBytes(int n) throws IOException;
// 指针跳过多少个字节

注意：当使用 rw 方式声明 RandomAccessFile 对象时，如果要写入的文件不存在，则系统会自动创建

代码示例：使用RandomAccessFile 类读取数据，并在内容末尾加上内容

假设E:\\test.txt文件中有以下三行数据：

Hello World!!!
Hello Wuhan!!!
Hello HUST!!!

代码目标是读取这三行数据输出到控制台，并将Hello CSDN!!!加到数据末尾。

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

public class TestFile {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		// 指定要操作的文件
		File f = new File("E:" + File.separator + "test.txt");
		
		// 声明RandomAccessFile对象，设定读写模式
		RandomAccessFile rdf = new RandomAccessFile(f,"rw");
		
		// 读取文件内容
		byte[] buf = new byte[(int) f.length()];
		int len = rdf.read(buf);
		// 输出读取的内容
		System.out.println(new String(buf));
		
		// 向文件中写入内容
		String s = "\n" + "Hello CSDN!!!";
		byte[] b = s.getBytes();
		rdf.write(b);
	}
}

字节流与字符流

在 java.io包中流操作主要有字节流和字符流类两大类，这两个类都有输入和输出操作。字节流使用 OutputStream 类输出数据，使用 InputStream 类输入数据。字符流使用 Writer 类输出数据，使用 Reader 类完成输入数据。

I/O操作是有相应步骤的，以文件操作为例，主要操作流程包括：

使用类 File 打开一个文件
通过字节流或字符流的子类指定输出位置
进行读/写操作
关闭输入/输出

字节输出流

OutputStream 是字节输出流的最大父类，它是一个抽象类，要先通过子类实例化对象才能使用此类。OutputStream 类的常用方法如下：

方法	类型	描述
public void close() throws IOException	普通	关闭输出流
public void flush() throws IOException	普通	刷新缓冲区
public void write(byte[] b) throws IOException	普通	将一个字节数组写入数据流
public void write(byte[] b，int off，int len) throws IOException	普通	将一个指定范围内的字节数组写入数据流
public abstract void write(int b) throws IOException	普通	讲一个字节数据写入数据流

代码示例：向 E盘中的 test.txt 文件中写入 Hello World!!!

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class TestFile {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		// 1.使用类 File 打开一个文件
		File f = new File("E:" + File.separator + "test.txt");
		
		// 2.使用OutputStream的子类指定输出位置
		OutputStream out = new FileOutputStream(f);
		
		// 3.进行读写操作
		String str = "Hello World！！！";
		byte[] b = str.getBytes();
		out.write(b);
		
		// 4.关闭输入/输出
		out.close();
	}
}

代码示例2：在E盘中的 test.txt 文件中追加数据 Hello CSDN！！！

上面的代码，如果重新执行程序，则会覆盖文件中的内容。想要在原数据后追加新的数据，可以使用子类 FileOutputStream的另一个构造方法：

public FileOutputStream(File file,boolean append) throws FileNotFoundException;// append设为true，即为追加

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class TestFile {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		// 1.使用类 File 打开一个文件
		File f = new File("E:" + File.separator + "test.txt");
		
		// 2.使用OutputStream的子类指定输出位置
		OutputStream out = new FileOutputStream(f,true);
		
		// 3.进行读写操作
		String str = "\r\n Hello World！！！";
		byte[] b = str.getBytes();
		out.write(b);
		
		// 4.关闭输入/输出
		out.close();
	}
}

注意：对于写入的数据要换行。直接在字符串要换行处加入一个“\r\n”即可。

字节输入流

InputStream 类也是一个抽象类，其子类是 FileInputStream 类。InputStream 类的主要方法如下：

方法	类型	描述
public int abailable() throws IOException	普通	可以取得输入文件的大小
public void close() throws IOException	普通	关闭输入流
public abstract int read() throws IOException	普通	以数组的方式读取内容
public int read(byte[] b) throws IOException	普通	将内容读到字节数组中，同时返回读入的个数

代码示例1：使用read(byte[] b) 方法读取 E盘中 test.txt文件的内容

public class TestFile {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		// 1.使用类 File 打开一个文件
		File f = new File("E:" + File.separator + "test.txt");
		
		// 2.使用InputStream的子类指定输出位置
		InputStream input = new FileInputStream(f);
		
		// 3.进行读写操作
		byte[] b = new byte[(int) f.length()];
		int len = input.read(b);
		System.out.println(new String(b));
		
		// 4.关闭输入/输出
		input.close();
	}
}

上述代码中可以通过 f.length() 指到存放数据的字节数组的具体大小，但是在文件长度无法知道的情况下，可以用下面的代码来进行：

代码示例2：未知内容时读取文件的内容

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class TestFile {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		// 1.使用类 File 打开一个文件
		File f = new File("E:" + File.separator + "test.txt");
		
		// 2.使用InputStream的子类指定输出位置
		InputStream input = new FileInputStream(f);
		
		// 3.进行读写操作
		byte[] buf = new byte[1024]; // 数组大小由文件决定
		int len = 0;	// 初始化变量len
		int temp = 0;	// 初始化变量temp
		while((temp = input.read()) != -1) {
			// 接收每一个进行来的数据
			buf[len] = (byte)temp;
			len++;
		}
		
		// 4.关闭输入/输出
		input.close();
		System.out.println("内容为：" + new String(buf,0,len));
	}
}

字符输出流

Writer 类是抽象类，其子类为 FileWriter 类，常用的方法如下：

方法	类型	描述
public abstract void close() throws IOException	普通	关闭输出流
public void write(String str) throws IOException	普通	输出字符串
public void write(char[] ch) throws IOException	普通	输出字符串组
public abstract void flush() throws IOException	普通	强制性清空缓存

代码示例1：使用FileWriter 向指定文件中写入内容

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class TestWriter {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		// 使用类File打开一个文件
		File file = new File("E:" + File.separator + "test.txt");
		
		// 获取字符输出流对象
		Writer writer = new FileWriter(file);
		
		// 写入内容
		String str = "Java从入门到精通";
		writer.write(str);
		
		// 关闭输出流
		writer.close();
	}

}

代码示例2：使用FileWriter 类在指定文件中追加内容

public FileWriter(File file,boolean append) throws IOException; // append为true，则追加

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class TestWriter {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		// 使用类File打开一个文件
		File file = new File("E:" + File.separator + "test.txt");
		
		// 获取字符输出流对象
		Writer writer = new FileWriter(file,true);
		
		// 写入内容
		String str = "\r\n Java 网络编程";
		writer.write(str);
		
		// 关闭输出流
		writer.close();
	}

}

字符输入流

Reader类同样是抽象类，子类为FileReader类，常用方法如下：

方法	类型	描述
public abstract void close() throws IOException	普通	关闭输出流
public int read() throws IOException	普通	读取单个字符
public int read(char[] ch) throws IOException	普通	将内容读到字符数组中，返回读入的长度

代码示例：使用FileReader 读取指定文件中的内容

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class TestReader {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		File file = new File("E:" + File.separator + "test.txt");
		
		Reader reader = new FileReader(file);
		
		char[] ch = new char[1024];
		int len = reader.read(ch);
		
		reader.close();
		System.out.println("内容为：" + new String(ch,0,len));
	}

}

字节转换流

流的类型分为字节流和字符流，除此之外，还存在一组“字节流-字符流”的转换类，用于两者之间的转换。

OutputStreamWriter：Writer的子类，字符输出流转字节输出流。
InputStreamReader：Reader的子类，字节输入流转字符输入流。

代码示例：操作指定文件

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;

public class Test {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		File file = new File("E:" + File.separator + "test.txt");
		
		InputStream input = new FileInputStream(file);
		
		// 字节输入流转字符输入流
		Reader reader = new InputStreamReader(input);
		// 读取内容
		char[] ch = new char[1024];
		int len = reader.read(ch);
		// 输出读取内容
		System.out.println("内容为：" + new String(ch,0,len));
		
		// 一定要先关闭流，才能进行后续写操作
		reader.close();
		input.close();
		
		// 定义字节输出流，追加内容
		OutputStream out = new FileOutputStream(file,true);
		
		// 字节输出流转字符输出流
		Writer writer = new OutputStreamWriter(out);
		// 写入内容
		String str = "\r\n Java语言描述 算法与数据结构";
		writer.write(str);		
		
		writer.close();
		out.close();
	}

}

内存操作流

一般在生成一些临时信息时才会使用内存操作流，这些临时信息如果要保存到文件中，则代码执行完成后还要删除这个临时文件，所以此时使用内存操作流是最合适的。内存操作流中 ByteArrayInputStream 类用于将内容写入内存中，ByteArrayOutputStream 类用于输出内存中的数据。

下面为ByteArrayInputStream 类的主要方法：

方法	类型	描述
public ByteArrayInputStream(byte[] buf)	构造	将全部内容写入内存中
public ByteArrayInputStream(byte[] buf，int offset，int lenght)	构造	将指定范围的内容写入到内存中

下面为ByteArrayOutputStream 类的主要方法：

方法	类型	描述
public ByteArray OutputStream()	构造	创建对象
public void write(int b)	普通	将内容从内存中输出

代码示例：使用内存操作流将一个大写字母转换为小写字母

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ByteArrayTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str = "HELLOWORLD"; // 定义字符串，全部由大写字母组成
		// 向内存中输出内容
		ByteArrayInputStream bis = new ByteArrayInputStream(str.getBytes());
		// 准备从内存中读取内容
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		
		int temp = 0;
		while((temp = bis.read()) != -1) {
			char c = (char) temp; // 读取的数字变成字符
			bos.write(Character.toLowerCase(c)); // 将字符变成小写
		}
		
		// 所有数据全部都在ByteArrayOutputStream中
		String newStr = bos.toString(); // 取出内容
		try {
			bis.close();
			bos.close();
		}catch(IOException e) {
			e.printStackTrace();
		}
		System.out.println(newStr);
	}

}

管道流

管道流用于实现两个线程间的通信，这两个线程为管道输出流（PipedOutputStream）和管道输入流（PipedInputStream）。要进行管道输出，就必须把输出流连到输入流上。使用 PipedOutputStream 类以下方法可以实现连接管道功能。

public void connect(PipedInputStream pis) throws IOException;

代码示例：使用管道流实现线程连接

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

class Send implements Runnable{ // 线程类，管道发送线程
	private PipedOutputStream pos = null; // 管道输出流
	
	public Send() {
		this.pos = new PipedOutputStream(); // 实例化输出流
	}
	
	public void run() {
		String str = "Hello World!!!"; // 要输出的内容
		try {
			this.pos.write(str.getBytes());
		}catch(IOException e) {
			e.printStackTrace();
		}
		try {
			this.pos.close();//关闭
		}catch(IOException e) {
			e.printStackTrace();
		}
	}
	
	public PipedOutputStream getPos() { // 得到此线程的管道输出流
		return this.pos;
	}
}

class Receive implements Runnable{ // 线程类，管道接收线程
	private PipedInputStream pis = null; // 管道输入流
	
	public Receive() {
		this.pis = new PipedInputStream(); // 实例化输入流
	}
	
	public void run() {
		byte b[] = new byte[1024]; // 接收内容
		int len = 0;
		try {
			len = this.pis.read(b); // 读取内容
		}catch(IOException e) {
			e.printStackTrace();
		}
		try {
			this.pis.close(); // 关闭
		}catch(IOException e){
			e.printStackTrace();
		}
		System.out.println("接收的内容：" + new String(b,0,len));
	}
	
	public PipedInputStream getPis() {
		return this.pis;
	}
	
}

public class PipedTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Send s = new Send();
		Receive r = new Receive();
		try {
			s.getPos().connect(r.getPis()); // 连接管道
		}catch(Exception e){
			e.printStackTrace();
		}
		new Thread(s).start(); // 启动线程
		new Thread(r).start(); // 启动线程
	}

}

打印流

打印流是输出信息最方便的一个类，主要包括字节打印流（PrintStream）和字符打印流（PrintWriter）。打印流提供了非常方便的打印功能，通过打印流可以打印任何的数据类型，例如小数、整数、字符串等。

PrintStream 类是 OutputStream 的子类，PrintStream 类的常用方法：

方法	类型	描述
public PrintStream(File file) throws FileNotFoundException	构造	通过File对象实例化 PrintStream类
public PrintStream(OutputStream out)	构造	接收 OutputStream 对象以实例化 PrintStream类
public PrintStream printf(Locale l，String format，Object… args)	普通	根据指定的 Locale 进行格式化输出
public PrintStream printf(String format，Object… args)	普通	根据本地环境格式化输出
public void print(boolean b)	普通	此方法可以重载很多次，输出任意数据
public void println(boolean b)	普通	此方法可以重载很多次，输出任意数据后换行

printf()方法的使用类似于C语言。

与OutputStream 类相比，PrintStream 类能更加方便地输出数据。

代码示例

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

public class PrintTest {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		// 声明打印流对象
		PrintStream ps = new PrintStream(new FileOutputStream(new File("E:" + File.separator) + "test.txt"));
		
		// 写入文件内容
		ps.print("hello ");
		ps.println("world!!!");
		ps.print("1 + 1 = " + 2);
		
		// 关闭
		ps.close();
		
	}

}

BufferedReader 类

BufferedReader 类能够从缓冲区中读取内容，所有的字节数据都将放进缓冲区中。常用方法如下：

方法	类型	描述
public BufferedReader(Reader in)	构造	接收一个 Reader 类的实例
public String readLine() throws IOException	普通	一次性从缓冲区中将内容全部读取进来

因为在 BufferedReader 类中定义的构造方法只能接收字符输入流的实例，所以必须使用字符输入流和字节输入流的转换 InputStreamReader 类将字节输入流 System.in 变为字符流。因为每一个汉字要占两字节，所以需要将 System.in 这个字节输入流变为字符输入流。当将 System.in 变为字符流放入到 BufferedReader后，可以通过方法 readLine()等待用户输入信息。

代码示例：输入两个数字，并让两个数字相加

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class BufferedTest {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		int i = 0;
		int j = 0;
		
		// 创建一个输入流，用于接收键盘输入的数据
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = null;
		System.out.println("请输入第一个数字：");
		
		// 接收数据
		str = br.readLine();
		// 将字符串变为整数
		i = Integer.parseInt(str);
		System.out.println("请输入第二个数字：");
		str = br.readLine();
		j = Integer.parseInt(str);
		
		// 输出结果
		System.out.println(i + " + " + j + " = " + (i+j));
		
		// 关闭
		br.close();
	}

}

数据操作流

在 Java 的 I/O 包中，提供了两个与平台无关的数据操作流，它们分别为数据输出流（DataOutputStream）和数据输入流（DataInputStream）。数据输出流会按照一定的格式输出数据，再通过数据输入流按照一定的格式将数据读入，这样可以方便对数据进行处理。

常见的订单数据就适合用数据操作流来实现。

商品名	价格/元	数量/个
帽子	98.3	3
衬衣	30.3	2
裤子	50.5	1

DataOutputStream 类

public class DataOutputStream extends FilterOutputStream implements DataOutput;

DataOutputStream 类继承 FilterOutputStream 类（FilterOutputStream 和 OutputStream 的子类），同时实现了 DataOutput 接口，在 DataOutput 接口定义了一系列写入各种数据的方法。

DataOutput 是数据的输出接口，其中定义了各种数据的输出操作方法，例如在 DataOutputStream 类中的各种 writeXxx() 方法就是此接口定义的。但是在数据输出时一般会直接使用DataOutputStream。

DataOutputStream 类常用方法如下：

方法	类型	描述
public DataOutputStream(OutputStream out)	构造	实例化对象
public final void writeInt(int v) throws IOException	普通	将一个 int 值以4字节形式写入基础输出流中
public final void writeDouble(double v) throws IOException	普通	写入一个 double 类型，以8字节值形式写入基础输出流
public final void writeChars(String s) throws IOException	普通	将一个字符串写入到输出流中
public final void writeChar(int v) throws IOException	普通	将一个字符写入到输出流中

代码示例：将订单数据写入到 order.txt 中

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;

public class DataOutputTest {

	public static void main(String[] args) throws Exception{ //抛出所有异常
		// TODO Auto-generated method stub
		File file = new File("E:" + File.separator + "order.txt");
		if(!file.exists()) {
			file.createNewFile();
		}
		DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
		
		String itemNames[] = {"帽子","衬衣","裤子"};
		Float price[] = {98.3f,30.3f,50.5f};
		int nums[] = {3,2,1};
		
		for(int i = 0;i < itemNames.length; i++) {
			dos.writeChars(itemNames[i]);
			// 写入分隔符
			dos.writeChar('\t');
			dos.writeFloat(price[i]);
			dos.writeChar('\t');
			dos.writeInt(nums[i]);
			// 写入换行符
			dos.writeChar('\n');
		}
		
		// 关闭
		dos.close();
	}

}

这个时候运行，发现出现了乱码问题，如下面这张图

可以看到编码格式为ANSI，为了防止乱码，最好设置字符编码为UTF-8，在写入的时候调用writeUTF()方法。（暂且想不到其它更好的方法）

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;

public class DataOutputTest {

	public static void main(String[] args) throws Exception{ //抛出所有异常
		// TODO Auto-generated method stub
		File file = new File("E:" + File.separator + "order.txt");
		DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
	
		String names[] = {"衬衣","手套","围巾"}; // 商品名称
		Float prices[] = {98.3f,30.3f,50.5f}; // 商品价格
		int nums[] = {3,2,1};	// 商品数量
		
		for(int i = 0;i < names.length; i++) {
			dos.writeUTF(names[i]);
			// 写入分隔符
			dos.writeChar('\t');
			dos.writeUTF(prices[i].toString());
			dos.writeChar('\t');
			dos.writeUTF(nums[i] + "");
			// 写入换行符
			dos.writeChar('\n');
		}
		
		// 关闭
		dos.close();
	}

}

DataInputStream 类

DataInputStream 类是 InputStream 的子类，能够读取并使用 DataOutputStream 输出的数据。

public class DataInputStream extends FilterInputStream implements DataInput

常用方法如下：

方法	类型	描述
public DataInputStream(InputStream in)	构造	实例化对象
public final int readInt() throws IOException	普通	从输入流中读取整数
public final float readFloat() throws IOException	普通	从输入流中读取小数
public final char readChar() throws IOException	普通	从输入流中读取一个字符

代码示例

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
public class DataInputTest{
    public static void main(String args[]) throws Exception{
        File file = new File("E:" + File.seperator + "order.txt");
        DataInputStream dis = new DataInputStream(new FileInputStream(file));
        
        String name = null; // 接收名称
        float price = null; // 接收价格
        int num = 0; // 接收数量
        char temp[] = null; // 接收商品名称
        int len = 0; // 保存读取数据的个数
        char c = 0; // '\u0000'
        try{
            while(true){
                temp = new char[200]; // 开辟空间
                len = 0;
                while((c = dis.readChar()) != '\t'){
                    // 接收内容
                    temp[len] = c;
                    len++; // 读取长度加1
                }
                name = new String(temp,0,len); // 将字符数组变为String
                price = dis.readFloat(); // 读取价格
                dis.readChar(); // 读取\t
                num = dis.readInt(); // 读取int
                dis.readChar(); //读取\n
                System.out.printf("名称：%s; 价格：%5.2f; 数量：%d\n",name,price,num);
            }
        }catch(Exception e){}
        dis.close();
    }
}

压缩流

Java 提供了专门的压缩，可以将文件或文件夹压缩成 ZIP、JAR、GZIP 等文件形式。这里只写下压缩成ZIP的笔记。

ZIP 是一种较为常见的压缩形式，在 Java 中要实现 ZIP 压缩需要导入 java.util.zip 包，然后使用此包中的 ZipFile、ZipOutputStream、ZipIntputStream 和 ZipEntry 几个类完成操作。

在每个压缩文件中都会存在多个子文件，每个子文件在 Java 中都使用 ZipEntry 来表示。ZipEntry 常用方法如下：

方法	类型	描述
public ZipEntry(String name)	构造	创建对象并指定要创建的 ZipEntry 名称
public boolean isDirectory()	普通	判断此 ZipEntry 是否为目录

ZipOutputStream 类

ZipOutputStream 类用于完成一个文件或文件夹的压缩。常用操作方法如下：

方法	类型	描述
public ZipOutputStream(OutputStream out)	构造	创建新的 ZIP 输出流
public void putNextEntry(ZipEntry e) throws IOException	普通	设置每个 ZipEntry 对象
public void setComment(String comment)	普通	设置ZIP 文件的注释

代码示例1：将E盘中的test.txt 文件压缩成文件 www.zip

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipOutputTest {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		File file = new File("E:" + File.separator + "test.txt"); // 定义要压缩的文件
		File zipFile = new File("E:" + File.separator + "www.zip"); // 定义压缩文件的名称
		InputStream input = new FileInputStream(file); //文件输入流
		
		// 压缩输出流
		ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(zipFile));
		// 设置ZipEntry 对象
		zipOut.putNextEntry(new ZipEntry(file.getName()));
		// 设置注释
		zipOut.setComment("www.www.cn");
		
		int temp = 0;
		while((temp = input.read()) != -1) { // 读取内容
			zipOut.write(temp); // 压缩输出
		}
		
		// 关闭输入/输出流
		input.close();
		zipOut.close();
		
	}

}

代码运行后得到压缩文件，可以看下面这张图。

代码示例2：压缩E盘中名为test的文件夹

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipOutputTest2 {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		// 要压缩的文件夹
		File file = new File("E:" + File.separator + "test");
		// 压缩文件
		File zipFile = new File("E:" + File.separator + "www2.zip");
		
		// 声明文件输入流
		InputStream input = null;
		// 定义压缩流
		ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(zipFile));
		// 注释
		zipOut.setComment("www.www.cn");
		
		int temp = 0;
		if(file.isDirectory()) { // 判断是否是文件夹
			File lists[] = file.listFiles(); // 列出全部文件
			for(int i=0; i < lists.length; i++) {
				input = new FileInputStream(lists[i]); // 定义文件的输入流
				// 设置ZipEntry 对象
				zipOut.putNextEntry(new ZipEntry(file.getName() + File.separator + lists[i].getName()));
				
				// 读取内容
				while((temp = input.read())!=-1) {
					zipOut.write(temp);
				}
				
				// 关闭输入流
				input.close();
			}
		}
		
		// 关闭输出流
		zipOut.close();
	}

}

代码运行后的结果可以看下图。

ZipFile 类

每个压缩文件都可以用File 类或ZipFile 类来表示。可以使用 ZipFile 根据压缩后的文件名找到每个压缩文件中的 ZipEntry 并对其执行解压缩操作。ZipFile 类常用方法如下：

方法	类型	描述
public ZipFile(File file) throws ZipException，IOException	构造	根据 File 类实例化 ZipFile 对象
public ZipEntry getEntry(String name)	普通	根据名称找到对应的 ZipEntry
public InputStream getInputStream(ZipEntry entry) throws IOException	普通	根据 ZipEntry 取得 InputStream 实例
public String getName()	普通	得到压缩文件的路径名称

代码示例：实例化 ZipFile 对象

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import java.util.zip.ZipFile;
import java.io.FileOutputStream;
public class ZipFileTest{
    public static void main(String args[]) throws Exception{ //抛出所有异常
        File file = new File("E:" + File.seperator + "www.zip");
        ZipFile zipFile = new ZipFile(file); // 实例化ZipFile 对象
        System.out.println("压缩文件的名称" + zipFile.getName()); // 得到压缩对象的名称
    }
}

ZipInputStream 类

ZipInputStream 类是 InputStream 类的子类，通过此类可以方便地读取ZIP 格式的压缩文件，常用方法如下：

方法	类型	描述
public ZipInputStream(InputStream in)	构造	实例化 ZipInputStream 对象
public ZipEntry getNextEntry() throws IOException	普通	取得下一个 ZipEntry

通过使用 ZipInputStream 类中的 getNextEntry() 方法可以依次取得每个 ZipEntry，这样可将此类与 ZipFile 结合从而对压缩的文件夹执行解压缩的操作。

代码示例：获取www2.zip 中的所有 ZipEntry

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class ZipInputTest {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		// 定义压缩文件的名称
		File zipFile = new File("E:" + File.separator + "www2.zip");
		// 定义压缩输入流
		ZipInputStream input = new ZipInputStream(new FileInputStream(zipFile));
		
		// 获取所有的ZipEntry
		ZipEntry entry = null;
		while((entry = input.getNextEntry())!=null) {
			System.out.println("压缩实体名称：" + entry.getName());
		}
	}

}

执行结果（与前面的图片对照）

压缩实体名称：test\missfont.log
压缩实体名称：test\test.py
压缩实体名称：test\text.aux
压缩实体名称：test\text.dvi
压缩实体名称：test\text.fdb_latexmk
压缩实体名称：test\text.fls
压缩实体名称：test\text.log
压缩实体名称：test\text.pdf
压缩实体名称：test\text.synctex.gz
压缩实体名称：test\text.tex

字符编码

在计算机世界，任何文字都是以指定的编码方式存在的，在Java 中最常见的有 ISO8859-1、GBK/GB2312、Unicode、UTF编码。

ISO8859-1属于单字节编码，最多只能表示 0~255个字符，主要是英文上应用。

GBK/GB2312是中文的国际编码，是双字节编码，专门用来表示汉字。如果在此编码中出现英文，则使用ISO8859-1编码。GBK可以表示简体和繁体中文；而GB2312只能表示简体中文。GBK兼容GB2312。

Unicode是最标准的一种编码，使用十六进制表示编码，它的问题在于不兼容ISO8859-1编码。

UTF用于弥补Unicode编码的不足。由于Unicode不支持ISO8859-1编码，且自身是十六进制编码容易占有更多的空间，再加上英文字母也需要使用两个字节来编码，使得Unicode不便于传输和存储，因此产生了UTF编码。UTF编码可以用来表示所有的语言字符，也兼容ISO8859-1编码。缺点是字符长度不等。

关于乱码问题

在程序中如果处理不好字符的编码，那么就有可能出现乱码问题。如果现在本机的默认编码是GBK，但在程序中使用了ISO8859-1编码，则会出现字符的乱码问题。

如果要避免产生乱码，则程序的编码与本地的默认编码要保持一致。

代码示例1：通过System类来得到本机编码

public class CharSetTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 获取当前系统编码
		System.out.println("系统默认编码：" + System.getProperty("file.encoding"));
	}

}

运行结果

系统默认编码：GBK

String 类中的 getBytes(String charset)方法可以设置文件的编码。

代码示例2：通过getBytes方法产生乱码

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class CharSetTest2 {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		File file = new File("E:" + File.separator + "test.txt");
		OutputStream out = new FileOutputStream(file);
		
		// 实例化输出流
		// 转码保存
		byte b[] = "甄嬛传永远滴神".getBytes("ISO8859-1");
		// 写入
		out.write(b);
		// 关闭输出流
		out.close();
	}

}

运行结果

对象序列化

对象序列化就是把一个对象变为二进制数据流的一种方法，通过对象序列化可以方便地实现对象的传输或存储。

Serializable 接口

如果我们想使自己创建的一个类的对象进行序列化，那么必须让这个类继承Serializable接口。

public interface Serializable{};

这个接口里面是没有定义任何方法的，它只是一个标识接口，实现了这个接口，就标示这该类可以被序列化。

代码示例：定义一个可序列化的类

import java.io.Serializable;

public class AdminUser implements Serializable{
	private String username;
	private String password;
	private int age;
	
	public AdminUser() {}
	
	public AdminUser(String username,String password,int age) {
		this.username = username;
		this.password = password;
		this.age = age;
	}
	
	public void setUsername(String username) {
		this.username = username;
	}
	
	public void setPassword(String password) {
		this.password = password;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	public String getUsername() {
		return this.username;
	}
	
	public String getPassword() {
		return this.password;
	}
	
	public int getAge() {
		return this.age;
	}
	
	@Override
	public String toString() {
		return "用户名：" + this.username + "; 密码：" + this.password
				+ "; 年龄：" + this.age;
	}
}

仅仅这样实现了接口还不够，真正的序列化要借助于对象输入/输出流。对象输出流进行序列化操作，将类的对象转化为二进制数据进行保存。对象输入流进行反序列化操作，将保存的二进制数据转化为类的对象。

ObjectOutputStream 类

对象输出流 ObjectOutputStream 类的常用方法如下：

方法	类型	描述
public ObjectOutputStream(OutputStream out) throws IOException	构造	传入输出的对象
public final void writeObject(Object obj) throws IOException	普通	输出对象

代码示例：将上面的AdminUser类的对象保存到文件中

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectOutputTest {

	public static void main(String[] args) throws IOException{
		// TODO Auto-generated method stub
		File file = new File("E:" + File.separator + "test.txt");
		// 对象输出流
		ObjectOutputStream objectOut = new ObjectOutputStream(new FileOutputStream(file));
		
		// 保存AdminUser对象
		objectOut.writeObject(new AdminUser("admin", "123456", 18));
		// 关闭输出流
		objectOut.close();
	}

}

运行结果

ObjectInputStream 类

对象输入流ObjectInputStream 类的主要操作方法如下：

方法	类型	描述
public ObjectInputStream(InputStream in) throws IOException	构造	构造输入对象
public final Object readObject() throws IOException，ClassNotFoundException	普通	从指定位置读取对象

代码示例：反序列化保存在文件中的AdminUser对象

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInputTest {

	public static void main(String[] args) throws IOException, ClassNotFoundException{
		// TODO Auto-generated method stub
		File file = new File("E:" + File.separator + "test.txt");
		
		// 实例化对象输入流
		ObjectInputStream objectInput = new ObjectInputStream(new FileInputStream(file));
		// 读取对象
		AdminUser adminUser = (AdminUser) objectInput.readObject();
		// 关闭输入流
		objectInput.close();
		// 输出对象
		System.out.println(adminUser.toString());
	}

}

代码执行结果

用户名：admin; 密码：123456; 年龄：18

根据代码执行结果，我们可以发现，对象输出流把我们定义的AdminUser类的所有信息都序列化保存到文件里面去了。

但是现在我们有一个新的需求，假如说甲方爸爸希望我们只将部分信息序列化保存到文件，该怎么完成这个需求？——如果我们想根据自己的需要选择序列化的属性，就可以使用另一个序列化接口：Externalizable或者关键字transient。

Externalizable 接口

此接口是Serializable接口的子接口。

public interface Externalizable extends Serializable{
    public void writeExternal(ObjectOutput out) throws IOException;
    public void readExternal(ObjectInput in) throws IOException,ClassNotFoundException;
}

write(ObjectOutput out)：在此方法中指定要保存的属性信息，它在对象序列化时调用。
readExternal(ObjectInput in)：在此方法中读取保存的属性信息，它在对象反序列话时调用。

当一个类要使用 Externalizable实现序列化时，此类中必须存在一个无参构造方法，因为在反序列化时会默认调用无参构造实例化对象，如果没有此无参构造，则运行时将会出现异常。

代码示例1：定义一个Department类实现此接口

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Department implements Externalizable{
	private long departmentId;
	private String departmentName;
	
	// 无参构造
	public Department() {}
	
	// 有参构造
	public Department(long departmentId,String departmentName) {
		this.departmentId = departmentId;
		this.departmentName = departmentName;
	}
	
	// 覆盖此方法，根据需要读取内容，反序列化时使用它
	@Override
	public void readExternal(ObjectInput in) throws IOException,ClassNotFoundException{
		this.departmentName = (String) in.readObject(); // 读取departmentName
	}
	
	// 覆盖此方法，根据需要可以保存属性或具体内容，序列化时使用它
	@Override
	public void writeExternal(ObjectOutput out) throws IOException{
		out.writeObject(this.departmentName);
	}
	
	public void setDepartmentId(long departmentId) {
		this.departmentId = departmentId;
	}
	
	public void setDepartmentName(String departmentName) {
		this.departmentName = departmentName;
	}
	
	public long getDepartmentId() {
		return this.departmentId;
	}
	
	public String getDepartmentName() {
		return this.departmentName;
	}
	
	@Override
	public String toString() {
		return "部门ID：" + this.departmentId + "部门名称：" + this.departmentName;
	}
}

上面的代码设定上我们只序列列部门名称DepartmentName。

代码示例2：序列化Deparment类的对象

import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class ExternalTest {

	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		File file = new File("E:" + File.separator + "test.txt");
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
		Department department = new Department(1,"研发部");
		// 保存对象
		department.writeExternal(out);
		// 关闭输出流
		out.close();
	}

}

代码执行结果

代码示例3：反序列化Department 类的对象

import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ExternalTest2 {

	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		File file = new File("E:" + File.separator + "test.txt");
		ObjectInputStream input = new ObjectInputStream(new FileInputStream(file));
		Department department = new Department();
		// 反序列读取对象
		department.readExternal(input);
		System.out.println(department.toString());
		
		//关闭输入流
		input.close();
	}

}

代码执行结果

部门ID：0部门名称：研发部

这里部门ID为0是因为只反序列化读取了部门名称，调用toString()方法的时候，就使用了long变量的默认值0。

关键字 transient

上面实现Externalizable接口的方式比较麻烦。我们可以用关键字 transient来声明不希望被序列化的属性。例如不希望AdminUser类的age属性被序列化，可以这样写：

private transient int age; // 此属性将不被序列化

其它的和实现Serializable接口相同。