Java输入输出，允许成都读取外部数据、用户输入的数据，允许程序记录运行状态，将程序数据输出到磁盘、光盘等存储设备中。
1. File类
File类是java.io包下代表与平台无关的文件和目录。在程序中对文件和目录进行操作都是通过File类完成。File类可以新建、删除、重命名文件和目录，但File类不能修改文件本身。1）访问文件和目录
File类可是使用文件路径字符串来穿件File类实例，路径可以是绝对路径也可以是相对路径。一旦创建了File对象后就可以调用File对象的方法来访问文件和目录。以下是File类使用的示例：
public class FileTest {
public static void main(String[] args)
throws IOException {
// 以当前路径来创建一个File对象
File file = new File(".");
// 直接获取文件名，输出一点
System.out.println(file.getName());
// 获取相对路径的父路径可能出错，下面代码输出null
System.out.println(file.getParent());
// 获取绝对路径
System.out.println(file.getAbsoluteFile());
// 获取上一级路径
System.out.println(file.getAbsoluteFile().getParent());
// 在当前路径下创建一个临时文件
File tmpFile = File.createTempFile("aaa", ".txt", file);
// 指定当JVM退出时删除该文件
tmpFile.deleteOnExit();
// 以系统当前时间作为新文件名来创建新文件
File newFile = new File(System.currentTimeMillis() + "");
System.out.println("newFile对象是否存在：" + newFile.exists());
// 以指定newFile对象来创建一个文件
newFile.createNewFile();
// 以newFile对象来创建一个目录，因为newFile已经存在，
// 所以下面方法返回false，即无法创建该目录
newFile.mkdir();
// 使用list()方法来列出当前路径下的所有文件和路径
String[] fileList = file.list();
System.out.println("====当前路径下所有文件和路径如下====");
for (String fileName : fileList)
{
System.out.println(fileName);
}
// listRoots()静态方法列出所有的磁盘根路径。
File[] roots = File.listRoots();
System.out.println("====系统所有根路径如下====");
for (File root : roots)
{
System.out.println(root);
}
}
}运行上面的程序，可以看见程序列出了当前路径的所有文件和路径是、列出了程序创建的临时文件，但程序结束时，aaa.txt文件并不存在，因此程序指定虚拟机退出时自动删除该文件。
注意：windows的路径使用反斜线。而Java程序中的反斜线表示的是转移序列。所以在使用反斜线时，需要在加上一条反斜线才能正确的表示路径。
2. 文件过滤器
在File类的list()方法中可以接受一个FilenameFilter参数，通过该参数可以只列出符合条件的文件。这里的FilenameFilter接口和java.swing.filehoose包下的FileFilter抽象类功能类似。使用方法如下：public class FilenameFilterTest {
public static void main(String[] args) {
File file = new File(".");
String[] nameList = file.list(new MyFilenameFilter());
for(String name : nameList) {
System.out.println(name);
}
}
}
// 实现自己的FilenameFilter实现类
class MyFilenameFilter implements FilenameFilter {
public boolean accept(File dir, String name) {
// 如果文件名以.java结尾，或者文件对应一个路径，返回true
return name.endsWith(".java")
|| new File(name).isDirectory();
}
}3. Java的IO流
Java的IO流体系中一共有40多了接口和类，我们按照其功能划分如下：
| 分类 | 字节输入流 | 字节输出流 | 字符输入流 | 字符输出流 |
|---|---|---|---|---|
| 抽象基类 | 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 |
注：表中粗体代表节点流，必须直接与指定的物理节点关联。斜体是抽象基类，无法直接操作流。
Java的IO流是实现输入输出的基础，他可以方便地实现数据的输入输出操作，在Java中把不同的输入输出源抽线表述为”流“，通过流的方式允许Java程序使用相同的方式访问不同的输入输出流。
1）流的分类输入流和输出流
- 输入流：只能读取数据而不能写入
- 输出流：只能写不能读
字节流和字符流的用法几乎完全一样，区别在于字节流和字符流操作的数据单元不同——字节流操作的数据单元是8位的字节，字符流操作的是16位的字符。
字节流主要由InputStream和OutputStream作为基类；而字符流主要由Write和Reader作为基类。
②节点流和处理流
可以从/向一个特定的IO设备读/写数据的流，称为节点流。节点流也被称为低级流。
处理流则用于对一个已存在的流进行连接或封装，通过封装后的流来实现数据的读和写功能。处理流也被称为高级流。
当使用处理流的一个好处是，只要使用相同的处理流，程序就可以采用完全相同的输入输出代码来访问不同的数据源，屏蔽了底层数据源处理的特异性。
Java把所有的有序数据抽象成流模型，简化了输入输出处理。Java的IO流共涉及40多类。
4. 字节流和字符流
1）InputStream和ReaderInputerStream和Reader是所有输入流的抽象基类，本身并不能创建实例来来执行输入，但它们成为了所有输入流的模板：
在InputStream中包含如下3个方法
- int read()：从输入流中读取单个字节，返回所读取的字节数据（字节数据可转换为int类型）
- int read(byte[] b): 从输入流中读取最多b.length个字节的数据，并存放在字节数组b中，返回实际读取的字节数。
- int read(bytep[] b, int off, int len):从输入流中最多读取len个字节的数据，并将其存储在数组b中，放入数组时，从off位置开始存放，返回实际读取的字节数。
public class FileInputStreamTest {
public static void main(String[] args) throws IOException {
// 创建字节输入流
FileInputStream fis = new FileInputStream(
"FileInputStreamTest.java");
// 创建一个长度为1024的“竹筒”
byte[] bbuf = new byte[1024];
// 用于保存实际读取的字节数
int hasRead = 0;
// 使用循环来重复“取水”过程
while ((hasRead = fis.read(bbuf)) > 0 ) {
// 取出“竹筒”中水滴（字节），将字节数组转换成字符串输入！
System.out.print(new String(bbuf , 0 , hasRead ));
}
// 关闭文件输入流，放在finally块里更安全
fis.close();
}
} 上面的程序运行会输出上面程序的源代码。
下面使用FileReader读取文件：
public class FileReaderTest {
public static void main(String[] args) {
try(
// 创建字符输入流
FileReader fr = new FileReader("FileReaderTest.java")) {
// 创建一个长度为32的“竹筒”
char[] cbuf = new char[32];
// 用于保存实际读取的字符数
int hasRead = 0;
// 使用循环来重复“取水”过程
while ((hasRead = fr.read(cbuf)) > 0 ) {
// 取出“竹筒”中水滴（字符），将字符数组转换成字符串输入！
System.out.print(new String(cbuf , 0 , hasRead));
}
}
catch (IOException ex) {
ex.printStackTrace();
}
}
}上面的程序与FileInputStream没有太大的不同，只是将缓存数组设置为了32，这就需要多次读取文件。同时程序还在try中声明了输入流对象，这样在程序执行完毕后，输入流会自动关闭。
2）OutputStream和Writer
它们同样非常相似。两个流都提供了如下方法：
- void write(int c): 将指定的字节/字符输出到输出流中。
- void write(byte[]/char[] buf)：将字节数组/字符数组的内容输出到输出流中。
- void write(byte[] buf, int off, int len): 将字节数组/字符数组从off位置开始，长度为Len的数据输出到输出流中。
public class FileOutputStreamTest {
public static void main(String[] args) {
try(
// 创建字节输入流
FileInputStream fis = new FileInputStream(
"FileOutputStreamTest.java");
// 创建字节输出流
FileOutputStream fos = new FileOutputStream("newFile.txt")) {
byte[] bbuf = new byte[32];
int hasRead = 0;
// 循环从输入流中取出数据
while ((hasRead = fis.read(bbuf)) > 0 ) {
// 每读取一次，即写入文件输出流，读了多少，就写多少。
fos.write(bbuf , 0 , hasRead);
}
}
catch (IOException ioe) {
ioe.printStackTrace();
}
}
}5. 输入输出流体系
1）处理流的用法处理流可以隐藏底层设备上节点流的差异。让程序员只需关心高级流的操作。
我们使用处理流的典型思路是，使用处理流包装节点流，程序通过处理流来执行输入输出功能。让节点流与底层的IO设备、文件交互。
下面使用PrintStream处理流来包装OutputStream，使用处理流后的输出流在输出时更加方便。
public class PrintStreamTest {
public static void main(String[] args) {
try(
FileOutputStream fos = new FileOutputStream("test.txt");
PrintStream ps = new PrintStream(fos)) {
// 使用PrintStream执行输出
ps.println("普通字符串");
// 直接使用PrintStream输出对象
ps.println(new PrintStreamTest());
}
catch (IOException ioe) {
ioe.printStackTrace();
}
}
} 上面的程序使用PrintStream输出字符串，十分的简单易用，实际上，System.out同样是PrintStream输出流。
输出输入体系中还提供了两个转换流，用于将字节流转换为字符流，其中InputStreamReader将字节输入流转换为字符输入流，OutputStreamWriter将字节输出流转换为字符输出流。
下面以获取键盘输入为例介绍转换流的用法。Java使用System.in代表标准输入，寄键盘输入，但这个便准输入是InputStream的示例，使用不太方便。我们可以将其转换为Reader字符输入流。但Reader读取数据太麻烦，所以使用BufferedReader包装Reader输入流，利用BufferedReader的ReadLine()方法可以一次读取一行的内容：
public class KeyinTest {
public static void main(String[] args) {
try(
// 将Sytem.in对象转换成Reader对象
InputStreamReader reader = new InputStreamReader(System.in);
//将普通Reader包装成BufferedReader
BufferedReader br = new BufferedReader(reader)) {
String buffer = null;
//采用循环方式来一行一行的读取
while ((buffer = br.readLine()) != null) {
//如果读取的字符串为"exit"，程序退出
if (buffer.equals("exit")) {
System.exit(1);
}
//打印读取的内容
System.out.println("输入内容为:" + buffer);
}
}
catch (IOException ioe) {
ioe.printStackTrace();
}
}
}3）推回输入流
在输入输出流体系中，有两个特殊的流与众不同，就是PushbachInputStream和PushbackReader，它们都有一下三个方法：
- void unread(byte[] buf)：将一个字节数组推回到推回缓冲区里，从而允许重复读取刚刚读取的内容。
- void unread(byte[] b, int off, int len)：将一个字节数组从off开始，长度为len的字节推回到推回缓冲区中。
- void unread(int b)：将一个字节推回到缓冲区中。
public class PushbackTest {
public static void main(String[] args) {
try(
// 创建一个PushbackReader对象，指定推回缓冲区的长度为64
PushbackReader pr = new PushbackReader(new FileReader(
"PushbackTest.java") , 64)) {
char[] buf = new char[32];
// 用以保存上次读取的字符串内容
String lastContent = "";
int hasRead = 0;
// 循环读取文件内容
while ((hasRead = pr.read(buf)) > 0) {
// 将读取的内容转换成字符串
String content = new String(buf , 0 , hasRead);
int targetIndex = 0;
// 将上次读取的字符串和本次读取的字符串拼起来，
// 查看是否包含目标字符串, 如果包含目标字符串
if ((targetIndex = (lastContent + content)
.indexOf("new PushbackReader")) > 0){
// 将本次内容和上次内容一起推回缓冲区
pr.unread((lastContent + content).toCharArray());
// 指定读取前面len个字符
int len = targetIndex > 32 ? 32 : targetIndex;
// 再次读取指定长度的内容（就是目标字符串之前的内容）
pr.read(buf , 0 , len);
// 打印读取的内容
System.out.print(new String(buf , 0 ,len));
System.exit(0);
}
else {
// 打印上次读取的内容
System.out.print(lastContent);
// 将本次内容设为上次读取的内容
lastContent = content;
}
}
}
catch (IOException ioe) {
ioe.printStackTrace();
}
}
}上面的程序中实现了指定的内容推回到缓冲区，于是当程序再次调用read()方法的时候，实际只读取了推回缓冲区的部分，从而实现了只打印目标字符串前面内容的功能。
6. 对象序列化
对象序列化是指将对象保存硬盘中，或允许在网络中直接传输对象。对象序列化将文件装换为二进制保存在磁盘上，通过网络将何种二进制传输到另一个网络节点。
为了让某个对象时刻序列化的，副对象的类必须实现如下两个接口之一：
Serializable
Externalizable
1）使用Serializable接口序列化
Serializable是一个标记接口，实现该接口无需实现任何方法，它只是表明该类的示例是可序列化的。
一旦一个类实现了Serializable接口，该类的对象就是可序列化的，程序可以通过如下的两个步骤来序列化对象：
①创建一个ObjectOutputStream，这是一个处理流，所以必须建立在其他节点流之上：
292
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
