IO（四）

最新推荐文章于 2021-06-07 20:21:00 发布
最新推荐文章于 2021-06-07 20:21:00 发布
阅读量301 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012467492/article/details/52973045
版权

前面已经把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();
                 }
             }
     }
}

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

pyj----
关注
专栏目录
io
hello~
01-26 667
io指的是数据从文件中读取或存入文件的操作，input output 以程序代码为核心，读文件中数据道程序中称为input,反之，为output 执行这些操作可以进行数据的存储，导入，完成数据存储，解决程序运行结束后数据消失的问题 1.file file类有方法open()\read()\write()等方法可以执行 open(para1,para2,para3):          ...
IO
weixin_44796253的博客
08-16 210
File -> 内存对象，表示文件/目录，和本地有没有这个文件/目录没关系 内存中创建一个file对象，和本地存不存在文件无关 java.io：input输入/读 output输出/写 文件单位：字节 人类读：字符编码 UTF-8 GBK 字节流：InputStream OutputStream 字符流：Reader...
java中的IO操作总结（四）
weixin_33964094的博客
12-17 86
前面已经把java io的主要操作讲完了 这一节我们来说说关于java io的其他内容   Serializable序列化 实例1：对象的序列化 import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; ...
JAVA的I/O操作（四）
翔宇.杨的技术仓库
10-28 881
 JAVA的I/O操作（四）RandomAccessFile此类的实例支持对随机访问文件的读取和写入。随机访问文件的行为类似存储在文件系统中的一个大型 byte 数组。存在指向该隐含数组的光标或索引，称为文件指针；输入操作从文件指针开始读取字节，并随着对字节的读取而前移此文件指针。如果随机访问文件以读取/写入模式创建，则输出操作也可用；输出操作从文件指针开始写入字节，并随着
java try后面括号的作用
豪猪的博客
01-31 1821
Java7新特性，支持使用try后面跟随（）括号管理释放资源 例如通常使用try代码块 1 try { 2 fis = new FileInputStream(source); 3 fos = new FileOutputStream(target); 4 5 byte[] buf = new byte[8
java中的IO操作总结（一）
weixin_30920597的博客
12-15 985
所谓IO，也就是Input与Output的缩写。在java中，IO涉及的范围比较大，这里主要讨论针对文件内容的读写 其他知识点将放置后续章节（我想，文章太长了，谁都没耐心翻到最后） 对于文件内容的操作主要分为两大类 分别是： 　　字符流 　　字节流 其中，字符流有两个抽象类：Writer Reader 其对应子类FileWriter和FileReader可实现文件的读写操作...
java里的ois是什么意思_什么？听说这四个概念，很多 Java 老手都说不清！
weixin_36241311的博客
02-28 556
Java 是很多人一直在用的编程语言，但是有些 Java 概念是非常难以理解的，哪怕是一些多年的老手，对某些 Java 概念也存在一些混淆和困惑。所以，在这篇文章里，会介绍四个 Java 中最难理解的四个概念，去帮助开发者更清晰的理解这些概念：匿名内部类的用法多线程如何实现同步序列化一、匿名内部类匿名内部类又叫匿名类，它有点像局部类(Local Class)或者内部类(Inner Class)，只...
3-IO输出-点亮多个LED灯方法1(51单片机C语言实例Proteus仿真和代码)
06-14
3-IO输出-点亮多个LED灯方法1(51单片机C语言实例Proteus仿真和代码)3-IO输出-点亮多个LED灯方法1(51单片机C语言实例Proteus仿真和代码)3-IO输出-点亮多个LED灯方法1(51单片机C语言实例Proteus仿真和代码)3-IO输出-...
JavaIO四大模型：NIO(IO多路复用)
Colorful_X的博客
06-07 1816
文章目录概述NIO涉及到的名词JavaNIO 服务端和客户端流程 概述         Java中的 Selector 和 Linux中的 epoll 都是基友IO多路复用的，有时也被称为异步阻塞IO。         我们之前介绍过，同步阻塞I/O和同步非阻塞IO。对于同步阻塞I/O来说，每次进行I/O时，我们的用户线程都会阻塞，显然这在高并发下效
51单片机IO口的四种使用方法
01-19
传统51单片机IO接口只可以作为标准双向IO接口，如果用其来驱动LED只能用灌电流的方式或是用三极管外扩驱动电路。　灌电流方式：LED正极接VCC，负极接IO口。IO为高电平是LED两极电平相同，没有电流，LED熄灭;IO为低电...
浅谈java IO流——四大抽象类
08-26
四、Writer Writer是字符输出流的父类，数据单位为字符。它提供了基本的输出操作，例如写入单个字符、写入字符数组等。Writer的常用方法包括： * void write(int b); 创建一个字符流 * void flush(); 刷新此流 * ...
RapidIO 4.0协议标准
12-28
#### 四、RapidIO 4.0协议规范内容 - **逻辑规范**：这部分定义了RapidIO 4.0协议的基本逻辑层，包括消息格式、数据路径控制、错误检测与纠正机制等。 - **物理层规范**：详细规定了信号传输的技术参数，如电压电平...
java的一些总结（不定期更新）
u012467492的专栏
07-08 451
1）Jsp网站中路径问题 　　（1）JSP网页中的相对路径与绝对路径 　　地址：http://shawnqiu.iteye.com/blog/721282 　　（2）JSP、HttpServlet路径讲解 　　地址：http://hi.baidu.com/630270730/blog/item/bc815865273bd9e5f7365493.html 　　（3）JSP、Servlet中
ELK(ElasticSearch, Logstash, Kibana)搭建实时日志分析平台
u012467492的专栏
03-14 307
ELK平台介绍 在搜索ELK资料的时候，发现这篇文章比较好，于是摘抄一小段： 以下内容来自： http://baidu.blog.51cto.com/71938/1676798 日志主要包括系统日志、应用程序日志和安全日志。系统运维和开发人员可以通过日志了解服务器软硬件信息、检查配置过程中的错误及错误发生的原因。经常分析日志可以了解服务器的负荷，性能安全性，从而及时采取措施纠正错
今天看了那么点Json
u012467492的专栏
10-12 285
JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation）     JSON 是轻量级的文本数据交换格式     JSON 独立于语言 *     JSON 具有自我描述性，更易理解 { "employees": [ { "firstName":"Bill" , "lastName":"Gates" }, { "firstNam
_Command_line_settings_desktop_wallpaper_tool,_Su_command-wallpa
最新发布
09-17
_Command_line_settings_desktop_wallpaper_tool,_Su_command-wallpaper
IMG_20240917_151703.jpg
09-17
IMG_20240917_151703.jpg
吉他谱_Pneuma - Tool.pdf
09-17
初级入门吉他谱 guitar tab
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值