基本概念和io入门
对于任何程序设计语言而言，输入输出系统都是非常核心的功能。程序运行需要数据，数据的获取往往需要跟外部系统进行通信，外部系统可能是文件、数据库、其他程序、网络、IO设备等等。外部系统比较复杂多变，那么我们有必要通过某种手段进行抽象、屏蔽外部的差异，从而实现更加便捷的编程。
输入(Input)指的是：可以让程序从外部系统获得数据(核心含义是“读”，读取外部数据)。常见的应用：
Ø 读取硬盘上的文件内容到程序。例如：播放器打开一个视频文件、word打开一个doc文件。
Ø 读取网络上某个位置内容到程序。例如：浏览器中输入网址后，打开该网址对应的网页内容;下载网络上某个网址的文件。
Ø 读取数据库系统的数据到程序。
Ø 读取某些硬件系统数据到程序。例如：车载电脑读取雷达扫描信息到程序;温控系统等。
输出(Output)指的是：程序输出数据给外部系统从而可以操作外部系统(核心含义是“写”，将数据写出到外部系统)。常见的应用有：
Ø 将数据写到硬盘中。例如：我们编辑完一个word文档后，将内容写到硬盘上进行保存。
Ø 将数据写到数据库系统中。例如：我们注册一个网站会员，实际就是后台程序向数据库中写入一条记录。
Ø 将数据写到某些硬件系统中。例如：导弹系统导航程序将新的路径输出到飞控子系统，飞控子系统根据数据修正飞行路径。
java.io包为我们提供了相关的API，实现了对所有外部系统的输入输出操作，这就是我们这章所要学习的技术。
数据源
数据源data source，提供数据的原始媒介。常见的数据源有：数据库、文件、其他程序、内存、网络连接、IO设备。如图所示。
数据源分为：源设备、目标设备。
-
源设备：为程序提供数据，一般对应输入流。
-
目标设备：程序数据的目的地，一般对应输出流。
流的概念
流是一个抽象、动态的概念，是一连串连续动态的数据集合。
对于输入流而言，数据源就像水箱，流(stream)就像水管中流动着的水流，程序就是我们最终的用户。我们通过流(A Stream)将数据源(Source)中的数据(information)输送到程序(Program)中。
对于输出流而言，目标数据源就是目的地(dest)，我们通过流(A Stream)将程序(Program)中的数据(information)输送到目的数据源(dest)中。
注意：
输入/输出流的划分是相对程序而言的，并不是相对数据源。
四大IO抽象类
InputStream/OutputStream和Reader/writer类是所有IO流类的抽象父类。
InputStream
此抽象类是表示字节输入流的所有类的父类。InputSteam是一个抽象类，它不可以实例化。 数据的读取需要由它的子类来实现。根据节点的不同，它派生了不同的节点流子类 。
继承自InputSteam的流都是用于向程序中输入数据，且数据的单位为字节(8 bit)。
常用方法：
int read()：读取一个字节的数据，并将字节的值作为int类型返回(0-255之间的一个值)。如果未读出字节则返回-1(返回值为-1表示读取结束)。
void close()：关闭输入流对象，释放相关系统资源。
OutputStream
此抽象类是表示字节输出流的所有类的父类。输出流接收输出字节并将这些字节发送到某个目的地。
常用方法：
void write(int n): 向目的第中写入一个字节
void close():关闭输出流对象，释放相关系统资源。
Reader
Reader用于读取的字符流抽象类，数据单位为字符。
int read():读取一个字符的数据，并将字符的值作为int类型返回（0-65535之间的一个值，即Unicode值）。如果未读出字符则返回-1（返回值为-1表示读取结束）。
void close()：关闭流对象，释放相关系统资源。
Wirter
Write用于写入的字符流抽象类，数据单位为字符；
void write(int n): 向输出流中写入一个字符；
void close(): 关闭输出流对象，释放相关系统资源。
文件字节流
FileInputStream通过字节的方式读取文件，适合读取所有类型的文件（图像，视频，文本文件，等。）java也提供了FileReader专门读取文本文件。
FileOutputStream通过字节的方式写数据到文件中，适合所有类型的文件。Java也提供了FIleWriter专门写入文本文件。
//将字符串/字节数组的内容写入到文件中
import java.io.FileOutputStream;
import java.io.IOException;
public class TestFileOutputStream{
public static void main(String[] args){
FileOutputStream fos = null;
String string = "北京尚学堂欢迎你！";
try{
//true表示内容会追加到文件末尾；false表示重写整个文件内容。
fos = new FileOutputStream("d:/a.txt",true);
//该方法是直接将一个字节数组写入文件中；wirte(int n)是写入一个字节
fos.wirte(string.getBytes());
}catch(Exception e){
e.printStackTrace();
}finally{
try{
if(fos !=null){
fos.close();
}
}catch(IOException e){
e.printStackTrace();
}
}
}
}
在实例中，用到一个wirte方法：void write(byte[] b),该方法不在一个字节一个字节地输入，而是直接写入一个字节数组；另外其还有一个重载方法：void write(byte[] b,int off,int length),这个方法也是写入一个字节数组，但是我们可以指定从字节数组的哪个位置开始写入，写入的长度是多少。
现在我们已经学习了使用文件字节流分别实现文件的读取与写入操作，接下来我们将两个功能综合使用就可以轻松实现文件的复制了。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestFileCope{
public static void main(String[] args){
//将a.txt内容拷贝到b.txt
copeFile("d:/a.txt","d:/b.txt");
}
/**
*将src文件的内容拷贝到dec文件
*src 源文件
*dec 目标文件
*/
static void copyFile(String src,String dec){
FileInputStream fis = null;
FileOutputStream fos = null;
//为了提高效率，设置缓存数组！(读取的字节数据会暂存放到该字节数组中)
byte[] buffer = new byte[1024];
int temp = 0;
try{
fis = new FileInputStream(src);
fos = new FileOutputStream(dec);
//边读边写
//temp指的是本次读取的真实长度，temp等于-1是表示读取结束
while((temp = fis.read(buffer))!=-1){
fos.write(buffer,0,temp);
}
}catch(Exception e){
e.printStackTrace();
}finally{
//两个流需要分别关闭
try{
if(fos !=null){
fos.close();
}
}catch(IOException e){
e.printStackTrace();
}
try{
if(fis !=null){
fis.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
}
注意：
在使用文件字节流时，我们需要注意以下两点：
-
为了减少对硬盘的读写次数，提高效率，通常设置缓存数组。相应地，读取时使用的方法为：read(byte[] b);写入时的方法为：write(byte[ ] b, int off, int length)。
-
程序中如果遇到多个流，每个流都要单独关闭，防止其中一个流出现异常后导致其他流无法关闭的情况。
文件字符流
前面介绍的文件字节流可以处理所有的文件，但是字节流不能很好的处理Unicode字符，经常会出现“乱码”现象。所以，我们处理文本文件，一般可以使用文件支付流，它以字符为单位进行操作。
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class TestFileCope2 {
public static void main(String[] args) {
//写法和使用Stream基本一样。只不过，读取时是读取的字符。
FileReader fr =null;
FileWriter fw =null;
int len =0;
try{
fr = new FileReader("D:\\Users\\testjava\\src\\IO_study02\\abc.txt");
fw= new FileWriter("D:\\Users\\testjava\\src\\IO_study02\\bcd.txt");
//为了提高效率，创建缓冲用的字符数组
char[] buffer = new char[1024];
//边读边写
while((len = fr.read(buffer)) !=-1){
fw.write(buffer,0,len);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try{
if(fw !=null){
fw.close();
}
} catch (IOException e) {
e.printStackTrace();
}try {
if(fr != null){
fr.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
装饰器模式简介
装饰器模式是GOF23种设计模式中较位常用的一种模式。它可以实现对原有类的包装和装饰，使新的类具有更强的功能。
我这里有智能手机iphone, 我们可以通过加装投影组件，实现原有手机功能的扩展。这就是一种“装饰器模式”。 我们在未来给普通人加装“外骨骼”装饰，让普通人具有力扛千斤的能力，也是一种“装饰器模式”。
class Iphone {
private String name;
public Iphone(String name) {
this.name = name;
}
public void show() {
System.out.println("我是" + name + ",可以在屏幕上显示");
}
}
class TouyingPhone {
public Iphone phone;
public TouyingPhone(Iphone p) {
this.phone = p;
}
// 功能更强的方法
public void show() {
phone.show();
System.out.println("还可以投影，在墙壁上显示");
}
}
public class TestDecoration {
public static void main(String[] args) {
Iphone phone = new Iphone("iphone30");
phone.show();
System.out.println("===============装饰后");
TouyingPhone typhone = new TouyingPhone(phone);
typhone.show();
}
}
缓冲字节流
Java缓冲流本身并不具备io流的读取与写入功能，只是在别的流（节点流或其他处理流）上加入缓冲功能提高效率，就像时把别的流包装起来一样，因此缓冲流是一种处理流(包装流)。
当对文件或者其他数据源进行频繁的读写操作时，效率比较低，这时如果使用缓冲流就能够更高效的读写信息。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷新时再一次性的读取到程序或写入目的地。
因此，缓冲流还是很重要的，我们在IO操作时记得加上缓冲流来提升性能。
BufferedInputStream和BufferedOutputStream这两个流是缓冲字节流，通过内部缓存数组来提高操作流的效率。
下面我们通过两种方式(普通文件字节流与缓冲文件字节流)实现一个视频文件的复制，来体会一下缓冲流的好处。
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestBufferedFileCopy1 {
public static void main(String[] args) {
// 使用缓冲字节流实现复制
long time1 = System.currentTimeMillis();
copyFile1("D:/电影/华语/大陆/尚学堂传奇.mp4", "D:/电影/华语/大陆/尚学堂越
"+"来越传奇.mp4");
long time2 = System.currentTimeMillis();
System.out.println("缓冲字节流花费的时间为：" + (time2 - time1));
// 使用普通字节流实现复制
long time3 = System.currentTimeMillis();
copyFile2("D:/电影/华语/大陆/尚学堂传奇.mp4", "D:/电影/华语/大陆/尚学堂越
"+"来越传奇2.mp4");
long time4 = System.currentTimeMillis();
System.out.println("普通字节流花费的时间为：" + (time4 - time3));
}
/**缓冲字节流实现的文件复制的方法*/
static void copyFile1(String src, String dec) {
FileInputStream fis = null;
BufferedInputStream bis = null;
FileOutputStream fos = null;
BufferedOutputStream bos = null;
int temp = 0;
try {
fis = new FileInputStream(src);
fos = new FileOutputStream(dec);
//使用缓冲字节流包装文件字节流，增加缓冲功能，提高效率
//缓存区的大小（缓存数组的长度）默认是8192，也可以自己指定大小
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
while ((temp = bis.read()) != -1) {
bos.write(temp);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//注意：增加处理流后，注意流的关闭顺序！“后开的先关闭！”
try {
if (bos != null) {
bos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (bis != null) {
bis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (fos != null) {
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (fis != null) {
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**普通节流实现的文件复制的方法*/
static void copyFile2(String src, String dec) {
FileInputStream fis = null;
FileOutputStream fos = null;
int temp = 0;
try {
fis = new FileInputStream(src);
fos = new FileOutputStream(dec);
while ((temp = fis.read()) != -1) {
fos.write(temp);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (fos != null) {
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (fis != null) {
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
注意：
-
在关闭流时，应该先关闭最外层的包装流，即“后开的先关闭”。
-
缓存区的大小默认是8192字节，也可以使用其它的构造方法自己指定大小。
缓冲字符流
BufferedReader/BufferedWriter增加了缓存机制，大大提高了读写文本文件的效率，同时，提供了更方便的按行读取的方法：readLine(); 处理文本时，我们一般可以使用缓冲字符流。
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class TestBufferedFileCopy2 {
public static void main(String[] args) {
// 注：处理文本文件时，实际开发中可以用如下写法，简单高效！！
FileReader fr = null;
FileWriter fw = null;
BufferedReader br = null;
BufferedWriter bw = null;
String tempString = "";
try {
fr = new FileReader("d:/a.txt");
fw = new FileWriter("d:/d.txt");
//使用缓冲字符流进行包装
br = new BufferedReader(fr);
bw = new BufferedWriter(fw);
//BufferedReader提供了更方便的readLine()方法，直接按行读取文本
//br.readLine()方法的返回值是一个字符串对象，即文本中的一行内容
while ((tempString = br.readLine()) != null) {
//将读取的一行字符串写入文件中
bw.write(tempString);
//下次写入之前先换行，否则会在上一行后边继续追加，而不是另起一行
bw.newLine();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (bw != null) {
bw.close();
}
} catch (IOException e1) {
e1.printStackTrace();
}
try {
if (br != null) {
br.close();
}
} catch (IOException e1) {
e1.printStackTrace();
}
try {
if (fw != null) {
fw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (fr != null) {
fr.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
注意：
- readLine()方法是BufferedReader特有的方法，可以对文本文件进行更加方便的读取操作。
- 写入一行后要记得使用newLine()方法换行。
转换流
InputStreamReader/OutputStreamWriter用来实现将字节流转化成字符流。比如，如下场景：
System.in是字节流对象，代表键盘的输入，如果我们想按行接受用户的输入时，就必须用到缓冲字符流BufferedReader特有的方法readerLine（），但是经过观察会发现在创建BufferedReader的构造方法的参数必须是一个Reader对象，这时候我们的转换流InputStreamReader就派上用场了。
而System.out也是字节流对象，代表输出到显示器，按行读取用户的输入后，并且要将读取的以个字符串直接显示到控制台，就需要用到字符流的writer（String str）方法，所以我们要使用OutputStreamWriter将字节流转化成字符流.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class TestConvertStream {
public static void main(String[] args) {
// 创建字符输入和输出流:使用转换流将字节流转换成字符流
BufferedReader br = null;
BufferedWriter bw = null;
try {
br = new BufferedReader(new InputStreamReader(System.in));
bw = new BufferedWriter(new OutputStreamWriter(System.out));
// 使用字符输入和输出流
String str = br.readLine();
// 一直读取，直到用户输入了exit为止
while (!"exit".equals(str)) {
// 写到控制台
bw.write(str);
bw.newLine();// 写一行后换行
bw.flush();// 手动刷新
// 再读一行
str = br.readLine();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭字符输入和输出流
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bw != null) {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
数据流
数据流将“基本数据类型与字符串类型”作为数据流，从而允许程序以与机器无关的方式从低层输入输出流中操作Java基本数据类型与字符串类型。
DataInputStream和DataOutputStream提供了可以存取与机器无关的所有Java基础类型数据。比如：int,double,String等)的方法。
DataInputStream和DataOutputStream是处理流，可以对其他流或处理流进行包装，增加一些更灵活，更高效的功能。
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestDataStream {
public static void main(String[] args) {
DataOutputStream dos = null;
DataInputStream dis = null;
FileOutputStream fos = null;
FileInputStream fis = null;
try {
fos = new FileOutputStream("D:/data.txt");
fis = new FileInputStream("D:/data.txt");
//使用数据流对缓冲流进行包装，新增缓冲功能
dos = new DataOutputStream(new BufferedOutputStream(fos));
dis = new DataInputStream(new BufferedInputStream(fis));
//将如下数据写入到文件中
dos.writeChar('a');
dos.writeInt(10);
dos.writeDouble(Math.random());
dos.writeBoolean(true);
dos.writeUTF("北京尚学堂");
//手动刷新缓冲区：将流中数据写入到文件中
dos.flush();
//直接读取数据：读取的顺序要与写入的顺序一致，否则不能正确读取数据。
System.out.println("char: " + dis.readChar());
System.out.println("int: " + dis.readInt());
System.out.println("double: " + dis.readDouble());
System.out.println("boolean: " + dis.readBoolean());
System.out.println("String: " + dis.readUTF());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(dos!=null){
dos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(dis!=null){
dis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(fos!=null){
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(fis!=null){
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
注意：
使用数据流时，读取的顺序一定要与写入的顺序一致，否则不能正确读取数据。
对象流
我们前边学到的数据流只能实现对基本数据类型和字符串类型的读写，并不能读取对象(字符串除外)，如果要对某个对象进行读写操作，我们需要学习一对新的处理流：ObjectInputStream/ObjectOutputStream。
ObjectInputStream/ObjectOutputStream是以“对象”为数据源，但是必须将传输的对象进行序列化与反序列化操作。
序列化与反序列化的具体内容，请见<10.3 Java对象的序列化和反序列化>。示例10-11仅演示对象流的简单应用。
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.Date;
public class TestObjectStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
write();
read();
}
/**使用对象输出流将数据写入文件*/
public static void write(){
// 创建Object输出流，并包装缓冲流，增加缓冲功能
OutputStream os = null;
BufferedOutputStream bos = null;
ObjectOutputStream oos = null;
try {
os = new FileOutputStream(new File("d:/bjsxt.txt"));
bos = new BufferedOutputStream(os);
oos = new ObjectOutputStream(bos);
// 使用Object输出流
//对象流也可以对基本数据类型进行读写操作
oos.writeInt(12);
oos.writeDouble(3.14);
oos.writeChar('A');
oos.writeBoolean(true);
oos.writeUTF("北京尚学堂");
//对象流能够对对象数据类型进行读写操作
//Date是系统提供的类，已经实现了序列化接口
//如果是自定义类，则需要自己实现序列化接口
oos.writeObject(new Date());
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭输出流
if(oos != null){
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(os != null){
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**使用对象输入流将数据读入程序*/
public static void read() {
// 创建Object输入流
InputStream is = null;
BufferedInputStream bis = null;
ObjectInputStream ois = null;
try {
is = new FileInputStream(new File("d:/bjsxt.txt"));
bis = new BufferedInputStream(is);
ois = new ObjectInputStream(bis);
// 使用Object输入流按照写入顺序读取
System.out.println(ois.readInt());
System.out.println(ois.readDouble());
System.out.println(ois.readChar());
System.out.println(ois.readBoolean());
System.out.println(ois.readUTF());
System.out.println(ois.readObject().toString());
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭Object输入流
if(ois != null){
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bis != null){
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(is != null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
注意:
-
对象流不仅可以读写对象，还可以读写基本数据类型。
-
使用对象流读写对象时，该对象必须序列化与反序列化。
-
系统提供的类(如Date等)已经实现了序列化接口，自定义类必须手动实现序列化接口。
序列化和反序列化是什么
当两个进程远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。比如，我们可以通过http协议发送字符串信息；我们也可以在网络直接发送Java对象。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；才能在网络上传送；接收方则需要把字节序列再恢复为Java对象才能正常读取.
把Java对象转化为字节序列的过程称为对象的序列化。把字节序列恢复为Java对象的过程称为对象的反序列化。
对象序列化的作用有如下两种：
- 持久化：把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中，比如：休眠的实现。以后服务器session管理，hibernate将对象持久化实现。
- 网络通信：在网络上传送对象的字节序列。比如：服务器之间的数据通信，对象传递。
序列化涉及的类和接口
ObjectOutputStream代表对象输出流，它的writeObject（Object obj）方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
ObjectInputStream代表对象输入流，它的readObject（）方法从一个源输入流中读取字节序列，把它们反序列化为一个对象，并将其返回。
只有实现了Serializable接口的类的对象才能被序列化。Seralizable接口是一个空接口，只起到标记作用。
1789
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
