Java流的体系结构（二）

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、对象流的使用

1.概念

1.ObjectInputStream和ObjectOutputStream
2.作用：用于存储和读取基本数据类型数据或对象的处理流
3.要想一个java对象是可序列化的，需要满足相应的要求。

1.需要实现接口：Serializable
2.当前类提供一个全局常量：serialVersionUID
3.处理当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的（默认情况下，基本数据类型可序列化）

补充：.ObjectInputStream和ObjectOutputStream不能序列化static和transient修饰的成员变量。

1
2
3
4
5
6

2.序列化机制

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

3.代码案例：序列化过程：将内存中的java对象保存到磁盘中或通过通络传输出去

//序列化过程：将内存中的java对象保存到磁盘中或通过通络传输出去
    //使用ObjectOutputStream实现
    @Test
    public void testObjectOutputStream(){
        ObjectOutputStream oos = null;
        try{
             oos = new ObjectOutputStream(new FileOutputStream("object.dat"));

            oos.writeObject(new String("我爱北京天安门"));

            oos.flush();  //刷新操作

            oos.writeObject(new Person("姚玛丽",21));
            oos.flush();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(oos != null)
                    oos.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

4.反序列化，将磁盘文件中的对象还原为内存中的一个java对象

@Test
    public void testObjectInputStream(){
        ObjectInputStream ois = null;
       try{
           ois = new ObjectInputStream(new FileInputStream("object.dat"));

           Object obj = ois.readObject();
           String str = (String)obj;

           Person p = (Person)ois.readObject();

           System.out.println(str);
           System.out.println(p);
       }catch(IOException e){
           e.printStackTrace();
        } catch (ClassNotFoundException e) {
           e.printStackTrace();
       } finally {
           try{
               if(ois != null)
                   ois.close();
           }catch(IOException e){
               e.printStackTrace();
           }
       }

    }

public class Person implements Serializable {

    public static final long sericlVersionUID = 45866454556L;

    private String name;
    private int age;

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }

    public String toString(){
        return "Person{" +
                "name='"+name+'\''+
                ",age="+age;
    }

    public Person(){

    }

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }


}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

二、RandomAccessFile的使用

1.说明

1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建，如果写出到的文件存在，则会对原有文件内容进行覆盏。（默认情况下，从头覆盖)
4.可以通过相关的操作，实现RandomAccessFile“插入”数据的效果

2.代码案例

public void test1() throws FileNotFoundException {

        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;

        try{
            raf1 = new RandomAccessFile(new File("2.jpg"),"r");
            raf2 = new RandomAccessFile(new File("3.jpg"),"rw");

            byte[] buffer = new byte[1024];
            int len;
            while((len = raf1.read(buffer))!=-1){
                raf2.write(buffer,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(raf1!=null){
                try{
                    raf1.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
            if(raf2!=null){
                try{
                    raf2.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public void test2() throws  IOException{

        RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");

        raf1.seek(3);  //将指针调到角标为3的位置
        raf1.write("xyz".getBytes());

        raf1.close();
    }

1
2
3
4
5
6
7
8
9
10

//使用RandomAccessFile实现数据的插入效果
    @Test
    public void test3() throws  IOException{

        RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");

        raf1.seek(3);  //将指针调到角标为3的位置
        //保存指针3后面的所有数据到StringBuilder中
        StringBuilder builder = new StringBuilder((int)new File("hello.txt").length());
        byte[] buffer = new byte[20];
        int len;
        while((len = raf1.read(buffer)) != -1){
            builder.append(new String(buffer,0,len));
        }
        //调回指针，写入“xyz”
        raf1.seek(3);
        raf1.write("xyz".getBytes());

        //将StringBuilder中的数据写入到文件中
        raf1.write(builder.toString().getBytes());
        raf1.close();
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

---