------
Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
在前面两天中学习了IO流,主要是字符流和字节流。内容包括字符流的几个类 Reader和Writer,文件操作类 FileReader、FileWriter、字符流缓冲区 BufferedReader和BufferedWriter,转换流 BufferedInputStreamReader和 BufferedOutputStreamWriter,字节流的InputStream和OutputStream,文件操作类 FileInputStream和FileOutputStream,字节流缓冲区 BufferedInputStream和BufferedOutputStream。这几个类之间的关系图如下:
下面,我们来的看一下IO包中的其他类
一、操作对象的流(ObjectInputStream和ObjectOutputStream)
ObjectInputStream和ObjectOutputStream:可以直接操作对象的流(对象的序列化)
又称为对象的序列化,或者对象的持久化。在我们的程序运行结束以后,我们在程序中创建的对象也会随着程序的结束而结束。现在我们可以将对象作一个持久化,即将以文件的形式保存在硬盘上。这里就要用到操作对象的流 ObjectInputStream 和 ObjectOutputStream
ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。通过在流中使用文件可以实现对象的持久存储。
主要方法:writeObject()
ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。
主要方法:readObject()
上面这两个类的父类分别是OutputStream和InputStream,所以继承了这两个类的方法
通过代码来看看其应用:
import java.io.*;
class ObjectStreamDemo
{
public static void main(String[] args)
{
//writeObject();
readObject();
}
//从文件中读取对象(反序列化)
public static void readObject()
{
ObjectInputStream ois=null;
try
{
//将对象反序列化
ois =new ObjectInputStream(new FileInputStream("obj.txt"));
//读取对象
Person p=(Person)ois.readObject();
System.out.println(p);
}
catch(Exception e)
{
System.out.println(e.toString());
}
finally
{
try
{
if(ois!=null)
ois.close();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
//将对象序列化(将对象持久化,即将对象存储在文件中)
public static void writeObject()
{
ObjectOutputStream oos=null;
try
{
oos=new ObjectOutputStream(new FileOutputStream("obj.txt"));
//将对象序列化
oos.writeObject(new Person("zhangsan0",30));
//也可以序列化多个对象,这样在读取的时候是依次读取的
//oos.writeObject(new Person("zhangsan",30));
//oos.writeObject(new Person("zhangsan",30));
//oos.writeObject(new Person("zhangsan",30));
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
try{
if(oos!=null)
oos.close();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
}
person类:被序列化的对象所属类要实现Serializable接口
每个类都有自己的UID,当我们将被序列化的对象所属类修改后,这个UID就会改变,为避免类修改以后,以前保存的对象无法反序列化,所以自定义了UID,如下:
import java.io.*;
class Person implements Serializable
{
//自定义UID变量,这样,即使类变化了,UID依然不变,以前序列化的对象依然可以读取
public static final log serialVersionUID=42L;
private String name;
private int age; //如果变量不想序列化,可以在前面加修饰符:transient
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age=age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name=name;
}
Person(String name,int age)
{
this.name=name;
this.age=age;
}
public String toString()
{
return name+"::"+age;
}
}
对象在文件中:
当我们对对象反序列化后:
二、管道流
PipedInputStream 和 PipedOutputStream
输入输出可以直接进行连接,通过结合线程使用.
1、管道输入流应该连接到管道输出流;
2、管道输入流提供要写入管道输出流的所有数据字节。
通常,数据由某个线程从 PipedInputStream 对象读取,并由其他线程将其写入到相应的 PipedOutputStream。
不建议对这两个对象尝试使用单个线程,因为这样可能死锁线程。
通常,数据由某个线程从 PipedInputStream 对象读取,并由其他线程将其写入到相应的 PipedOutputStream。
不建议对这两个对象尝试使用单个线程,因为这样可能死锁线程。
3、管道输入流包含一个缓冲区,可在缓冲区限定的范围内将读操作和写操作分离开。
如果向连接管道输出流提供数据字节的线程不再存在,则认为该管道已损坏。
1、可以将管道输出流连接到管道输入流来创建通信管道。管道输出流是管道的发送端。
2、通常,数据由某个线程写入 PipedOutputStream 对象,并由其他线程从连接的 PipedInputStream 读取。
如果向连接管道输出流提供数据字节的线程不再存在,则认为该管道已损坏。
1、可以将管道输出流连接到管道输入流来创建通信管道。管道输出流是管道的发送端。
2、通常,数据由某个线程写入 PipedOutputStream 对象,并由其他线程从连接的 PipedInputStream 读取。
代码:
import java.io.*;
class PipedStreamDemo
{
public static void main(String[] args) throws IOException
{
//创建管道输入流对象
PipedInputStream pis=new PipedInputStream();
//创建管道输出流对象
PipedOutputStream pos=new PipedOutputStream();
//管道输入流输出流连接
pis.connect(pos);
Write write=new Write(pos);
Read read=new Read(pis);
new Thread(write).start();
new Thread(read).start();
}
}
//自定义类实现Runnable接口
class Write implements Runnable
{
private PipedOutputStream pos;
Write(PipedOutputStream pos)
{
this.pos=pos;
}
public void run()
{
try
{
System.out.println("开始写入数据,等待6秒后。。。");
Thread.sleep(6000);
//管道输出流写入数据,是管道的发送端
pos.write("我来了".getBytes());
pos.close();
}
catch(Exception e)
{
throw new RuntimeException("管道流输出失败!");
}
}
}
//自定义类实现Runnable接口
class Read implements Runnable
{
private PipedInputStream pis;
Read(PipedInputStream pis)
{
this.pis=pis;
}
public void run()
{
try
{
byte[] byt=new byte[1024];
System.out.println("读取前。。。没有数据,阻塞中。。。。");
//管道输入流读取数据
int len=pis.read(byt);
System.out.println("读到数据。。。。阻塞结束");
String s=new String(byt,0,len);
System.out.println(s);
pis.close();
}
catch(Exception e)
{
throw new RuntimeException("管道流输入失败!");
}
}
}
结果:
三,随机访问文件类(RandomAccessFile)
随机访问文件,自身具备读写的方法,通过skipBytes(int x),seek(int x) 来达到随机访问
该类不算是IO体系中的子类。而是直接继承自Object。但是它是IO包中成员。因为它具备读和写功能。
内部封装了一个数组,而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置,同时可以通过seek改变指针的位置。
其实完成读写的原理就是内部封装了字节输入流和输出流。
该类不算是IO体系中的子类。而是直接继承自Object。但是它是IO包中成员。因为它具备读和写功能。
内部封装了一个数组,而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置,同时可以通过seek改变指针的位置。
其实完成读写的原理就是内部封装了字节输入流和输出流。
通过构造函数可以看出,该类只能操作文件。而且操作文件还有模式:只读r,读写rw。如果模式为只读r,不会创建文件,会去读取一个已存在的文件,如果该文件不存在,则会出现异常。如果模式为rw,操作的文件不存在,会自动创建,如果存在不会覆盖。
代码:
import java.io.*;
class RandomAccessFileDemo
{
public static void main(String[] args)
{
//writeFile();
read();
}
//在指定位置插入
public static void write_2()
{
RandomAccessFile raf=null;
try
{
//创建一个随机访问文件类的对象
raf=new RandomAccessFile("ran.txt","rw");
//指定指针的位置
ran.seek(8*1);
//在指针位置插入
raf.write("周七".getBytes());
raf.writeInt(105);
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
try{
if(raf!=null)
raf.close();
}
}
}
//取值
public static void read()
{
RandomAccessFile raf=null;
try
{
raf=new RandomAccessFile("ran.txt","r");// 此处只是读取,所以模式为r
//调整对象中的指针
//raf.seek(8);
//跳过指定的字节数(只能往后跳,不能往前跳)
raf.skipBytes(8);
byte[] byt=new byte[4];
//读取
raf.read(byt);
String name=new String(byt);
int age=raf.readInt();
System.out.println("name="+name);
System.out.println("age="+age);
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
try
{
if(raf!=null)
raf.close();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
//使用RandomAccessFile的写入功能
public static void writeFile()
{
RandomAccessFile raf=null;
try
{
raf=new RandomAccessFile("ran.txt","rw"); //模式为读写模式
raf.write("李四".getBytes());
raf.writeInt(97);
raf.write("张三".getBytes());
raf.writeInt(99);
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
try{
if(raf!=null)
raf.close();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
}
四、操作基本数据类型(DataInputStream和DataOutputStream)
构造方法
DataInputStream(InputStream in) 使用指定的底层 InputStream 创建一个 DataInputStream。
import java.io.*;
class DataStreamDemo
{
public static void main(String[] args)
{
//writeData();
//readData();
//writeUTFDemo();
readUTFDemo();
}
//读取UTF-8修订版编码的数据
public static void readUTFDemo()
{
DataInputStream dis=null;
try
{
dis=new DataInputStream(new FileInputStream("utf.txt"));
String s=dis.readUTF();
System.out.println(s);
}
catch(IOException e)
{
throw new RuntimeException("读取失败");
}
finally
{
try{
if(dis!=null)
dis.close();
}
catch(IOException e)
{
throw new RuntimeException("读取失败");
}
}
}
//使用的是UTF-8修订版将数据写入数据(UTF-8修订版每个汉字占4个字节)
//使用UTF-8修订版写入的数据也必须要用UTF-8修订版来读取
public static void writeUTFDemo()
{
DataOutputStream dos=null;
try
{
dos=new DataOutputStream(new FileOutputStream("utf.txt"));
dos.writeUTF("你好"); //使用的是UTF-8修订版
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
try
{
if(dos!=null)
dos.close();
}
catch(IOException e)
{
throw new RuntimeException("写入失败!");
}
}
}
//读取
public static void readData()
{
DataInputStream dis=null;
try
{
//读取流对象
dis=new DataInputStream(new FileInputStream("data.txt"));
int i=dis.readInt();//读取Int类型
boolean b=dis.readBoolean();
double d=dis.readDouble();
System.out.println("int="+i+",boolean="+b+",double="+d);
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
try{
if(dis!=null)
dis.close();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
//写入数据
public static void writeData()
{
DataOutputStream dos=null;
try
{
//创建基本数据类型操作类的对象
dos=new DataOutputStream(new FileOutputStream("data.txt "));
dos.writeInt(234);//写入Int类型(与OutputStream的write区别在于,write是将int类型的最后八位写进去,而这里是写入32位)
dos.writeBoolean(true);
dos.writeDouble(955.355);
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
try{
if(dos!=null)
dos.close();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
}
五、对数组进行操作的流对象
用于操作字节数组的流对象
ByteArrayInputStream:在构造的时候,需要接收数据源,而且数据源是一个字节数组。
构造函数:ByteArrayInputStream(byte[] buf)
ByteArrayInputStream(byte[] buf, int offset, int length)
ByteArrayOutputStream:在构造的时候,不用定义数据目的,因为该对象中已经内部封装了可变长度的字节数组。
这就是数据目的地。因为这两个流对象都是操作的数组,并没有使用系统资源。所以,不用进行close关闭。
在流操作规律讲解时:
源设备:键盘 System.in, 硬盘 FileStream 内存 ArrayStream
目的设备:
控制台:System.out 硬盘 FileStream 内存 ArrayStream
用流的读写思想来操作数组
ByteArrayInputStream:在构造的时候,需要接收数据源,而且数据源是一个字节数组。
构造函数:ByteArrayInputStream(byte[] buf)
ByteArrayInputStream(byte[] buf, int offset, int length)
ByteArrayOutputStream:在构造的时候,不用定义数据目的,因为该对象中已经内部封装了可变长度的字节数组。
这就是数据目的地。因为这两个流对象都是操作的数组,并没有使用系统资源。所以,不用进行close关闭。
在流操作规律讲解时:
源设备:键盘 System.in, 硬盘 FileStream 内存 ArrayStream
目的设备:
控制台:System.out 硬盘 FileStream 内存 ArrayStream
用流的读写思想来操作数组
还有其他的:
CharArrayReader 和 CharArrayWriter 操作字符数组的流对象,同理,CharArrayReader的源是一个字符数组 char[] ,CharArrayWriter 内部封装有一个字符数组
StringReader 和 StringWriter 操作字符串的流对象 StringReader 的源是一个字符串
CharArrayReader 和 CharArrayWriter 操作字符数组的流对象,同理,CharArrayReader的源是一个字符数组 char[] ,CharArrayWriter 内部封装有一个字符数组
StringReader 和 StringWriter 操作字符串的流对象 StringReader 的源是一个字符串
代码(演示ByteArrayOutputStream)
import java.io.*;
class ByteArrayStream
{
public static void main(String[] args)
{
//数据源(数据源是一个字节数组)
ByteArrayInputStream bis=new ByteArrayInputStream("呵呵".getBytes());
//数据目的
ByteArrayOutputStream bos=new ByteArrayOutputStream();
int len=0;
while((len=bis.read())!=-1)
{
bos.write(len);
}
System.out.println(bos.toString());
//writeTo(OutputStream os)
//同样可以将一个OutputStream作为目的
bos.writeTo(new FileOutputStream("test.txt"));
}
}
六、字符编码
A、字符流的出现是为了方便操作字符
B、更重要的是加了编码转换。
C、通过子类转换流来完成
InputStreamReader
OutputStreamWriter
D、在两个对象进行构造的时候可以加入字符集
编码表的由来:
1、计算机只能识别二进制数据,早期由来是电信号
2、为了方便应用计算机,让它可以识别各个国家的文字。
3、就将各个国家的文字用数字来表示,并一一对应,形成一张表,即编码表。
B、更重要的是加了编码转换。
C、通过子类转换流来完成
InputStreamReader
OutputStreamWriter
D、在两个对象进行构造的时候可以加入字符集
编码表的由来:
1、计算机只能识别二进制数据,早期由来是电信号
2、为了方便应用计算机,让它可以识别各个国家的文字。
3、就将各个国家的文字用数字来表示,并一一对应,形成一张表,即编码表。
编码:字符串变成字节数组
String-->byte[]: str.getBytes(charsetName);
解码:字节数组变成字符串
byte[]-->String: new String(byte[],charsetName );
解码:字节数组变成字符串
byte[]-->String: new String(byte[],charsetName );
用什么编码格式编的码,就用相应的格式解码。如,用UTF-8编码,就得用UTF-8解码
如:
import java.util.*;
import java.io.*;
class EncodeDemo
{
public static void main(String[] args) throws Exception
{
writeText() ;
readText();
}
//解码:字节数组变成字符串
public static void readText()
{
InputStreamReader isr=null;
try
{
isr=new InputStreamReader(new FileInputStream("utf.txt"),"utf-8");
char[] buf=new char[1024];
int len=0;
while((len=isr.read(buf))!=-1)
{
String s=new String(buf,0,len);
System.out.println(s);
}
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
try{
if(isr!=null)
isr.close();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
public static void writeText() throws IOException
{
//使用UTF-8格式编码。(只能用UTF-8来解码)
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("utf.txt"),"utf-8");
osw.write("你好");
osw.close();
}
}
结果:
如果编码的时候使用UFT-8,解码的时候使用GBK,结果:
可以看出,两个结果完全不同,这是因为当我们解码的时候,将字节拿到GBK编码表中查表的时候,出来的就是上图中的几个字符。
再看另一个例子:
import java.util.*;
import java.io.*;
class EncodeDemo
{
public static void main(String[] args) throws Exception
{
String s="你好";
byte[] b1=s.getBytes(); //编码:字符串变成字节数组(默认是GBK)
System.out.println(Arrays.toString(b1));
String s1=new String(b1,"ISO8859-1"); //解码:字节数组变成字符串
System.out.println(s1);//解码后的字符串
//对s1进行ISO8859-1编码
byte[] b2=s1.getBytes("ISO8859-1");
System.out.println(Arrays.toString(b2));
String s2=new String(b2,"gbk"); //再用GBK解码
System.out.println(s2);
}
}
结果:
其编码解码过程如图:
好了,IO包中的其他类就到这里了