文章目录
- 1 流的概念与分类
- 2 字节流
- 2.1 文件字节流
- 2.2 字节缓冲流
- 2.3 对象流
- 3 编码方式
- 4 字符流
- 4.1 文件字符流
- 4.2 字符缓冲流
- 4.3 打印流
- 4.4 转换流
1 流的概念与分类
- 流的概念：内存与存储设备之间传输数据的通道。
水借助管道传输≈数据借助流传输。 - 流的分类
（1）按方向【重点】
输入流：将<存储设备>中的内容读入到<内存>中。
输出流：将<内存>中的内容写入到<存储设备>中。
（2）按单位
字节流：以字节为单位，可以读写所有数据。
字符流：以字符为单位，只能读写文本数据。
（3）按功能
字节流：具有实际传输数据的读写功能。
过滤流：在节点流的基础之上增强功能。
2 字节流
存储在java.io包中。【之前都在java.lang包】
字节流的父类（抽象类）：
//InputStream 字节输入流
public int read(){}//从输入流读取下一个数据字节;已到达流的末尾，则返回-1
public int read(byte[] b){}从输入流中读取字节数组长度的字节数据存入数组中，返回实际读到的字节数；如果达到文件的尾部，则返回-1。
public int read(byte[] b, int off, int len){}//b缓冲区; off起始偏移;len最大字节数
// OutputStream 字节输出流
public void write(int n){}//将指定字节写入输出流。
public void write(byte[] b){}//一次写多个字节，将b数组中所有字节，写入输出流。
public void write(byte[] b, int off, int len){}对文件读写时，容易出现异常IOException，可以在main方法中提前抛出throws Exception。
2.1 文件字节流
- FileInputStream文件输入流
public int read()//从输入流中读取一个字节数据，返回读到的字节数据，如果达到文件末尾，返回-1。public int read(byte[] b)//从输入流中读取字节数组长度的字节数据存入数组中，返回实际读到的字节数；如果达到文件的尾部，则返回-1。 - FileOutputStream文件输出流
public void write(int b)//将指定字节写入输出流。public void write(bute[] b)//一次写多个字节，将b数组中所有字节，写入输出流。
文件输入：
package stream.bytestream;
import java.io.FileInputStream;
public class FileInText {
public static void main(String[] args) throws Exception{
//创建流并指定文件路径
FileInputStream in = new FileInputStream("E:\\code\\JAVA\\a.txt");//可能出现读取错误异常
//read()读入单个字节
int date = 0;
while((date=in.read())!=-1){
// System.out.print(date);//ASCII码
System.out.print((char)date);
}
//read(byte[] b);读入多个字节
byte[] b = new byte[1024];//自定义字节数
int count = 0;
while ((count=in.read(b))!=-1){
System.out.println(new String(b, 0, count));
//b是这个数组的值(一次读几个)，0是指从length=0开始读取流，count指到count时候停止读取
}
//关闭
in.close();
}
}
/*
Hello world.
Hello Java.
*/文件输出：
package stream.bytestream;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;
public class FileOutText {
public static void main(String[] args) throws Exception {
//创建输出流
FileOutputStream out = new FileOutputStream("E:\\code\\JAVA\\b.txt");
//写入文件
out.write(97);//ASCII码，代表字符‘a'
out.write('b');//写入一个字符
String s = new String(" Hello,Java");
out.write(s.getBytes(StandardCharsets.UTF_8));
//关闭流
out.close();
}
}
/*
ab Hello,Java
*/文件复制（一边输入一边输出）：
package stream.bytestream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class CopyText {
public static void main(String[] args) throws Exception {
//将图片读取到输入流
FileInputStream fileInputStream = new FileInputStream("E:\\code\\JAVA\\01.jpg");
//从输出流写入数据
FileOutputStream fileOutputStream = new FileOutputStream("E:\\code\\JAVA\\02.jpg");
int count;//保存一次读取到的实际个数
byte[] b = new byte[1024];
while ((count = fileInputStream.read(b)) != -1) {
fileOutputStream.write(b, 0, count);
}
System.out.println("复制成功");
//关闭流
fileInputStream.close();
fileOutputStream.close();
}
}
2.2 字节缓冲流
- 缓冲流：BufferedInputStream/BufferedOutputStream
- 特点：
（1）提高IO效率，减少访问磁盘的次数；
（2）数据存储在缓冲区中。flush()（“刷新”）可以将缓存区的内容写入文件，也可以直接close()关闭流【关闭时自动调用flush()】。
从缓冲区读入：
package stream.bytestream;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
public class BufferText1 {
public static void main(String[] args) throws Exception {
//从硬盘读取的输入流对象
FileInputStream in = new FileInputStream("E:\\code\\JAVA\\a.txt");
//从磁盘读入到缓冲区
BufferedInputStream bu = new BufferedInputStream(in);
// //从缓冲区读入，默认缓冲区大小8192(8K)
// int date;
// while ((date = bu.read()) != -1) {
// System.out.print((char) date);
// }
//自己创建一个缓冲区；
//每次读取从自己创建的缓冲区中读取。
int count;
byte[] buf = new byte[1024];
while ((count = bu.read(buf)) != -1) {
System.out.println(new String(buf, 0, count));
}
bu.close();//关闭缓冲区会自动关闭输入流对象，不需要再单独关闭
}
}
/*
Hello world.
Hello Java.
*/从缓冲区写出：
package stream.bytestream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;
public class BufferText2 {
public static void main(String[] args) throws Exception{
//文件输出对象
FileOutputStream out = new FileOutputStream("E:\\code\\JAVA\\c.txt");
//文件输出缓冲区
BufferedOutputStream bu = new BufferedOutputStream(out);
//写入缓冲区并刷新
for (int i = 0; i < 10; i++) {
bu.write("Helle,Java!".getBytes(StandardCharsets.UTF_8));
bu.flush();
}
bu.close();
}
}2.3 对象流
- 对象流：ObjectOutputStream/ObjectInputStream
用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。 - 特点：
（1）增加了缓冲区功能。
（2）增强了读写8种基本数据类型和字符串功能。
（3）增强了读写对象的功能。 - 使用流传输对象的过程称为序列化、反序列化。
序列化：数据转为二进制流。创建一个ObjectOutputStream调用writeObject()输出可序列化对象。注意写出一次，操作flush()一次。
反序列化：二进制流还原为数据。创建一个ObjectInputStream调用readObject()读取流中的对象。 - 注意点：
（1）序列化类必须要实现Serializable接口（此接口内什么都没有，只是一个序列化标识）。序列化类中对象属性也要求实现Serializable接口。
（2）serialVersionUID属性序列化版本号ID，可以保证序列化的类和反序列化的类是同一个类，不同的平台默认提供的序列化版本号多数情况下不会相同，为了避免反序列化时出错，需要指定。
（3）不能序列化static（静态）和transient（瞬间）修饰的成员变量。
（4）序列化多个对象,可以借助集合实现。
建一个Student类作为对象：
package study.io.objectstream;
import java.io.Serializable;
//实现接口Serializable标明类可以序列化
public class Student implements Serializable {
//序列化的类需要显式声明序列化版本标识符
private static final long serialVersionUID = 123L;
String name;
transient int age;//transient修饰的属性不可序列化
static int height;//静态属性不可序列化
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}序列化：
package study.io.objectstream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
//序列化：数据转为二进制流
public class Output {
public static void main(String[] args) throws Exception{
//定一个文件输出流，用来写文件。这个文件后缀名表示二进制文件，但你可以写成其他如obj等任意后缀
FileOutputStream fos = new FileOutputStream("G:\\Java\\student.obj");
//用文件输出流构造对象输出流
ObjectOutputStream oos = new ObjectOutputStream(fos);
//向流中写对象
Student s1 = new Student("Louis", 22);
Student s2 = new Student("Levics", 18);
Student s3 = new Student("Coco", 18);
ArrayList<Student> students = new ArrayList<>();//用一个集合存储多个对象
students.add(s1);
students.add(s2);
System.out.println(students);//[Student{name='Louis', age=22}, Student{name='Levics', age=18}]
oos.writeObject(students);//写入多个对象的列表
oos.writeObject(s3);//写入单个对象
oos.close();//自动调用flush()刷新
System.out.println("序列化完成");
}
}
反序列化：
package study.io.objectstream;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;
//反序列化：二进制流还原为数据
public class Input {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("G:\\Java\\student.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
//读取流中数据,只能依次读，不会重读
ArrayList<Student> list = (ArrayList<Student>)ois.readObject();
Student s = (Student)ois.readObject();
ois.close();
System.out.println("反序列化完成");
System.out.println(list.toString());
System.out.println(s.toString());
}
}
/*
反序列化完成
[Student{name='Louis', age=0}, Student{name='Levics', age=0}]
Student{name='Coco', age=0}
*/3 编码方式
编码方式 | 说明 |
IOS-8859-1 | 收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。采用1个字节来表示，最多只能表示256个字符。 |
UTF-8 | 针对Unicode码表的可变长度字符编码。国际上使用的编码，也称为“万国码”，收录了几乎所有国家的常用字符。采用1至3个字节来表示一个字符。 |
GB2312 | 简体中文，采用1个或2个字节来表示字符，95年之前所采用的编码。 |
GBK | 简体中文的扩充，GB2312的升级版本。 |
BIG5 | 台湾，繁体中文。 |
当编码方式和解码方式不一致时，会出现乱码。假如文件内容不是字母而是“我爱中国”这样的汉字，那么使用字节流读取出来的信息就是乱码。因为字节流按字节输入输出，而这四个汉字占了12个字节，把一个汉字按一个一个字节读入自然会出现问题，这时就需要使用字符流。
查看文本编码方式：
4 字符流
字符类的父类（抽象类）：
//reader 字符输入流
public int read(){}//从流中读取单个字符，用整型来返回读取的字符；当读到流底部时返回-1。
public int read(char[] c){}//从流中读取字符保存到c数组中，返回读取的字符个数，当读到流底部时返回-1。
public int read(char[] b, int off, int len){}//抽象方法。
//Writer 字符输出流
public void write(int n){}//写入单个字符，只能写入包含16位低阶字节的整型数值，16位高阶字节将会被忽略。
public void write(String str){}//写入一个字符串。
public void write(char[] c){}//写入一个字符数组。- 字符流适用于含有汉字的文本读取，但不能复制图片或二进制文件（01字符串）。
- 字节流可以复制任意文件。
4.1 文件字符流
- FileReader文件字符输入流：
public int read(char[] c)//从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数;如果达到文件的尾部，则返回-1。 - FileWrite文件字符输出流r：
public void write(String str)//一次写多个字符，将b数组中所有字符，写入输出流。
文件输入：
package study.io.file;
import java.io.FileReader;
//文件字符输入流
public class FileReaderText {
public static void main(String[] args) throws Exception{
FileReader fr = new FileReader("G:\\Java\\a.txt");
// //单个字符读取
// int date;
// while((date=fr.read())!=-1){
// System.out.print((char)date);
// }
// System.out.println(" ");
//自建缓冲区域读取多个字符
char[] buf = new char[1024];
int count;
while ((count=fr.read(buf))!=-1){
System.out.println(new String(buf, 0, count));
}
fr.close();
System.out.println("【读取完毕】");
}
}
/*
为共产主义事业奋斗终身！
【读取完毕】
*/文件输出：
package study.io.file;
import java.io.FileWriter;
//文件字符输出流
public class FileWriterText {
public static void main(String[] args) throws Exception {
FileWriter fw = new FileWriter("G:\\Java\\b.txt");
for (int i = 0; i < 10; i++) {
fw.write("为可持续发展贡献力量！\n");
}
fw.close();
System.out.println("【写入完毕】");
}
}文件复制：（使用FileReader和Filewriter复制文本文件，不能复制图片或二进制文件。）
package study.io.file;
import java.io.FileReader;
import java.io.FileWriter;
//使用FileReader和Filewriter复制文本文件,不能复制图片或二进制文件
public class FileCopy {
public static void main(String[] args) throws Exception {
FileReader fr = new FileReader("G:\\Java\\b.txt");
FileWriter fw = new FileWriter("G:\\Java\\b2.txt");
char[] ch = new char[1024];
int count;
while ((count=fr.read(ch))!=-1){
fw.write(new String(ch, 0, count));
}
fr.close();
fw.close();
System.out.println("【复制完成】");
}
}4.2 字符缓冲流
- 缓冲流：BufferedReader/BufferedWriter
- 特点：
（1）高效读写
（2）支持输入换行符newLine()（3）可一次写一行、读一行readLine()
借助缓冲流按行读取并复制：
package study.io.file;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
//字符缓冲流
public class BufferReaderText {
public static void main(String[] args) throws Exception {
FileReader fr = new FileReader("G:\\Java\\a.txt");
BufferedReader br = new BufferedReader(fr);
FileWriter fw = new FileWriter("G:\\Java\\a2.txt");
BufferedWriter bw = new BufferedWriter(fw);
// //默认缓冲区读取
// int date;
// while((date=br.read())!=-1){
// System.out.print((char)date);
// }
//实现按行读取并写入
String line = null;
while((line=br.readLine())!=null){
System.out.println(line);
bw.write("自信从容迈向未来");
bw.newLine();//相当于一个换行符\r \n
bw.write(line);
}
br.close();
bw.close();
System.out.println("【复制完毕】");
}
}4.3 打印流
- 实现类：PrintWriter
- 特点：
（1）封装了print()/println()方法，支持写入后换行。
（2）支持数据原样打印
package study.io.file;
import java.io.PrintWriter;
//字符打印流
public class printText {
public static void main(String[] args) throws Exception{
PrintWriter pw = new PrintWriter("G:\\Java\\print.txt");
//支持数据原样打印
pw.print(97);//97
pw.print("b");
pw.println("ok");//换行
pw.println("你好");
pw.close();
}
}
/*
97bok
你好
*/4.4 转换流
- 桥转换流: InputStreamReader/OutputStreamWriter。
- 特点：
（1）可将字节流转换为字符流。
（2）可设置字符的编码方式。
用转换流读取汉字字符并设置编码方式：
package study.io.file;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
//转换流
public class StreamReader {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("G:\\Java\\a.txt");//字节流
InputStreamReader isr = new InputStreamReader(fis, "utf-8");
FileOutputStream fos = new FileOutputStream("G:\\Java\\turn.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");
char[] ch = new char[1024];
int count;
while((count=isr.read(ch))!=-1){
System.out.println(new String(ch, 0, count));
osw.write(new String(ch, 0, count));
}
isr.close();
osw.close();
System.out.println("【转换完成】");
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
