Java程序中，对于数据的输入/输出操作都是以“流”的方式进行。即数据在两个输入/输出设备间的传输称为流，流的本质是数据传输。
流序列中的数据可以是没有进行加工的原始数据（二进制字节数据），也可以是经过编码的符合某种格式规定的数据。Java中提供了不同的流类对它们进行处理。
按照流传输方向不同分为
▶输入流（InputStream）
▶输出流（OutputStream）
按照流的处理数据的单位不同分为
▶字节流（8位）
▶字符流（16 位 Unicode Reader Writer）
按照流的基本功能不同
▶节点流
▶过滤流
Java IO中包含了许多InputStream、OutputStream、Reader、Writer的子类。各类用途汇总如下：
● 文件访问
● 网络访问
● 内存缓存访问
● 线程内部通信(管道)
● 缓冲
● 过滤
● 解析
● 读写文本 (Readers / Writers)
● 读写基本类型数据 (long, int etc.)
● 读写对象
我们通常对文本文件的操作使用读写使用字符流
对非文本文件的操作使用字节流
Reader：字符输入流父类 从文件、控制台等设备中读取文本
常用Reader的子类
◆ InputStreamReader ： 从字节流读入字符流
◆ FileReader ：从文本文件中读取文本
◆ BufferedReader:缓冲读取，一次读一个字符太慢，将字符缓冲成一行，常由InputStreamReader
构造。
Writer：字符输出流父类，向文件、控制台等设备写入文本
常用的Writer的子类
◆ OutputStreamWriter：从字符流中写成字节流
◆ FileWriter:向文本文件中写入文本
◆ BufferedWriter： 缓冲写入，一次写一个字符太慢，将字符缓冲成一行，做字符串写入
◆ PrintWriter：常用于http响应写入 （web）
注：字符流本质也是字节流，1字符等于2字节，1字节等于8位
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
public class ConsoleInOut {
public static void main(String[] args) {
// TODO 自动生成的方法存根
try {
//以字节流构造一个字符流 返回ASCII码值 控制台输入
InputStreamReader isr = new InputStreamReader(System.in);
//以一个字符缓冲流
BufferedReader br = new BufferedReader(isr);
//构建打印输出流
PrintStream ps = System.out;
ps.println("请输入：");
//读取一行
String str =br.readLine();
//打印输出结果
ps.println(str);
//关闭流释放资源
br.close();
isr.close();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
读取文本文件内容打印到控制台
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
public class FileTxtReader {
public static void main(String[] args) {
try {
//从文件中构建文件字符输入流
FileReader fr = new FileReader("e:/JavaIO/风入松·听风听雨过清明.txt");
//构建缓冲流
BufferedReader br = new BufferedReader(fr);
//读第一行
String txt = br.readLine();
//第一行不为空,循环直到读的文本为空ֹ
while(txt!=null) {
System.out.println(txt);
txt = br.readLine();
}
//关闭流释放资源
br.close();
fr.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
读取控制台内容写入到文本文件
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.Scanner;
public class FileTxtWriter {
public static void main(String[] args) {
try {
//构建输出流 文件不存在会自动创建 true表示以追加内容的方式写入
FileWriter fw = new FileWriter("e:/JavaIO/hello.txt",true);
//构建对应缓冲流
BufferedWriter bw = new BufferedWriter(fw);
System.out.print("请输入：");
//获取系统输入
InputStreamReader is= new InputStreamReader(System.in);
//构建输入缓冲流
BufferedReader br = new BufferedReader(is);
//将获取的输入写入文本
bw.write(br.readLine());
//刷新操作系统缓存
bw.flush();
//关闭流释放资源
br.close();
is.close();
bw.close();
fw.close();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
完成文本文件的拷贝
将文本文件拷贝到另一个文件夹下
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
public class FileTxtCopy {
public static void main(String[] args) {
try {
//构建输入流
FileReader fr = new FileReader("e:/JavaIO/风入松·听风听雨过清明.txt");
//构建输入缓冲
BufferedReader br = new BufferedReader(fr);
//构建输出流 没有文件会自动创建
FileWriter fw = new FileWriter("e:/JavaIO/copy/风入松·听风听雨过清明.txt");
//构建输出缓冲
BufferedWriter bw = new BufferedWriter(fw);
String txt = br.readLine();
while(txt!=null) {
//写入一行
bw.write(txt);
//换行
bw.newline();
txt = br.readLine();
}
//刷新操作系统缓存
bw.flush();
//关闭流
bw.close();
fw.close();
br.close();
fr.close();
} catch (Exception e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
System.out.println("拷贝完成！");
}
}
字节流
InputStream 字节输入流 父类 从文件、控制台、网络等设备中读入本身
常用的InputStream的子类有：
◆ ByteArrayInputStream ： 以字节数组的形式读入
◆ FileInputStream ： 读文件，构建文件本身输入流
◆ FilterInputStream：过滤输入流，包括：
◆ BufferedInputStream：输入缓冲流
◆ DataInputStream：读基本数据类型和String类型流。（常用于网络传输）
◆ PipedInputStream：管道输入流（多线程管道通信）
OutputStream：字节输出流父类，向文件、控制台、网络等设备写入本身
◆ ByteArrayOutputStream：以字节数组的形式写出
◆ FileOutputStream:写文件，构建文件本身的输出流
◆ FilterOutputStream：过滤输出流，包括：
◆ BufferedOutputStream：输出缓冲流
◆ PrintStream:打印输出流 （System.out）
◆ DataOutputStream:写基本数据类型和String类型流。（常用于网络传输）
◆ PipedOutputStream:管道输出流（多线程管道通信）
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class ImgCopy {
public static void main(String[] args) {
try {
//构建字节输入流
FileInputStream fis = new FileInputStream("e:/JavaIO/back.png");
//构建字节输出流
FileOutputStream fos = new FileOutputStream("e:/JavaIO/copy/back.png");
//设置1k的缓冲
byte[] buf = new byte[1024];
//循环拷贝
int read = 0;
while((read = fis.read(buf)) != -1) {
fos.write(buf,0,read);
}
//刷新系统缓冲
fos.flush();
//关流
fos.close();
fis.close();
} catch (Exception e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
System.out.println("拷贝完成！");
}
}
Java文件操作
主要功能为文件的创建、查找、删除。
创建文件夹
//创建File对象 操作文件夹
File dir2 = new File("E:/JavaIO/File");
//如果该文件夹不存在则创建
if(!dir2.exists()) {
dir2.mkdirs();
System.out.println("创建完成");
}
查询
//创建File对象 操作文件夹
File dir = new File("E:/JavaIO");
//是文件夹
if(dir.isDirectory()) {
System.out.println("存在该文件夹");
//查询文件夹下的文件目录
String[] filename = dir.list();
}
删除
if(dir2.exists()) {
//删除文件夹
dir2.delete();
System.out.println("删除成功");
}
文件夹下创建文件
//文件夹下创建文件
File file = new File("E:/JavaIO","test.txt");
//如果文件不存在则创建该文件
if(!file.exists()) {
//创建该文件
try {
file.createNewFile();
System.out.println("创建成功");
//写点东西
//读取
PrintStream ps = System.out;
ps.println("请输入:");
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
//写入
FileWriter fw = new FileWriter("E:/JavaIO/test.txt");
BufferedWriter bw = new BufferedWriter(fw);
bw.write(br.readLine());
//刷缓存
bw.flush();;
//关流
bw.close();
fw.close();
br.close();
isr.close();
System.out.println("写入成功");
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}else{
file.delete();
System.out.println("删除文本文件成功");
}
JavaBean的冷藏与解冻
即Javabean的序列化和反序列化
序列化：把对象转换为字节序列的过程称为对象的序列化。
反序列化：把字节序列恢复为对象的过程称为对象的反序列化。
对象的序列化主要有两种用途：
1）把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
2）在网络上传送对象的字节序列。
串行化与序列化的关系：
串行化也叫做序列化,就是把存在于内存的对象数据转化成可以保存成硬盘文件的形式去存储;
并行化与反序列化的关系：
并行化也叫反序列化,就是把序列化后的硬盘文件加载到内存，重新变成对象数据。
也就是把内存中对象数据变成硬盘文件。
创建一个UserBean
import java.io.Serializable;
public class UserBean implements Serializable{
private static final long serialVersionUID = 74176337636670604L;
private int id;
private String name;
private String sex;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 "UserBean [id=" + id + ", name=" + name + ", sex=" + sex + ", age=" + age + "]";
}
}
序列化（冷藏）
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class SeriUserBean {
public static void main(String[] args) {
try {
//构建文件输出流
FileOutputStream fos = new FileOutputStream("e:/JavaIO/user.obj");
//对象输出流
ObjectOutputStream oos = new ObjectOutputStream(fos);
//创建对象
UserBean user = new UserBean();
user.setId(1);
user.setAge(18);
user.setName("张三");
user.setSex("男");
//将对象写入对象输出流
oos.writeObject(user);
oos.flush();
oos.close();
fos.close();
System.out.println("冷藏完成！");
} catch (Exception e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
解冻（反序列化）
package com.qingsu.seri;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.ObjectInputStream;
public class DeSeriUserBean {
public static void main(String[] args) {
try {
//构建文件输入流
FileInputStream fis = new FileInputStream("e:/JavaIO/user.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
//读取对象
UserBean user = (UserBean)ois.readObject();
System.out.println(user);
} catch (Exception e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
System.out.println("解冻完成");
}
}
