File不能访问文件的内容,即不能从文件中读取数据或者向文件中写入数据,这时就要用到流。
读文件,是指把文件中的数据读到内存中,写文件,是指把内存中的数据写到文件中。
流:是指一串流动的字符,以先进先出的方式发送和接收数据的通道。流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。
IO流的分类
根据处理数据类型的不同分为:字符流和字节流
根据数据流向不同分为:输入流和输出流
字符流和字节流
字符流的由来: 因为数据编码的不同,而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时,去查了指定的码表。
字节流和字符流的区别:
读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。
处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能处理字符类型的数据。
结论:只要是处理纯文本数据,就优先考虑使用字符流。 除此之外都使用字节流。
Java流操作有关的类或接口:
Java流类图结构:
字节输入流InputStream:
实际应用中使用FileInputStream
public class Main {
public static void main(String[] args) {
FileInputStream fis=null;
try {
fis=new FileInputStream("D:\\java.txt");
int data;
try {
System.out.println("可读取的字节数:"+fis.available());
System.out.println("文件内容为:");
while((data=fis.read())!=-1){//如果fis.read没有读到数据返回-1
System.out.print((char)data);//强转为char类型,否则输出的是整数
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(fis!=null){
try {
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
字节输出流OutputStream:
同样,实际应用中使用FileOutputStream
注意:为防止覆盖文件原有的内容,构造方法最好为此种形式:
FileOutputStream fos=new FileOutputStream("D:\\a.txt",true)
true表示在文件末尾增加数据。
public class Main {
public static void main(String[] args){
FileOutputStream fos=null;
String str="好好学习";
byte[] b=str.getBytes();//字节数组
//创建输出字节流对象
try {
fos=new FileOutputStream("D:\\java.txt",true);
fos.write(b, 0, b.length);
System.out.println("写入");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
if(fos!=null){
fos.close();}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
综合运用
public class Main {
public static void main(String[] args){
FileInputStream fis=null;//先在try catch外声明,方便finally里关闭流
FileOutputStream fos=null;
try {
fis=new FileInputStream("D:\\我.txt");
fos=new FileOutputStream("E:\\我.txt",true);
byte[]b=new byte[1024];
int len;//存储读入数组的长度
while((len=fis.read(b))!=-1){
fis.read(b);//读取到字符数组中
fos.write(b, 0, len);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
//关闭流
//一般情况下是:先打开的后关闭,后打开的先关闭
//但是有一种情况:要看依赖关系,如果流a依赖流b,应该先关闭流a,再关闭流b
try {
if(fos!=null){
fos.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(fis!=null){
fis.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
字符输入流Reader
使用其子类FileReader
public class Main {
public static void main(String[] args){
Reader fr=null;
StringBuffer sb=null;
try {
fr=new FileReader("D:\\我.txt");
char ch[]=new char[1024];
sb=new StringBuffer();
int length=fr.read(ch);//读取数据存放到ch字符数组,并返回length长度
while(length!=-1){
sb.append(ch);
length=fr.read();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(fr!=null){
try {
fr.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
缓冲字符输入流BufferedReader:
自带缓冲区,可以先把一批数据读到缓冲区,然后从缓冲区读取数据,避免每次都是从数据源读取数据进行字符编码转换,从而提高效率。
Reader fr=new FileReader("D:\\a.txt");
BufferedReader br=new BufferedReader(fr);//创建对象
br.readLine()//特有方法,读取一行数据,返回字符串
br.close();//关闭流对象
fr.close();
public class Main {
public static void main(String[] args){
FileReader fr=null;
BufferedReader br=null;
try {
fr=new FileReader("D:\\java.txt");
br=new BufferedReader(fr);//创建br对象
String line=br.readLine();//读取一行
while(line!=null){
System.out.println(line);
line=br.readLine();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}//创建fr对象
catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(br!=null){
try {
br.close();//先关br
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(fr!=null){
try {
fr.close();//再关fr
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
字符输出流Writer
使用其子类FileWriter
public class Main {
public static void main(String[] args){
Writer fw=null;
try {
fw=new FileWriter("D:\\java1.txt");
fw.write("哈哈哈aaa");
fw.flush();//刷新缓冲区
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(fw!=null){
fw.close();}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
缓冲字符输出流BufferedWriter :
自带缓冲区,可以先把一批数据写到缓冲区,缓冲区写满的时候,再把缓冲区的数据写到字符输出流中,避免每次都执行物理操作,从而提高效率。
public class Main {
public static void main(String[] args){
FileWriter fw=null;
BufferedWriter bw=null;
try {
fw=new FileWriter("D:\\java2.txt");
bw=new BufferedWriter(fw);
bw.write("hhh");
bw.newLine();//插入换行符
bw.write("啊");
bw.flush();//刷新缓冲区
fw.close();//关闭流
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
序列化和反序列化
序列化:
将对象的状态存储到特定存储介质的过程。序列化过程会将对象的公有成员,私有成员(包括类名)转换为字节流,再将字节流写入数据流存储到存储介质中。
意义:序列化后可以转换为字节序列,这些字节序列可以保存在磁盘也可以通过网络传输,同时由于序列化的对象保存的是二进制状态,实现了平台无关性,无须担心数据因为平台问题显示异常。
序列化步骤:
1.创建一个对象输出流(ObjectOutputStream)
2.通过对象输出流的writeObject()方法写对象,输出可序列化对象。
import java.io.Serializable;
public class Student implements Serializable{
private String name;
private String sex;
private int age;
public Student(String name, String sex, int age) {
super();
this.name = name;
this.sex = sex;
this.age = age;
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", sex=" + sex + ", age=" + age + "]";
}
}
package test;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
public class SerializableObj {
public static void main(String[] args) {
// TODO Auto-generated method stub
ObjectOutputStream oos=null;
try {
//创建输出流
oos=new ObjectOutputStream(new FileOutputStream("D:\\student.txt"));
Student stu=new Student("安娜","女",18);
Student stu1=new Student("玛丽","女",20);
List list=new ArrayList();
list.add(stu);
list.add(stu1);
//写入输出流
oos.writeObject(list);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
if(oos!=null){
oos.close();}//关闭输出流
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
反序列化:
从特定存储介质中将数据重新构建对象的过程。
步骤:
1.创建一个对象输入流(ObjectInputStream)
2.通过他的readObject()方法读取对象,返回的是object类型,需要强转。
package test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
public class SerializableReadObj {
public static void main(String[] args) {
ObjectInputStream ois=null;
try {
//输入流
ois=new ObjectInputStream(new FileInputStream("D:\\student.txt"));
//反序列化,并强转
ArrayList<Student> list=(ArrayList<Student>) ois.readObject();
//增强for循环遍历
for(Student stu:list){
System.out.println("姓名:"+stu.getName()+"年龄:"+stu.getAge()+"性别:"+stu.getSex());
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
if(ois!=null){
ois.close();}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}