简单的使用IO流是很简单的~
扩展：
使用追加方式去复制（存储）文件 的格式：
FileWriter fw = new FileWrite("d:/java/test/ioDemo.txt",true); &FileOutputStream
在文件里换行：
============使用字节流/字符流完成文件复制============
import java.io.*;
//IO里的对象来自于java.io.*;
//IO流的输入输出是相对于内存RAM的
//分类：单位【字节流、字符流】or方向【输入流、输出流】or功能【节点流、处理流】
//所有的IO流由四个抽象类扩展而来：
//InputStream 的子类 FileInputStream BufferedInputStream
//OutputStream 的子类FileInputStream BufferedOutputStream
//Reader 的子类FileReader BufferedReader
//Writer 的子类FileWriter BufferedWriter
public class IOTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 以下代码用字节流和字符流2种方法完成文件复制功能
// 1 准备
String path1 = "D:\Java\Test\红楼梦-曹雪芹.txt";
String path2 = "D:\Java\Test\程序创建：红楼梦-曹雪芹.txt";
String path3 = "D:\Java\Test\红楼梦-曹雪芹 - 副本.txt";
String path4 = "D:\Java\Test\程序创建：红楼梦-曹雪芹 - 副本.txt";
byte[] b = new byte[1024 * 256];
char[] c = new char[1024 * 256];
// 2 声明
FileInputStream fis = null;
BufferedInputStream bis = null;
FileOutputStream fos = null;
BufferedOutputStream bos = null;
FileReader fr = null;
BufferedReader br = null;
FileWriter fw = null;
BufferedWriter bw = null;
// 3 创建
try {
fis = new FileInputStream(path1);
bis = new BufferedInputStream(fis);
fos = new FileOutputStream(path2);
bos = new BufferedOutputStream(fos);
fr = new FileReader(path3);
br = new BufferedReader(fr);
fw = new FileWriter(path4);
bw = new BufferedWriter(fw);
// 4读取
int ib = bis.read(b);
// 5判断-方法1
long t1 = System.currentTimeMillis();
while (ib > 0) {
// 6复制
bos.write(b, 0, ib);
// 7循环
ib = bis.read(b);
}
// 8刷新
bw.flush();
long t2 = System.currentTimeMillis();
System.out.println("使用字节流复制文件完成，用时：" + (t2 - t1) + "毫秒");
long t3 = System.currentTimeMillis();
int ic = br.read(c);
// 判断-方法2
while (ic > 0) {
// 复制
bw.write(c, 0, ic);
// 循环
ic = br.read(c);
}
// 刷新
bw.flush();
long t4 = System.currentTimeMillis();
System.out.println("使用字符流复制文件完成，用时：" + (t4 - t3) + "毫秒");
// =============以下全是异常处理代码段，可以不看=============
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
// 9 关闭
if (bis != null) {
try {
bis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (bos != null) {
try {
bos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (br != null) {
try {
br.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (fr != null) {
try {
fr.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (bw != null) {
try {
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (fw != null) {
try {
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
============数据流============
DataInputStream
DataOutputStream
数据流的特点是保持基本数据类型的数据不变，实现它们的传递
常用方法：
writeInt(int); &readInt();
writeDouble(double); &readDouble();
...
writeUTF(string); &readUTF();
数据流属于处理流，所以使用时必须套接在节点流上
做一个小Demo，代码如下：
import java.io.*;
//DataIO的使用方法
public class DataIO {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 准备
String path1 = "D:/java/test/datao.txt";
//String path2 = "D:/java/test/datai.txt";
int i = 127;
double d = 12345678.234567;
String str = "成都市有个金龙长城";
String str2 = "成都市有2个金龙长城";
String str3 = "成都市有3个金龙长城";
// 声明
DataOutputStream dos = null;
DataInputStream dis = null;
// 创建
try {
dos = new DataOutputStream(new FileOutputStream(path1));
dis = new DataInputStream(new FileInputStream(path1));
// 复制,按队列顺序存储
dos.writeInt(i);
dos.writeDouble(d);
dos.writeUTF(str);
dos.writeUTF(str3);
dos.writeUTF(str2);
// 刷新
dos.flush();
System.out.println("存储成功！");
// 读取
System.out.println(dis.readInt());
System.out.println(dis.readDouble());
System.out.println(dis.readUTF());
System.out.println(dis.readUTF());
System.out.println(dis.readUTF());
dos.close();
dis.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}//未合理处理异常
}
}
============对象流============
ObjectInputStream
ObjectOutputStream
为了便于将对象输入输出且保持对象性质，砖家提供了对象流
常用方法：
Object readObject();//记得向下转型哦
void writeObject();
对象流也是处理流~
要放进对象流里的自定义的对象的类，必须实现java.io.Serializable接口
代码示例如下：
import java.io.*;
//Father是Student的子类，Student要实现Serializable，
//逻辑上Father必须先实现Serializable，Student才能实现Serializable
class Father implements Serializable {
private String name;
public Father() {
// TODO Auto-generated constructor stub
}
public Father(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// 要对Student类进行对象流处理，则Student要实现Serializable接口
class Student implements Serializable {
// String类也实现了Serializable接口
private String name;
private Father father;
public Student() {
// TODO Auto-generated constructor stub
}
public Student(String name, Father father) {
super();
this.name = name;
this.father = father;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Father getFather() {
return father;
}
public void setFather(Father father) {
this.father = father;
}
}
public class ObjectIO {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 准备
Student student01 = new Student("张三", new Father("张三的爸爸"));
Student student02 = new Student("张三2", new Father("张三2的爸爸"));
Student student03 = new Student("张三3", new Father("张三3的爸爸"));
Father father = new Father("1号爸爸");
Father father2 = new Father("2号爸爸");
Father father3 = new Father("3号爸爸");
String path = "d:/java/test/ObjectIO.txt";
// 声明
ObjectInputStream ois = null;
ObjectOutputStream oos = null;
// 创建
try {
oos = new ObjectOutputStream(new FileOutputStream(path));
// 存储
oos.writeObject(student01);
oos.writeObject(student02);
oos.writeObject(student03);
oos.writeObject(father);
oos.writeObject(father2);
oos.writeObject(father3);
System.out.println("对象存储完成！");
// 读取对象值
ois = new ObjectInputStream(new FileInputStream(path));
student01 = (Student) ois.readObject();
student02 = (Student) ois.readObject();
student03 = (Student) ois.readObject();
father = (Father) ois.readObject();
father2 = (Father) ois.readObject();
father3 = (Father) ois.readObject();
System.out.println("第一个存放的人的名字:" + student01.getName() + "他/她爸爸的名字是：" + student01.getFather().getName());
System.out.println("第二个存放的人的名字:" + student02.getName() + "他/她爸爸的名字是：" + student02.getFather().getName());
System.out.println("第三个存放的人的名字:" + student03.getName() + "他/她爸爸的名字是：" + student03.getFather().getName());
System.out.println(father.getName());
System.out.println(father3.getName());// 顺序和下面相反
System.out.println(father2.getName());
System.out.println("对象输出完成！");
} catch (IOException | ClassNotFoundException e) {
// TODO Auto-generated catch block
System.out.println("发生了异常！");
} finally {
// 简单处理异常、资源关闭
try {
ois.close();
oos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
============转换流============
InputStreamReader; byte→char
OutpurStreamWriter; char→byte
为了处理给定的数据流和需要的数据流在单位上发生矛盾的时候，进行转换
另，转换时可以指定编码方案
import java.io.*;
public class InputStreamReaderTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 准备
String path = "d:/java/test/isrt1.txt";
// 声明
InputStreamReader isr = null;
OutputStreamWriter osw = null;
try {
// 创建
osw = new OutputStreamWriter(new FileOutputStream(path), "utf-8");
// 存储
osw.write("欢迎来到北京市");
osw.close();
System.out.println("存储完成");
// 读取
isr = new InputStreamReader(new FileInputStream(path), "utf-8");
System.out.println(isr.getEncoding());
int x = isr.read();
while (x > 0) {
System.out.print((char) x);
x = isr.read();
}
System.out.println("读取完成");
isr.close();
} catch (UnsupportedEncodingException | FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
============打印流============
PrintStream
PrintWriter
打印流属于输出流，打印流属于节点流
常用方法：
print()
println()
import java.io.FileNotFoundException;
import java.io.PrintStream;
public class PrintIO {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 准备
String path = "d:/java/test/printio.txt";
// 声明
PrintStream ps = null;
// 创建
try {
// =============第一种方法
ps = new PrintStream(path);
// 存储
ps.print("欢迎来上海");
System.out.println("信息存储完成1");
// =============第二种方法
PrintStream old = System.out;
System.setOut(ps);
// 这里的输出将保持到文件里
for (int i = 0; i < 10; i++) {
System.out.print(i);
}
System.setOut(old);
System.out.println("信息存储完成2");
// 这里的输出将打印在控制台
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
*
* IO总复习: 1. 四个抽象类[两对] 1) InputStream和OutputStream 抽象的字节输入输出流类。 2) Reader和Writer
* 抽象的字符输入输出流类
*
* 2. 文件的字节/字符输入输出流类; 1) FileInputStream 和 FileOutputStream 2) FileReader 和
* FileWriter
* read() read(byte[] bs)
* write(int) write(byte[], loc, len);
*
* 3. 缓冲流类: 1) BufferedInputStream 和 BufferedOutputStream 缓冲的字节输入输出流类
* 2)BufferedReader 和 BufferedWriter 缓冲的字符输入输出流类
* br.readLine(); bw.write(String);bw.newLine();
*
* 4. 数据流类: DataInputStream 数据的字节输入流类 DataOutputStream 数据的字节输出流类 注意:
* 它们用来实现基本类型的数据及字符串的输入输出． 特色: 保持数据类型不变．
* 注意: 输入数据的顺序与输出数据顺序要一致． 注意: 它们的方法往往成对出现．
* 例如: writeByte(byte) byte readByte();
*
* 5. 对象流类: ObjectInputStream 对象的字节输入流类． ObjectOutputStream 对象的字节输出流类．
*
* 注意: 对象对应的类必须实现 java.io.Serializable接口．
*
* 思考: 读取多个对象时会发现什么现象． 注意: writeObject( obj ) Object readObject();
*
* 9． 转换流: InputStreamReader 字节转换成字符的一个转换流．最后，以字符方式来读取数据．
*
* OutputStreamWriter 字符转换字节的一个转换流．最后，以字节方式输出数据．
*
* 注意: 在创建转换流时，可以指定字符的编码方案(字符集)．
*
* 10. 打印流: PrintStream 字节打印流． PrintWriter 字符打印流．
*
* 注意: 追加存盘． 注意: 字符流通常用来处理文本文件． 注意: 字节流通常可以处理任意类型的文件．
*
* 11. File 类: 计算机资源的管理类．
*
*/