I/O操做总结（四））

前面已经把java io的主要操作讲完了

这一节我们来说说关于java io的其他内容

Serializable序列化

实例1：对象的序列化


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

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectOutputStream;

import java.io.Serializable;

@SuppressWarnings("serial")

//一个类要想实现序列化则必须实现Serializable接口

class Person implements Serializable {

    private String name;

    private int age;

    

    public Person(String name, int age) {

        this.name = name;

        this.age = age;

    }

    

    public String toString() {

        return "Name:" + this.name + ", Age:" + this.age;

    }

}

public class Demo {

    public static void main(String[] args) {

        String path = File.separator + "home" + File.separator + "siu" +

                      File.separator + "work" + File.separator + "demo.txt";

        

        Person p1 = new Person("zhangsan",12);

        Person p2 = new Person("lisi",14);

        

        //此处创建文件写入流的引用是要给ObjectOutputStream的构造函数玩儿

        FileOutputStream fos = null;

        ObjectOutputStream oos = null;

        try {

            fos = new FileOutputStream(path);

            oos = new ObjectOutputStream(fos);

            

            //这里可以写入对象，也可以写入其他类型数据

            oos.writeObject(p1);

            oos.writeObject(p2);

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            try {

                oos.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

}

所谓对象序列化就是把一个对象进行持久化存储，方便保留其属性

通俗点说，等于把一个对象从堆内存里边揪出来放到硬盘上

当然，如果你开心，你可以序列化其他东西，包括数组，基本数据类型等等

来看看内容，神马玩意儿这是……

实例2：对象的反序列化


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

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

public class Demo {

    public static void main(String[] args) {

        String path = File.separator + "home" + File.separator + "siu" +

                      File.separator + "work" + File.separator + "demo.txt";

        

        //好吧，这里代码写得着实有点长了，还要抛异常什么的

        //如果你也看的烦，那就在主方法上抛吧，构造方法里用匿名对象就好了

        //什么？别告诉我你不知道匿名对象

        FileInputStream fis = null;

        ObjectInputStream ois = null;

        try {

            fis = new FileInputStream(path);

            ois = new ObjectInputStream(fis);

            

            //这里返回的其实是一个Object类对象

            //因为我们已知它是个Person类对象

            //所以，就地把它给向下转型了

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

            System.out.println(p);

            

            //抛死你，烦烦烦～！！！

        } catch (IOException e) {

            e.printStackTrace();

        } catch (ClassNotFoundException e) {

            e.printStackTrace();

        } finally {

            try {

                //还是要记得关闭下流

                ois.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

}

你看，我们把一个对象存放在硬盘上是为了方便日后使用

现在用得着它了，自然得拿出来

管道流

实例3：线程的通信


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

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

import java.io.IOException;

import java.io.PipedInputStream;

import java.io.PipedOutputStream;

//实现Runnable接口，实现一个读的线程

class Read implements Runnable {

    private PipedInputStream in;

    //将需要读的管道流传入到构造函数中

    public Read(PipedInputStream in) {

        this.in = in;

    }

    

    //实现读这一线程

    public void run() {

        try {

            byte[] buf = new byte[1024];

            int temp = 0;

            //循环读取

            //read是一个阻塞方法，需要抛异常

            //此处把打印流的代码也加入进来

            //是因为如果没有读取到数据，那么打印的代码也无效

            while((temp = in.read(buf)) != -1) {

                String str = new String(buf,0,temp);

                System.out.println(str);

            }

        } catch (IOException e) {

            //其实这里应抛出一个自定义异常的

            //暂时我还没弄清楚

            e.printStackTrace();

        } finally {

            try {

                //我已经抛火了，这只是为了提醒自己异常很重要

                in.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }  

}

//这里实现一个写的类

class Write implements Runnable {

    private PipedOutputStream out;

    //将管道输入流传进来

    public Write(PipedOutputStream out) {

        this.out = out;

    }

    public void run() {

        try {

            //这里开始写出数据

            out.write("管道输出".getBytes());

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            try {

                //其实应该可以把这个关闭方法写到上面那个try里边

                //但是这样感觉怪怪的，逻辑不大对

                out.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

}

public class Demo {

    public static void main(String[] args) {

        PipedInputStream in = new PipedInputStream();

        PipedOutputStream out = new PipedOutputStream();

        try {

            //连接管道

            in.connect(out);

            

            //创建对象，开启线程

            //此处同样放进try...catch里面

            //因为如果没有链接管道，下面操作无意义

            Read r = new Read(in);

            Write w = new Write(out);

            //把已经实现好run方法的对象放入线程中执行

            new Thread(r).start();

            new Thread(w).start();

            

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

好吧，废了那么大劲儿，就打印了这么一句话，异常抛弃来很烦，为了注重细节……

管道流也许很难理解，其实非也

我们知道，字节流和字符流都需要数组来进行流的中转

而管道流则直接串联两条流，一边发送数据，一边接收

然而，同时通信的的两种状态，如何才能确定发送和接收的一致性呢

那么，就需要用到线程，无论是接收方还是发送方先执行

总会造成一个线程的阻塞状态，从而等待另一方的数据传过来

总体而言，管道流的目的，也就是为了线程通信

此外，还有PipedReader和PipedWriter类，操作原理都一样，这里就不再赘述了

DataOutputStream和DataInputStream类

实例4：基本数据类型的写入


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

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

public class Demo {

    public static void main(String[] args) {

        String path = File.separator + "home" + File.separator + "siu" +

                      File.separator + "work" + File.separator + "demo.txt";

        

        DataOutputStream d = null;

            try {

                //此处需要传入一个OutputStream类的对象

                d = new DataOutputStream(new FileOutputStream(path));

                //开始写入基本数据类型

                d.writeInt(12);

                d.writeBoolean(true);

                d.writeDouble(12.2223);

                d.writeChar(97);

                //刷新流

                d.flush();

    

            } catch (IOException e) {

                e.printStackTrace();

            } finally {

                try {

                    d.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

    }

}

此处我们并不能直观看懂内容，因为它采用字节流的方式操作，而不是字符流

我们只需要知道，此程序已经将基本数据类型写入到硬盘即可

实例5：基本数据类型的读取


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

import java.io.DataInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

public class Demo {

    public static void main(String[] args) {

        String path = File.separator + "home" + File.separator + "siu" +

                      File.separator + "work" + File.separator + "demo.txt";

        

        DataInputStream d = null;

            try {

                d = new DataInputStream(new FileInputStream(path));

                //按存储顺序读取基本数据类型

                System.out.println(d.readInt());

                System.out.println(d.readBoolean());

                System.out.println(d.readDouble());

                System.out.println(d.readChar());

                

            } catch (IOException e) {

                e.printStackTrace();

            } finally {

                try {

                    d.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

    }

}

这里要注意的是，一定要按照写入顺序读取，否则会发生数据的打印错误

时间： 2024-10-14 19:03:04

I/O操做总结（四））的相关文章

expdb 操做方法

expdp system/oracle directory=DB_BAK dumpfile=zhzy.dmp schemas=zhzy expdp system/SYSTEM directory=DB_BAK dumpfile=sde__zyyh_zhzy.dmp schemas=(sde,zyyh,zhzy) logfile=expdp_all.log expdp system/SYSTEM directory=DB_BAK dumpfile=sde__zyyh_zhzy.dmp schema

你的一生不用瞎忙 只要做对四件事

第一件事:找对平台 无论你是才华横溢,还是草根布衣,你只有把自己放对了地方,你才会有正念正见正语正行,因为,人是环境的产物. 第二件事:交对朋友 物以类聚,人与群分,你的一生中要么影响别人,要么被人影响,当你还是处在社会底层的时候被人影响非常重要也十分必要,关键是你被谁在影响,你是否经常被一些与你同层次的人弄的人云亦云的,经常被人消极的催眠呢?请记住,跟谁交朋友,将决定你的一生可能跟谁一样! 第三件事:跟对贵人 先有伯乐,才有千里马.人是可以被教育的,前提是,你的伯乐在哪里?他是谁?他能让你成为

文本操做小结

文本操做: 对文件操作流程: 1. 打开文件,得到文件句柄并赋值给一个变量 2. 通过句柄对文件进行操作 3. 关闭文件  data = open("file").read() print(data)  fs = open("yesterday","r", encoding="utf-8")         #fs即文件句柄 data = fs.read()          #从头开始一行一行读文件内容,然后指针到了最后. 

在职场上，千万不要做这四种人

来郴州找工作的人越来越多,形成了职场竞争力的加剧,让很多在职人员都很没有安全感,想要过得比较轻松呢,就只能做一辈子底层,这类人在生活工作方面是比较安逸,但是如果公司出现什么裁员,你就会成为第一个.你要保持住这个职位,就必须要凸显出自己的价值来. 不做职场中的“龙套”的首要条件,就是胸怀大志.首先,想要在职场上做大事的人,你必定要有个目标,而且要先从小事做起.目标很重要,比如说你想要成为销售经理,就必须从普通的销售业务开始做,你有个一个伟大的目标是好事,但是千万不要暴露出太多缺点,要不然,没等你目

I/O流操做总结（三）

说实话,其实我并不是很喜欢Java这门语言,尽管它很强大,有很多现成的API可以调用 但我总感觉它把简单的事情弄得太过复杂,甚至有时候会让人迷失 弄不清到底是为了写出东西,还是为了语言本身 我学习的第一门编程语言是Python,虽然学的不深 但是它的简单优雅至今令人难忘(呃,其实也就两年前的事--) 我接触的第二门语言是C,它给我的感觉是一种纯粹,一种高效的灵活 而不是类似java,写一堆含糊的代码来实现一个小小的功能 坦白讲,如果一个人在学习自己不感兴趣的东西,那会很累 支撑我的是,我对移动开

I/O操做总结（二）

文件的操作 这一节我们来讨论关于文件自身的操作 不浪费唾沫了,用代码说话-- 实例1:创建文件对象 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 import java.io.File; public class Demo {     public static void main(String[] args) {         //创建要操作的文件路径和名称    

数据库基本操做

linux数据库基本操作1.准备软件仓库目录[[email protected] ~]# mkdir /mnt/dvd[[email protected] ~]# mount /dev/cdrom /mnt/dvdmount: /dev/sr0 写保护,将以只读方式挂载[[email protected] ~]# mkdir /root/cos[[email protected] ~]# cp -fr /mnt/dvd/* /root/cos 2.设置yum软件源[[email protecte

Django-ORM 多对多基本操做！

多对多和外键一样正向反向查找,一样可以创建related_name ,,,,,,,正向查找用双下划线__          反向查找用 related_name加.  进行查找 原文地址:https://www.cnblogs.com/lhqlhq/p/9153719.html

基本数据类型扩展，及字符串的操做（切片，记忆希望字符串的基本操作）

?.python基本数据类型 1. int ==> 整数. 主要?来进?数学运算 2. str ==> 字符串, 可以保存少量数据并进?相应的操作 3. bool==>判断真假, True, False 4. list==> 存储?量数据.?[ ]表? 5. tuple=> 元组, 不可以发?改变 ?( )表? 6. dict==> 字典, 保存键值对, ?样可以保存?量数据 7. set==> 集合, 保存?量数据. 不可以重复. 其实就是不保存value的di