前述
程序在运行结束后，数据内容就会被内存回收掉，从而消失，为了使一些有用的数据可以被下一次调用该程序时候直接使用，所以需要引入IO的操作将数据从内存中传输到磁盘中，从而实现数据的持久化（或者使用数据库也可以实现数据的持久化）。
数据的传输都是通过两种类型的流：输入流和输出流，这就是IO。
流的继承关系图
需要读入数据使用输入流，需要写入数据使用输出流；
按照操作的数据类型分类：字节流和字符流
字节流可以读取和写入任何数据，因为任何数据最终都能以字节存储；
字符流只能操作文本类型的文件，按照字符进行读取和写入，方便对字符的操作
常用的一些字节流子类：
文件输入输出流：FileInputStream、FileOutputStream
对象输入输出流：ObjectInputStream、ObjectOutputStream
常用的一些字符流子类：
文件输入输出流：FileReader FileWriter
缓存的文件输入输出流：BufferedReader BufferedWriter
就个人整理以上所述的8中IO类
1、FileInputStream（文件字节输入流）
package io;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class ByteInput {
public static void main(String[] args) throws IOException {
//1、定义要使用的文件
File file = new File("F:" + File.separator + "byteInput.txt");
file.createNewFile(); //文件存在的时候不会执行，不存在的时候会执行
//2、定义字节输入流指定为文件输入流
InputStream input = new FileInputStream(file);
byte[] b = new byte[(int) file.length()]; // file.length()获取文件的长度返回long类型
int len = input.read(b);
input.close();
//3、验证输入结果
System.out.println("文件的内容长度为 : " + len);
System.out.println("文件的内容为: " + new String(b));
}
}
本例需要有原始的文件，会将该文件中的内容输入到eclipse的控制台中
txt文件内容：
控制台输出：
2、FileOutputStream（文件字节输出流）实现对文件内容的逐字节处理
package io;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class ByteOutput {
public static void main(String[] args) throws IOException{
//1、获取要操作的文件
File file=new File("F:"+File.separator+"byteOutput.txt");
file.createNewFile();
//2、写入指定的内容
String str="I Like Java!";
OutputStream output=new FileOutputStream(file);
output.write(str.getBytes(), 0, str.length()); //写入字符串
output.close();
}
}
本例结果:
3、FileReader（文件字符输入流）实现对文件内容的逐字符处理
package io;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class CharInput {
public static void main(String[] args) throws IOException {
//1、指定要操作的文件
File file=new File("F:"+File.separator+"charInput.txt");
file.createNewFile();
//2、指定字节输入流
Reader reader=new FileReader(file);
char[] c=new char[(int)file.length()];
int len=reader.read(c);
reader.close();
//3、验证
System.out.println("字符流读取文件的长度为: "+len);
System.out.println("字符流读取文件的内容: "+new String(c));
}
}
本例结果
源文件中的内容:
控制台结果:
4、FileWriter（文件字符输出流）实现对文件内容的逐字符处理
package io;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class CharOutput {
public static void main(String[] args) throws IOException {
File file = new File("F:" + File.separator + "charOutput.txt");
file.createNewFile();
Writer writer = new FileWriter(file);
writer.write("I Love Basketball！", 0, 18);
writer.close();
}
}
本例结果
5、ObjectInputStream（对象输入流）本例需要对象实现序列化接口，实现对文件内容的逐个对象处理
先定义一个实现Serializable接口的pojo实体类
package io;
import java.io.Serializable;
public class StudentInfo implements Serializable{
private String stuno;
private String name;
private Integer age;
public StudentInfo() {
}
public StudentInfo(String stuno, String name, Integer age) {
super();
this.stuno = stuno;
this.name = name;
this.age = age;
}
public String getStuno() {
return stuno;
}
public void setStuno(String stuno) {
this.stuno = stuno;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "StudentInfo [stuno=" + stuno + ", name=" + name + ", age=" + age + "]";
}
}
定义测试类
package io;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class ObjectInput {
public static void main(String[] args) throws IOException, ClassNotFoundException {
File file=new File("F:"+File.separator+"object.txt");
file.createNewFile();
ObjectInputStream in=new ObjectInputStream(new FileInputStream(file));
StudentInfo stu=(StudentInfo)in.readObject();
in.close();
System.out.println(stu);
}
}
本例的结果
6、ObjectOutputStream（对象输出流）本例需要对象实现序列化接口，实现对文件内容的逐个对象处理
pojo对象同5例中的StudentInfo对象，测试类如下
package io;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class ObjectOutput {
public static void main(String[] args) throws IOException {
File file=new File("F:"+File.separator+"object.txt");
file.createNewFile();
StudentInfo student=new StudentInfo("10001","zhangsan",20);
ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream(file));
output.writeObject(student);
output.close();
}
}
本例结果
本例会在txt文件中出现乱码，是由于记事本和eclipse的编码不同导致，但是当再次存取在eclipse中不会乱码，所以不必在意乱码结果。
7、BufferedReader（缓存文件输入流）实现对文件内容的逐行处理
package io;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class BufferReaderDemo {
public static void main(String[] args) throws IOException {
//指定文件
File file = new File("F:" + File.separator + "buffered.txt");
file.createNewFile();
//定义需要验证的变量
int i = 1;
String str;
StringBuffer buffer = new StringBuffer();
//定义逐行读入的流
BufferedReader br = new BufferedReader(new FileReader(file));
while ((str = br.readLine()) != null) { //逐行读取并验证
System.out.println("读取的行数: " + (i));
buffer.append(str);
System.out.println("第" + (i++) + "行的内容为: " + str);
}
br.close();
//打印最终结果
System.out.println("\n文件中的全部内容为: "+buffer.toString());
}
}
本例结果
8、BufferedWriter（缓存文件输出流）实现对文件内容的逐行处理
package io;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class BufferedWriterDemo {
public static void main(String[] args) throws IOException{
//指定文件
File file=new File("F:"+File.separator+"buffered.txt");
file.createNewFile();
//指定
Writer bw=new BufferedWriter(new FileWriter(file,true));
bw.write("\r\n");
bw.write("XiaoHuangRen like banana!");
bw.write("\r\n");
bw.write("XiaoHuangRen like bana!");
bw.close();
}
}
本例结果
以上的8个例子中，由于5,6两个例子和7,8两个例子共用同一个文件，所以可以先测试输出流在测试输入流看结果。
以上的例子均为个人理解，初学者可以参考一下，大神勿喷。。。