一.IO流概述

1.定义:Java的IO流是实现输入输出的基础,它可以方便地实现数据的输入/输出操作。

2.流的分类:

(1)按流向来分:输入流和输出流

(2)按操作的数据来分:字节流和字符流

(3)按流的角色来分:节点流和处理流

二.IO流类图

IO流(二)I/O-LMLPHP

常用流分类:

IO流(二)I/O-LMLPHP

通常来说,字节流的功能比字符流强大,因为计算机里所有的数据都是二进制的,而字节流可以处理所有的二进制文件,但如果使用字节流来处理文本文件,则需要将字节转换为字符,这增加了编程复杂度。所以有这样一个规则:如果操作的内容是文本,则考虑使用字符流,如果操作的内容是二进制内容,则应考虑使用字节流。

三.常用流介绍

1.转换流:输入/输出流体系中还提供了两个转换流,这两个转换流用于实现将字节流转换成字符流。

InputStreamReader将字节输入流转换成字符输入流,OutputStreamWriter将字节输出流转换成字符输出流。

 public class InputStreamReaderDemo {
public static void main(String[] args) {
// 将标准字节输入流转换为字符流
InputStreamReader reader = new InputStreamReader(System.in);
// 将字符流进一步包装成缓冲流
BufferedReader buffer = new BufferedReader(reader);
String line = null;
try {
// System.out.println("请输入:");
while ((line = buffer.readLine()) != null) { if ("exit".equals(line)) {
System.exit(1);// 读取到exit,程序退出
}
System.out.println("输出内容:" + line);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

2.缓冲流

BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedeWriter

使用缓冲流的好处:能够高效的读写信息,原理是先将数据缓存起来,然后再一起写入或者读取出来。

3.打印流

PrintStream,PrintWriter

  使用打印流的好处:可以很方便的进行输出

 public class PrintDemo {

     public static void main(String[] args) {
printToFile();
System.out.println("success");
} public static void printToFile(){
try {
OutputStream output = new FileOutputStream("D:\\code\\999.txt");
PrintWriter pw = new PrintWriter(new BufferedOutputStream(output));
pw.println("我是一只小小小鸟");
pw.println(true);
pw.println(999);
pw.println(1.114);
pw.flush();
pw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} }
}

 4.对象流:序列化和反序列化对象

  (1)什么是对象序列化

    对象序列化的目标是将对象保存到磁盘中,或在网络中传输对象。

    对象序列化机制允许把内存中的对象转换成平台无关的二进制流,从而允许把这种二进制流持久地保存在磁盘上,或通过网络将这种二进制流传输到另一个网络节点,其他程序一旦获得这个二进制流,就可以将这种二进制流恢复成原来的java对象。

  (2)如何让类是可序列化的

    实现Serializable接口,该接口是一个标记接口,接口内无任何需要实现的方法。

  (3)对象的序列化和反序列化

    对象序列化(Serialize)是指将一个java对象写入IO流中,对象的反序列化(Deserialize)是指从IO流中恢复该java对象

  (4)怎么使用对象流实现序列化

    两个类:ObjectOutputStream,ObjectInputStream 对象流是处理流,需要建立在节点流的基础之上。

    两个方法:writeObject(), readObject()

    如果不想序列化某个成员变量,可以在声明中加入关键字 transient, 例如private transient int age;

    使用方法见下面代码:(Dog类省略)

    

 package com.gdp.xuliehua;

 import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream; public class TestDog {
public static void main(String[] args) {
//writeObject();
//readObject();
//writeObject2();
readObject2();
}
/**
* 将对象写入到文件中
*/
public static void writeObject(){
try {
OutputStream out = new FileOutputStream("D:\\dog.txt");
ObjectOutputStream oos = new ObjectOutputStream(out);
oos.writeInt(130);
Dog dog = new Dog("小黑",3);
oos.writeObject(dog);
oos.flush();
oos.close();
out.close();
System.out.println("OK");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} }
/**
* 从文件中读取对象
*/
public static void readObject(){
try {
InputStream in = new FileInputStream("D:\\dog.txt");
ObjectInputStream ois = new ObjectInputStream(in);
int i = ois.readInt();
Dog dog = (Dog)ois.readObject();
ois.close();
in.close();
System.out.println(i);
System.out.println(dog);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} }
/**
* 序列化多个对象,采用对象数组来实现将对象写入文件中
*/
public static void writeObject2(){
Dog dog1 = new Dog("小黑",5);
Dog dog2 = new Dog("小白",3);
Dog dog3 = new Dog("小红",6);
try {
OutputStream out = new FileOutputStream("D:\\obj.tmp");
ObjectOutputStream oos = new ObjectOutputStream(out);
Dog[] dogs = new Dog[]{dog1,dog2,dog3};
oos.writeObject(dogs);
oos.flush();oos.close();out.close();
System.out.println("ok");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} }
/**
* 将多个对象从文件中读取出来
* 1.读取出来的对象是对象数组
* 2.遍历数组,取出对象
*/
public static void readObject2(){
try {
InputStream in= new FileInputStream("D:\\obj.tmp");
ObjectInputStream ois = new ObjectInputStream(in);
Dog[] dogs = (Dog[])ois.readObject();
ois.close();in.close();
for (Dog dog : dogs) {
System.out.println(dog);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} }
}

 5.ByteArrayInputStream和ByteArrayOutputStream

  (1)ByteArrayInputStream包含一个内部缓冲区,该缓冲区包含从流中读取的字节。

    关闭ByteArrayInputStream无效,此类的方法在关闭流后仍可被调用,而不会产生任何IOException。

  (2)ByteArrayOutputStream,此类实现一个输出流,其中的数据被写入一个byte数组,缓冲区会随着数据的不断写入而自动增长,可以使用toByteArray()和toString()获取数据.

  关闭ByteArrayOutputStream无效,此类的方法在关闭流后仍可被调用,而不会产生任何IOException。

  (3)使用方法如下列代码:

 import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException; public class ByteArrayDemo {
public static void main(String[] args) {
write();
}
/**
* 写入数据,不与文件关联,写入内存
* 读取数据并显示
*/
public static void write(){
ByteArrayOutputStream bos = new ByteArrayOutputStream();
String info = "我是一只小小小小鸟!";
try {
bos.write(info.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
//读取数据
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
StringBuffer buf = new StringBuffer();
byte[] bytes = new byte[1024];
int temp ;
try {
while((temp=bis.read(bytes))!=-1){
buf.append(new String(bytes, 0, temp));
}
System.out.println(buf.toString());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }
}

6.过滤器数据流:DataInputStream和DataOutputStream

  (1)DataInputStream和DataOutputStream专门用于读写基本数据类型数据,而对象流既可以读写基本数据类型的数据也可以读写对象。

  (2)它是一个处理流,需要建立在节点流的基础之上,如new DataInputStream(new FileInputStream("text.txt"))

  (3)DataInputStream和DataOutputStream有读写的相关方法一一对应,基本使用方法见下面代码:

 import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream; public class DataStreamDemo {
public static void main(String[] args) {
// write();
read();
} /**
* 向文件写入数据
*/
public static void write() {
try {
OutputStream out = new FileOutputStream("D:\\test.txt");
DataOutputStream dos = new DataOutputStream(out);
dos.writeInt(100);// 写入int数值
dos.writeDouble(99.99);// 写入double数值
dos.writeBoolean(true);// 写入boolean值
dos.writeUTF("我是一只小小小小鸟");
dos.flush();
dos.close();
out.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} } /**
* 从文件读取数据
*/
public static void read() {
try {
InputStream in = new FileInputStream("D:\\test.txt");
DataInputStream dis = new DataInputStream(in);
System.out.println(dis.readInt());
System.out.println(dis.readDouble());
System.out.println(dis.readBoolean());
System.out.println(dis.readUTF());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} }
}
05-17 14:10