黑马程序员_JAVA_IO（三）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、对象序列化        

       将堆内存中的对象存入硬盘，保留对象中的数据，称之为对象的持久化（或序列化）。

常用到的两个类：ObjectInputStream和ObjectOutputStream。
被操作的对象需要实现Serializable接口（也称标记接口)
 
关于Serializable接口：
        1、接口Serializable中没有方法，称之为标记接口
        2、序列化运行时使用一个称为 serialVersionUID的版本号与每个可序列化类相关联，用于验证序列化对象的发送者和接收者是否为同一对象。如果接收者加载的该对象的类的 serialVersionUID与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。
             public static final long serialVersionUID = 42L;

注意：1、静态成员不能被序列化，因为静态在方法区，序列化只能对堆内的对象进行序列化。

             2、非静态成员要不被序列化，可以用关键字transient修饰，保证非静态成员保存在堆内存中，不能存入文件中。

import java.io.*;class Peason implements Serializable {// 自定义serialVersionUID版本号public final static long serialVersionUID = 32L;private String name;transient int age;// 使用transient关键字表示该成员不被序列化static String country = "CN";// 静态成员不能序列化// 构造函数Peason(String name, int age) {this.name = name;this.age = age;}// 复写toString方法public String toString() {return name + ":" + age + ":" + country;}}// 序列化测试类class ObjectStreamDemo {public static void main(String[] args) {// 指定文件File file = new File("obj.txt");Peason p = new Peason("zhangsan", 25);// 序列化指定对象writeObj(p, file);// 反序列化readObj(file);}// 将指定对象序列化到指定文件中public static void writeObj(Peason p, File file) {ObjectOutputStream oos = null;try {// 创建写入流对象，关流文件oos = new ObjectOutputStream(new FileOutputStream(file));oos.writeObject(p);// 写入对象数据} catch (IOException e) {throw new RuntimeException("对象写入失败");} finally {try {if (oos != null)oos.close();} catch (IOException e) {throw new RuntimeException("关流失败");}}}// 读取指定文件中的对象，也称反序列化public static void readObj(File file) {ObjectInputStream ois = null;try {// 创建读取流对象，关联文件ois = new ObjectInputStream(new FileInputStream(file));// 读取文件中的对象Peason p = (Peason) ois.readObject();System.out.println(p);} catch (Exception e) {throw new RuntimeException("文件读取对象失败");} finally {try {if (ois != null)ois.close();} catch (IOException e) {throw new RuntimeException("关流失败");}}}}

二、管道流( PipedInputStream和PipedOutputStream )
特点：
         1、输入输出可以直接进行连接，不用再借助数组或集合等容器进行临时存储。     
         2、一般结合多线程使用。通常，数据由某个线程写入PipedOutputStream对象，并由其他线程从连接的 PipedInputStream 读取。
 
操作步骤：
        1、要先创建一个读和写的两个类，实现Runnable接口，因为是两个不同的线程，覆盖run方法，注意，需要在内部处理异常。
        2、创建两个管道流，并用connect()方法将两个流连接
        3、创建读写对象，并传入两个线程内，并start执行。

import java.io.*;class PipedStreamDemo {public static void main(String[] args) {try {// 创建管道流对象，并关联PipedInputStream in = new PipedInputStream();PipedOutputStream out = new PipedOutputStream();in.connect(out);// 启动线程new Thread(new Read(in)).start();new Thread(new Write(out)).start();} catch (IOException e) {throw new RuntimeException("管道流关联失败");}}}// 读取线程class Read implements Runnable {private PipedInputStream in;Read(PipedInputStream in) {this.in = in;}// 覆盖run方法public void run() {try {// 用来存储读到的字节byte[] by = new byte[1024];System.out.println("读取前。。没有数据阻塞");// 读取流中数据int len = in.read(by);System.out.println("读到数据。。阻塞结束");// 将字节数组转换为字符串打印输出String s = new String(by, 0, len);System.out.println(s);} catch (IOException e) {throw new RuntimeException("读取数据失败");} finally {try {if (in != null)in.close();} catch (IOException e) {throw new RuntimeException("流关闭失败");}}}}// 写线程class Write implements Runnable {private PipedOutputStream out;Write(PipedOutputStream out) {this.out = out;}// 覆盖run方法public void run() {try {System.out.println("开始写入数据，等待3秒后。");Thread.sleep(3000);// 写入数据到管道流中out.write("piped shi shem ma?".getBytes());} catch (Exception e) {throw new RuntimeException("写入数据失败");} finally {try {if (out != null)out.close();} catch (IOException e) {throw new RuntimeException("流关闭失败");}}}}

三、RandomAccessFile类

        1、RandomAccessFile此类的实例支持对随机访问文件的读取和写入，自身具备读写方法。

        2、该类不算是IO体系中的子类，而是直接继承Object，但是它是IO包成员，因为它具备读写功能，内部封装了一个数组，且通过getFilePointer方法获取指针位置，来对数组的元素进行操作，同时可通过seek方法改变指针的位置。

        3、可以完成读写的原理：内部封装了字节输入流和输出流。

        4、构造函数：RandomAccessFile(File file,String mode)

注意：1、如果模式为只读r，则不会创建文件，会去读一个已存在的文件，若文件不存在，则会出现异常。

    2、如果模式为读写rw，且该对象的构造函数要操作的文件不存在，会自动创建；如果存在，则不会覆盖。

 

特有方法：

        1、seek(long pos)：//调整对象中指针。来进行指定位置的数据读取和写入。数据要有规律。如果设置的指针位置已有数据，写入时将会将其修改。用seek可以表示随机读写访问。

        2、int skipBytes(int n)：跳过指定字节数，不可往前跳

 RandomAccessFile中也有对基本数据类型进行读写的方法。还有readLine方法。

//需求：使用RandomAccessFileDemo进行读写操作import java.io.*;public class RandomAccessFileDemo {public static void main(String[] args) throws IOException {// 指定文件File file = new File("1.txt");// 写数据writeFile(file);// 读数据readFile(file);}// 读取指定文件中的数据public static void readFile(File file) throws IOException {// 创建对象RandomAccessFile raf = new RandomAccessFile(file, "r");// 设置指针位置raf.seek(4);// 设置跳过的字节数// raf.skipBytes(8);// 读取四个字节存入byte[] by = new byte[4];// 读数据raf.read(by);// 将存入数据的字节数组转换为字符串String str = new String(by);raf.close();// 关流System.out.println("str=" + str);}// 将数据写入指定文件中public static void writeFile(File file) throws IOException {// 创建对象RandomAccessFile raf = new RandomAccessFile(file, "rw");raf.write("abcdefghigk".getBytes());raf.close();// 关流}}

四、操作基本数据类型的流对象( DataStream )

        1、操作基本数据类型的流对象：DataInputStream和DataOutputStream

        2、这两个读写对象，可用于操作基本数据类型的流对象，包含读写各种基本数据类型的方法。

 

String readUTF();//对应writeUTF，读取以UTF-8修改版编码写入的字符串

writeUTF(String str);//以与机器无关方式使用UTF-8修改版编码将一个字符串写入基础输出流。

五、操作数组与字符串的流

        1、ByteArrayInputStream：在构造函数的时候，需要接受数据源，而且数据源是一个字节数据。

        2、ByteArrayOutputStream：在构造函数的时候，不用定义数据目的，因为该对象中已经在内部封装了可变长度的字节数组，这就是数据的目的地。

ByteArrayOutputStream中特有方法：

        writeTo(OutputStream out);//将此 byte 数组输出流的全部内容写入到指定的输出流参数中

        int size();//当前缓冲区的大小

        String toString();//使用平台默认的字符集，通过解码字节将缓冲区内容转换为字符串

 注意：1、这个对象并没有调用底层资源，所以不用关闭流资源，即使关闭后，仍可调用。 

     2、内部包含缓冲区，相当于以内存作为流操作源和目的，不会产生任何IO异常。 

     3、因为writeTo(OutputStream out)这个方法用到了字节输出流，需要抛IO异常，也是字节数组流中唯一需要抛异常的方法。

对应的字符数组和字符串

        字符数组流：CharArrayReader和CharArrayWriter

        字符串流：   StringReader和StringWriter

//使用IO中操作字节数组的流对象读写数据import java.io.*;class ByteArrayStreamDemo {public static void main(String[] args) {// 创建一个byte数组输入流，数据源ByteArrayInputStream bais = new ByteArrayInputStream("ABCDEFG".getBytes());// 创建一个新的byte数组输出流，数据目的ByteArrayOutputStream baos = new ByteArrayOutputStream();int by = 0;while ((by = bais.read()) != -1) {// 写入数据baos.write(by);}// 输出数据长度System.out.println(baos.size());// 以字符串输出数据System.out.println(baos.toString());try {// 调用此方法时，需要抛出异常baos.writeTo(new FileOutputStream("writeTo.txt"));} catch (IOException e) {throw new RuntimeException("数据写入文件失败");}}}

六、字符编码

1、字符流的出现为了方便操作字符。

2、更重要的是加入了编码的转换，即转换流。

3、通过子类转换流来完成。在两个对象进行构造的时候，可以加入字符集（即编码表），可传入编码表的有：

        1、转换流：InuputStreamReader和OutputStreamWriter

        2、打印流：PrintStream和PrintWriter，只有输出流

常见的编码表：

        1）ASCII：美国标准信息交换码表。用一个字节的7位表示

        2）IOS8859-1：拉丁码表；欧洲码表。用一个字节的8位表示

        3）GB2312：中国的中文编码表（）早期

        4）GBK：中国的中文编码表升级，融合了更多的中文文字字符。打头的是两个高位为1的两个字节编码。为负数

        5）Unicode：国际标准码，融合了多种文字。所有文字都用两个字节来表示,Java语言使用的就是unicode。

        6）UTF-8：最多用三个字节表示一个字符的编码表，根据字符所占内存空间不同，分别用一个、两个、三个字节来编码。

注意： 1、如果编码失败，解码就没意义了。

              2、如果编码成功，解码出来的是乱码，则需对乱码通过再次编码（用解错码的编码表），然后再通过正确的编码表解码。针对于IOS8859-1是通用的。

              3、如果用的是GBK编码，UTF-8解码，此时通过再次编码后解码的方式，就不能成功了，因为UTF-8也支持中文，在UTF-8解的时候，会将对应的字节数改变，所以不会成功。