Java上路19-I/O-常用类

一. 对象序列化：

Java对象序列化将那些实现了Serializable接口的对象转换成一个字节序列，并能够以后将这个字节序列完全恢复为原来的对象。利用对象的序列化，可以实现轻量级持久性，这意味着一个对象的生存周期并不取决于程序是否正在执行，它可以生存于程序的调用之间。通过将一个序列化对象写入磁盘，然后在重新调用程序时恢复该对象，就能够实现持久性的效果。ObjectOutputStream / ObjectInputStream 。

测试类：

import java.io.*;
 
//类通过实现Serializable接口以启用其序列化功能
class Test implements Serializable
{
       private String name;
       private boolean used;
       static int age;       //静态的不可被序列化
       transient intsex;  //声明为不可序列化的成员
 
       public static final long serialVersionUID = 43L;       //自定义的UID
 
       Test(String name, boolean used, int age, int sex)
       {
              this.name=name;
              this.used=used;
              this.age=age;
              this.sex=sex;
       }
 
       public StringtoString()
       {
              return "Name : "+name+", usefull : "+used+", age :"+age+", sex : "+sex;
       }
}

操作类：

import java.io.*;
 
class FileDemo
{
       public static void main(String[] args) throws Exception
       {
              //writeObj();
              readObj();
       }
 
       public static void writeObj() throws Exception
       {
              ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("obj.txt"));      //将对象序列化后的数据保存在txt文件
              oos.writeObject(newTest("Test", true, 24, 1));      //写入目标对象
              oos.close();
       }
 
       public static void readObj() throws Exception
       {
              ObjectInputStream ois=new ObjectInputStream(new FileInputStream("obj.txt")); //读取现有的数据反序列化
              Test test=(Test)ois.readObject();      //实例化序列中的对象
              System.out.println(test);
              ois.close();
       }
}

首先编译Test类，然后开启操作类的writeObj()方法注释readObj()方法编译执行，再注释writeObj()方法开启readObj()方法编译执行。如果已经有了一个序列化的文件，可以只有读取的方法。

 

二. 管道流：

       管道，它具有将一个程序的输出当作另一个程序的输入的能力。在Java中，可以使用管道流进行线程之间的通信，输入流和输出流必须相连接，不需要共享的数据空间。涉及多线程。

字节流：PipedOutputStream和PipedInputStream

字符流：PipedWriter和PipedReader

import java.io.*;
 
class Read implements Runnable
{
       private PipedInputStream in;     //管道读取
 
       Read(PipedInputStream in)
       {
              this.in=in;
       }
 
       public voidrun()
       {
              try
              {
                     byte[]buf=new byte[1024];
                     int len=(in.read(buf));
                     String s=new String(buf, 0, len);
                     System.out.println(s);
                     in.close();
              }
              catch(IOException e)
              {
                     thrownew RuntimeException("管道流读取失败");
              }
       }
}
 
class Write implements Runnable
{
       private PipedOutputStream out;       //管道写入
 
       Write(PipedOutputStream out)
       {
              this.out=out;
       }
 
       public voidrun()
       {
              try
              {
                     out.write("管道接通".getBytes());
              }
              catch(IOException e)
              {
                     thrownew RuntimeException("管道流写入失败");
              }
       }
}
 
class PipelineDemo
{
       public static void main(String[] args) throws IOException
       {
              PipedInputStream in=new PipedInputStream();
              PipedOutputStream out=new PipedOutputStream();
              in.connect(out);
              Read r=new Read(in);
              Write w=new Write(out);
              newThread(r).start();
              newThread(w).start();
       }
}

三. RandomAccessFile：

       此类的实例支持对随机访问文件的读取和写入。如果模式为r，不会创建文件，而是读取已存在的文件；如果不存在则发生异常。如果模式为rw，当文件不存在时自动创建；如果存在，将直接读取修改。

import java.io.*;
 
class RafDemo
{
       public static void main(String[] args) throws IOException
       {
              //writeFile();
              readFile();
       }
 
       public static void writeFile() throws IOException
       {
              RandomAccessFile raf=new RandomAccessFile("obj.txt", "rw");
              raf.write("hello".getBytes());
              raf.writeInt(48);
              raf.write("wod".getBytes());
              raf.writeInt(48);
              raf.close();
       }
 
       public static void readFile() throws IOException
       {
              RandomAccessFile raf=new RandomAccessFile("obj.txt", "r");
              //raf.seek(8); //从第8位开始读取
              raf.skipBytes(8);   //跳过前8位
              byte[]buf=new byte[5];     //一次读取5个字节
              raf.read(buf);
              String name=new String(buf);
              System.out.println("name"+name);
              raf.close();
       }
}

四. DataStream：

       可以用于操作基本数据类型的数据的流对象。

import java.io.*;
 
class RafDemo
{
       public static void main(String[] args) throws IOException
       {
              //write();
              read();
       }
 
       public static void write() throws IOException
       {
              DataOutputStream dos=new DataOutputStream(new FileOutputStream("obj.txt"));
              dos.writeInt(520);
              dos.writeBoolean(true);
              dos.writeDouble(2340.2340);
              dos.writeUTF("Java上路系列");
              dos.close();
       }
 
       public static void read() throws IOException
       {
              DataInputStream dis=new DataInputStream(new FileInputStream("obj.txt"));
              int i=dis.readInt();
              boolean b=dis.readBoolean();
              double d=dis.readDouble();
              String s=dis.readUTF();
              dis.close();
              System.out.println(i+","+b+", "+d+", "+s);
       }
}

五. 字节数组：

用于操作字节数组的流对象

import java.io.*;
 
class RafDemo
{
       public static void main(String[] args) throws IOException
       {
              //s数据源
              ByteArrayInputStream bis=new ByteArrayInputStream("66666ABCDEF".getBytes());
              //数据目的
              ByteArrayOutputStream bos=new ByteArrayOutputStream();
 
              intby=0;
              while((by=bis.read())!=-1)
              {
                     bos.write(by);
              }
 
              System.out.println(bos.size());
              System.out.println(bos.toString());
       }
}