JAVA中IO整理

最新推荐文章于 2023-02-14 12:42:22 发布
最新推荐文章于 2023-02-14 12:42:22 发布
阅读量718 收藏
点赞数
分类专栏： java 基础

http://www.cnblogs.com/rollenholt/archive/2011/09/11/2173787.html

JAVA中的IO整理

写在前面：本文章基本覆盖了java的

最后欢迎大家提出意见和建议。

【案例1】创建一个新文件

？
1
2
3
4
5
6
7
8
9
10
11
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args）{
         文件F = 新的  文件（ “D：\ \ hello.txt的” ）;
         尝试 {
             f.createNewFile（）;
         } 赶上  （例外五）{
             e.printStackTrace（）;
         }
     }
}

【运行结果】：

程序运行之后，在ð 盘下会有一个名字为hello.txt中的文件。

【案例2】类的两个常量

？
1
2
3
4
5
6
7
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args）{
         System.out.println（文件分割符）;
         system.out.println（File.pathSeparator）;
     }
}

【运行结果】：

\

;

此处多说几句：有些同学可能认为，我直接在windows下使用\进行分割不行吗？当然是可以的。但是在linux下就不是\了。所以，要想使得我们的代码跨平台，更加健壮，所以，大家都采用这两个常量吧，其实也多写不了几行。呵呵、

现在我们使用文件类中的常量改写上面的代码：

？
1
2
3
4
5
6
7
8
9
10
11
12
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args）{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         尝试 {
             f.createNewFile（）;
         } 赶上  （例外五）{
             e.printStackTrace（）;
         }
     }
}

你看，没有多写多少吧，呵呵。所以建议使用文件类中的常量。

 

删除一个文件

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/ **
  *删除一个文件
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args）{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         ，如果 （f.exists（））{
             f.delete（）;
         其他 {
             System.out.println（ “ 文件不存在” ）;
         }
         
     }
}

创建一个文件夹

？
1
2
3
4
5
6
7
8
9
10
11
/ **
  *创建一个文件夹
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args）{
         字符串文件名​​= “D：” +文件分割符+ “你好” ;
         文件F = 新的  文件（文件名 ​​）;
         f.mkdir（）;
     }
}

【运行结果】：

ð 盘下多了一个招呼文件夹

 

列出指定目录的全部文件（包括隐藏文件）：

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/ **
  *使用列表中列出指定目录的全部文件的
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args）{
         字符串文件名​​= “D：” +文件分割符;
         文件F = 新的  文件（文件名 ​​）;
         的String []海峡= f.list（）;
          （  I = 0 ; <str.length; + +）{
             System.out.println（STR []）;
         }
     }
}

【运行结果】：

$ RECYCLE.BIN

360

360Downloads

360Rec

360SoftMove

Config.Msi

达

下载

DriversBackup

日食

的java web 整合开发和项目实战

联想

MSOCache文件

节目

程序文件

蟒蛇

{8F92DA15-A229-A4D5-B5CE的5280C8B89C19 RECYGLER。}

系统卷信息

的Tomcat6

VAR

vod_cache_data

新建文件夹

（你的运行结果应该和这个不一样的，呵呵）

但是使用list返回的是String数组，。而且列出的不是完整路径，如果想列出完整路径的话，需要使用listFiles.他返回的是File的数组

列出指定目录的全部文件（包括隐藏文件）：

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/ **
  *使用listFiles列出指定目录的全部文件的
  * listFiles输出的是完整路径
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args）{
         字符串文件名​​= “D：” +文件分割符;
         文件F = 新的  文件（文件名 ​​）;
         文件[] f.listFiles STR =（）;
          （  I = 0 ; <str.length; + +）{
             System.out.println（STR []）;
         }
     }
}

【运行结果】：

D：\ $ RECYCLE.BIN

D：\ 360

D：\ 360Downloads中

D：\ 360Rec中

D：\ 360SoftMove中

D：\ Config.Msi中

D：\ DA

D：\下载

D：\ DriversBackup中

D：\ eclipse的

D：\ java的web 整合性开发和项目实战

D：\联想

ð：\ MSOCACHE中

D：\ PROGRAM

D：\ Program Files文件

D：\蟒蛇

D：\ {8F92DA15-A229-A4D5-B5CE的5280C8B89C19 RECYGLER。}

D：\ System Volume Information资料

D：\的Tomcat6

D：\ VAR

D：\ vod_cache_data

D：\ 新建文件夹

通过比较可以指定使用的listFiles 更加方便，

 

判断一个指定的路径是否为目录

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/ **
  *使用isDirectory判断一个指定的路径是否为目录
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args）{
         字符串文件名​​= “D：” +文件分割符;
         文件F = 新的  文件（文件名 ​​）;
         ，如果 （f.isDirectory（））{
             system.out.println（ “YES” ）;
         其他 {
             system.out.println（ “NO” ）;
         }
     }
}

【运行结果】：YES

 

搜索指定目录的全部内容

？
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
/ **
  *列出指定目录的全部内容
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args）{
         字符串文件名​​= “D：” +文件分割符;
         文件F = 新的  文件（文件名 ​​）;
         打印（F）;
     }
     公共  静态  无效  打印（文件F）{
         如果 （f! = 空 ）{
             ，如果 （f.isDirectory（））{
                 文件[] fileArray = f.listFiles（）;
                 如果 （fileArray! = 空 ）{
                      （  I = 0 ; <fileArray.length;我+ +）{
                         / /递归调用
                         打印（fileArray []）;
                     }
                 }
             }
             其他 {
                 System.out.println（F）;
             }
         }
     }
}

【运行结果】：

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \阿帕奇\ JSP \ framepages \ web4welcome_jsp.java

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ help_005fhome_jsp.class

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ help_005fhome_jsp.java

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ home_jsp.class

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ home_jsp.java

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ index_jsp.class

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ index_jsp.java

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ login_jsp.class

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ login_jsp.java

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ modify_005fuser_005finfo_jsp.class

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ modify_005fuser_005finfo_jsp.java

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ register_005fnotify_jsp.class

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ register_005fnotify_jsp.java

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ sign_00​​5fup_jsp.class

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ sign_00​​5fup_jsp.java

D：\的Tomcat6 \工作\卡特琳娜\ localhost为\涅韦尔\ ORG \ apache的\ JSP \ transit_jsp.class

......

 

【使用的RandomAccessFile 写入文件】

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/ **
  *使用的RandomAccessFile写入文件
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         RandomAccessFile的演示= 新  的RandomAccessFile（F， “RW” ）;
         demo.writeBytes（ “asdsad” ）;
         demo.writeInt（ 12 ）;
         demo.writeBoolean（ 真 ）;
         demo.writeChar（ “A” ）;
         demo.writeFloat（ 1 .21 F）;
         demo.writeDouble（ 12.123 ）;
         demo.close（）;  
     }
}

如果你此时打开打招呼。TXT 查看的话，会发现那是乱码。

 

字节流

【向文件中写入字符串】

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/ **
  *字节流
  *向文件中写入字符串
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         OutputStream中出= 新的  文件输出流（F）;
         字符串str = “你好” ;
         字节 [] = str.getBytes（）;
         out.write（b）条;
         out.close（）;
     }
}

查看hello.txt中会看到“你好”

当然也可以一个字节一个字节的写。

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/ **
  *字节流
  *向文件中一个字节一个字节的写入字符串
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         OutputStream中出= 新的  文件输出流（F）;
         字符串str = “你好” ;
         字节 [] = str.getBytes（）;
          （  I = 0 ; b.length个; + +）{
             out.write（B []）;
         }
         out.close（）;
     }
}

结果还是：“你好”

 

向文件中追加新内容：

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/ **
  *字节流
  *向文件中追加新内容：
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         OutputStream中出= 新的  文件输出流， 真正的 ）;
         字符串str = “ROLLEN” ;
         / /字符串str =“\ R \ nRollen”可以换行
         字节 [] = str.getBytes（）;
          （  I = 0 ; b.length个; + +）{
             out.write（B []）;
         }
         out.close（）;
     }
}

【运行结果】：

你好ROLLEN

 

【读取文件内容】

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/ **
  *字节流
  *读文件内容
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         InputStream的= 新的  文件输入流（F）;
         字节 [] = 新的  字节 [ 1024 ];
         in.read（b）条;
         in.close（）;
         System.out.println（ 新的  字符串（B））;
     }
}

【运行结果】

你好ROLLEN

Rollen_

但是这个例子读取出来会有大量的空格，我们可以利用in.read(b);的返回值来设计程序。如下：

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/ **
  *字节流
  *读文件内容
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         InputStream的= 新的  文件输入流（F）;
         字节 [] = 新的  字节 [ 1024 ];
          LEN = in.read（b）条;
         in.close（）;
         （ “读入长度为：” + LEN）;
         System.out.println（ 新的  字符串（B， 0 ，LEN））;
     }
}

【运行结果】：

读入长度为：18

你好ROLLEN

ROLLEN

 

读者观察上面的例子可以看出，我们预先申请了一个指定大小的空间，但是有时候这个空间可能太小，有时候可能太大，我们需要准确的大小，这样节省空间，那么我们可以这样干：

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/ **
  *字节流
  *读文件内容，节省空间
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         InputStream的= 新的  文件输入流（F）;
         字节 [] = 新的  字节 [（ INT ）经度（）];
         in.read（b）条;
         （ 文件的长度为：“ +经度（））;
         in.close（）;
         System.out.println（ 新的  字符串（B））;
     }
}

文件长度为：18

你好ROLLEN

ROLLEN

 

将上面的例子改为一个一个读：

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/ **
  *字节流
  *读文件内容，节省空间
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         InputStream的= 新的  文件输入流（F）;
         字节 [] = 新的  字节 [（ INT ）经度（）];
          （  I = 0 ; b.length个; + +）{
             B [] =（ 字节 ）in.read（）;
         }
         in.close（）;
         System.out.println（ 新的  字符串（B））;
     }
}

输出的结果和上面的一样。

 

细心的读者可能会发现，上面的几个例子都是在知道文件的内容多大，然后才展开的，有时候我们不知道文件有多大，这种情况下，我们需要判断是否独到文件的末尾。

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/ **
  *字节流
  *读文件
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         InputStream的= 新的  文件输入流（F）;
         字节 [] = 新的  字节 [ 1024 ];
          计数= 0 ;
          温度= 0 ;
         （（温度= in.read（））！=（ - 1 ））{
             B [计数+ +] =（ 字节 ）温度;
         }
         in.close（）;
         System.out.println（ 新的  字符串（B））;
     }
}

【运行结果】

你好ROLLEN

Rollen_

提醒一下，当独到文件末尾的时候会返回-1。正常情况下是不会返回-1 的

 

字符流

【向文件中写入数据】

现在我们使用字符流

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/ **
  *字符流
  *写入数据
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         作家= 新  FileWriter中（F）;
         字符串str = “你好” ;
         out.write（STR）;
         out.close（）;
     }
}

当你打开打招呼。TXT 的时候，会看到打招呼

其实这个例子上之前的例子没什么区别，只是你可以直接输入字符串，而不需要你将字符串转化为字节数组。

当你如果想问文件中追加内容的时候，可以使用将上面的声明out的哪一行换为：

作家= 新 FileWriter中（F，真实）;

这样，当你运行程序的时候，会发现文件内容变为：

hellohello 如果想在文件中换行的话，需要使用“ \ R \ N “

比如将海峡变为字符串str = “\ R \ nhello” ;

这样文件追加的STR 的内容就会换行了。

 

从文件中读内容：

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/ **
  *字符流
  *从文件中读出内容
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         的char [] CH = 新  的char [ 100 ];
         阅读器读取 新  的FileReader（F）;
          计数= read.read（CH）;
         read.close（）;
         （ “读入的长度为：” +计数）;
         （ 内容为“ + 新的  字符串（CH， 0 计数））;
     }
}

【运行结果】：

读入的长度为：17

内容为hellohello

你好

 

当然最好采用循​​环读取的方式，因为我们有时候不知道文件到底有多大。

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/ **
  *字符流
  *从文件中读出内容
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         文件F = 新的  文件（文件名 ​​）;
         的char [] CH = 新  的char [ 100 ];
         阅读器读取 新  的FileReader（F）;
          温度= 0 ;
          计数= 0 ;
         （（温度= read.read（））=（ - 1 ））{
             CH [计数+ +] =（ char ）的温度;
         }
         read.close（）;
         （ 内容为“ + 新的  字符串（CH， 0 计数））;
     }
}

运行结果：

内容为hellohello

你好

 

关于字节流和字符流的区别

实际上字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的，但是字符流在操作的 时候下后是会用到缓冲区的，是通过缓冲区来操作文件的。

读者可以试着将上面的字节流和字符流的程序的最后一行关闭文件的代码注释掉，然后运行程序看看。你就会发现使用字节流的话，文件中已经存在内容，但是使用字符流的时候，文件中还是没有内容的，这个时候就要刷新缓冲区。

使用字节流好还是字符流好呢？

答案是字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的，包括图片等内容。但是字符只是在内存中才会形成的，所以在开发中，字节流使用广泛。

文件的复制

其实ＤＯＳ下就有一个文件复制功能，比如我们想把ｄ盘下面的ｈｅｌｌｏ．ｔｘｔ文件复制到d盘下面的rollen.txt文件中，那么我们就可以使用下面的命令：

副本d：\ hello.txt的D：\ rollen.txt

运行之后你会在d盘中看见hello.txt.，并且两个文件的内容是一样的，（这是屁话）

 

下面我们使用程序来复制文件吧。

基本思路还是从一个文件中读入内容，边读边写入另一个文件，就是这么简单。、

首先编写下面的代码：

？
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
/ **
  *文件的复制
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         （args.length！= 2 ）{
             （ “命令行参数输入有误，请检查” ）;
             system.exit（ 1 ）;
         }
         file1文件= 新的  文件（参数[ 0 ]）;
         文件FILE2 = 新的  文件（参数[ 1 ]）;
         
         （！file1.exists（））{
             （ “被复制的文件不存在” ）;
             system.exit（ 1 ）;
         }
         InputStream中输入 新的  文件输入流（文件1）;
         OutputStream的输出= 新的  文件输出流（文件2）;
         （（input! = 空 ）&&（output! = 空 ））{
              温度= 0 ;
             （（温度= input.read（））=（ - 1 ））{
                 output.write（临时）;
             }
         }
         input.close（）;
         output.close（）;
     }
}

然后在命令行下面

javac Hello.java的来

java的招呼D：\ hello.txt的D：\ rollen.txt

现在你就会在ð 盘看到ROLLEN TXT 了，

OutputStreramWriter 和InputStreamReader的类

整个IO 类中除了字节流和字符流还包括字节和字符转换流。

OutputStreramWriter 将输出的字符流转化为字节流

InputStreamReader的将输入的字节流转换为字符流

但是不管如何操作，最后都是以字节的形式保存在文件中的。

 

将字节输出流转化为字符输出流
？
1
2
3
4
5
6
7
8
9
10
11
12
13
/ **
  *将字节输出流转化为字符输出流
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         档案文件= 新的  文件（文件名 ​​）;
         作家出的 新  OutputStreamWriter（ 新的  文件输出流（文件））;
         out.write（ “ 招呼” ）;
         out.close（）;
     }
}

运行结果：文件中内容为：你好

将字节输入流变为字符输入流
？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/ **
  *将字节输入流变为字符输入流
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串文件名​​= “D：” +文件分割符+ “hello.txt的” ;
         档案文件= 新的  文件（文件名 ​​）;
         读者读= 新  的InputStreamReader（ 新的  文件输入流（文件））;
         的char [] B = 新  的char [ 100 ];
          LEN = read.read（b）条;
         System.out.println（ 新的  字符串（B， 0 ，LEN））;
         read.close（）;
     }
}

【运行结果】：你好

前面列举的输出输入都是以文件进行的，现在我们以内容为输出输入目的地，使用内存操作流

ByteArrayInputStream的主要将内容写入内容

字节数组输出流  主要将内容从内存输出

使用内存操作流将一个大写字母转化为小写字母
？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/ **
  *使用内存操作流将一个大写字母转化为小写字母
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串str = “ROLLENHOLT” ;
         ByteArrayInputStream的输入= 新  ByteArrayInputStream类（str.getBytes（点））;
         字节数组输出流输出= 新  的ByteArrayOutputStream（）;
          温度= 0 ;
         而 （（临时= input.read（））！= - 1 ）{
             字符  CH =（ char ）的温度;
             output.write（Character.toLowerCase（CH））;
         }
         弦乐OUTSTR = output.toString（）;
         input.close（）;
         output.close（）;
         System.out.println（OUTSTR）;
     }
}

【运行结果】：

rollenholt

内容操作流一般使用来生成一些临时信息采用的，这样可以避免删除的麻烦。

管道流

管道流主要可以进行两个线程之间的通信。

PipedOutputStream的管道输出流

PipedInputStream的管道输入流

验证管道流
？
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
/ **
  *验证管道流
  / **
进口  java.io. *;
 
/ **
  *消息发送类
  / **
类  实现  了Runnable {
     私人  PipedOutputStream的= NULL ;
     公众  发送（）{
         = 新  的PipedOutputStream（）;
     }
     公共  PipedOutputStream的getOut的（）{
         返回  这个 。出;
     }
     公共  无效  的run（）{
         字符串消息= “你好，ROLLEN” ;
         尝试 {
             out.write（message.getBytes情况（））;
         } 赶上  （例外五）{
             e.printStackTrace（）;
         } {
             out.close（）;
         } 赶上  （例外五）{
             e.printStackTrace（）;
         }
     }
}
 
/ **
  *接受消息类
  / **
类  Recive 实现  了Runnable {
     私人  的PipedInputStream输入= NULL ;
     的公共  Recive（）{
         输入 新的  PipedInputStream的（）;
     }
     公众  的PipedInputStream获取输入（）{
         返回  输入;
     }
     公共  无效  的run（）{
         字节 [] = 新的  字节 [ 1000 ];
          LEN = 0 ;
         尝试 {
             LEN = input.read（二）;
         } 赶上  （例外五）{
             e.printStackTrace（）;
         } {
             input.close（）;
         } 赶上  （例外五）{
             e.printStackTrace（）;
         }
         System.out.println（ “ 接受的内容为” +（ 新的  字符串（B， 0 ，LEN）））;
     }
}
/ **
  *测试类
  / **
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         发送  发送（）;
         Recive recive，= 新  Recive（）;
         尝试 {
/ /管道连接
             send.getOut（）连接（recive.getInput（））;
         } 赶上  （例外五）{
             e.printStackTrace（）;
         }
         新的  主题（发送）。启动（）;
         新的  主题（recive）。启动（）;
     }
}

【运行结果】：

接受的内容为你好，ROLLEN

打印流

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/ **
  *使用的PrintStream进行输出
  / **
进口  java.io. *;
 
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         PrintStream的打印= 新  的PrintStream（ 新  文件输出流（ 新的  文件（ “D：”
                 +文件分割符+ “hello.txt的” ）））;
         print.println（ 真 ）;
         print.println（ “ROLLEN ）;
         print.close（）;
     }
}

【运行结果】：

真

ROLLEN

当然也可以格式化输出

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/ **
  *使用的PrintStream进行输出
  *并进行格式化
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         PrintStream的打印= 新  的PrintStream（ 新  文件输出流（ 新的  文件（ “D：”
                 +文件分割符+ “hello.txt的” ）））;
         字符串名称= “ROLLEN” ;
          年龄= 20 ;
         print.printf（ “ 姓名：％s的年龄数：％d” ，姓名，年龄）;
         print.close（）;
     }
}

【运行结果】：

姓名：ROLLEN。年龄：20。

 

使用的OutputStream 向屏幕上输出内容

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/ **
  *使用的OutputStream向屏幕上输出内容
  / **
进口  java.io. *;
类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         = System.out的OutputStream中出;
         尝试 {
             out.write（ “ 你好” 。getBytes的（））;
         } 赶上  （例外五）{
             e.printStackTrace（）;
         }
         尝试 {
             out.close（）;
         } 赶上  （例外五）{
             e.printStackTrace（）;
         }
     }
}

【运行结果】：

你好

 

输入输出重定向

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
进口  的java.io.File;
进口  java.io.FileNotFoundException;
导入  java.io.FileOutputStream;
导入  java.io.PrintStream;
 
/ **
  *为的System.out.println（）重定向输出
  / **
公共  类  systemDemo {
     公共  静态  无效的  主要（字串[] args）{
         / /此刻直接输出到屏幕
         System.out.println（ “ 你好” ）;
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         尝试 {
             System.setOut（ 新  的PrintStream（ 新的  文件输出流（文件）））;
         } 赶上 （FileNotFoundException异常E）{
             e.printStackTrace（）;
         }
         （ “这些内容在文件中才能看到哦！” ）;
     }
}

【运行结果】：

eclipse的控制台输出的是hello。然后当我们查看d盘下面的hello.txt文件的时候，会在里面看到：这些内容在文件中才能看到哦！

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
进口  的java.io.File;
进口  java.io.FileNotFoundException;
导入  java.io.FileOutputStream;
导入  java.io.PrintStream;
 
/ **
  * System.err的重定向这个例子也提示我们可以使用这种方法保存错误信息
  / **
公共  类  systemErr {
     公共  静态  无效的  主要（字串[] args）{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         system.err.println（ 这些在控制台输出“ ）;
         尝试 {
             System.setErr（ 新  的PrintStream（ 新的  文件输出流（文件）））;
         } 赶上 （FileNotFoundException异常E）{
             e.printStackTrace（）;
         }
         system.err.println（ “ 这些在文件中才能看到哦！” ）;
     }
}

【运行结果】：

你会在eclipse的控制台看到红色的输出：“这些在控制台输出”，然后在d盘下面的hello.txt中会看到：这些在文件中才能看到哦！

？
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
进口  的java.io.File;
导入  java.io.FileInputStream;
进口  java.io.FileNotFoundException;
进口  java.io.IOException异常;
 
/ **
  * System.in重定向
  / **
公共  类  系统在{
     公共  静态  无效的  主要（字串[] args）{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         （file.exists（））{
             返回 ;
         其他 {
             尝试 {
                 System.setIn（ 新的  文件输入流（文件））;
             } 赶上 （FileNotFoundException异常E）{
                 e.printStackTrace（）;
             }
             字节 []字节= 新  字节 [ 1024 ];
              LEN = 0 ;
             尝试 {
                 LEN = System.in.read（字节）;
             } 赶上 （IOException异常E）{
                 e.printStackTrace（）;
             }
             （ “读入的内容为：”   + 新的  字符串（字节， 0 ，LEN））;
         }
     }
}

【运行结果】：

前提是我的d盘下面的hello.txt中的内容是：“这些文件中的内容哦！”，然后运行程序，输出的结果为：读入的内容为：这些文件中的内容哦！

 

BufferedReader的的小例子

注意： BufferedReader只能接受字符流的缓冲区，因为每一个中文需要占据两个字节，所以需要将System.in这个字节输入流变为字符输入流，采用：

？
BufferedReader的BUF = 新  的BufferedReader（
                 新  的InputStreamReader（System.in））;

下面给一个实例：

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
进口  java.io.BufferedReader;
进口  java.io.IOException异常;
进口  java.io.InputStreamReader;
 
/ **
  *使用缓冲区从键盘上读入内容
  / **
公共  类  BufferedReaderDemo {
     公共  静态  无效的  主要（字串[] args）{
         BufferedReader的BUF = 新  的BufferedReader（
                 新  的InputStreamReader（System.in））;
         字符串str = 空 ;
         （ “请输入内容” ）;
         尝试 {
             STR = buf.readLine（）;
         } 赶上 （IOException异常E）{
             e.printStackTrace（）;
         }
         （ “你输入的内容是：”   + STR）;
     }
}

运行结果：

请输入内容

dasdas

你输入的内容是：dasdas

 

扫描类

其实我们比较常用的是采用Scanner类来进行数据输入，下面来给一个Scanner的例子吧

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
导入  java.util.Scanner;
 
/ **
  *扫描仪的小例子，从键盘读数据
  / **
公共  类  ScannerDemo {
     公共  静态  无效的  主要（字串[] args）{
         扫描SCA =   （System.in）;
         / /读一个整数
          温度= sca.nextInt（）;
         System.out.println（临时）;
         / /读取浮点数
         浮动  FLO = sca.nextFloat（）;
         System.out.println（FLO）;
         / /读取字符
         / / ...等等的，都是一些太基础的，就不师范了。
     }
}

其实扫描仪可以接受任何的输入流

下面给一个使用扫描仪类从文件中读出内容

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
进口  的java.io.File;
进口  java.io.FileNotFoundException;
导入  java.util.Scanner;
 
/ **
  *扫描仪的小例子，从文件中读内容
  / **
公共  类  ScannerDemo {
     公共  静态  无效的  主要（字串[] args）{
 
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         扫描SCA = 空 ;
         尝试 {
             SCA = 新的  扫描仪（文件）;
         } 赶上 （FileNotFoundException异常E）{
             e.printStackTrace（）;
         }
         字符串str = sca.next（）;
         （ “从文件中读取的内容是：”   + STR）;
     }
}

【运行结果】：

从文件中读取的内容是：这些文件中的内容哦！

数据操作流DataOutputStream的数据输入流类

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
导入  java.io.DataOutputStream;
进口  的java.io.File;
导入  java.io.FileOutputStream;
进口  java.io.IOException异常;
 
公共  类  DataOutputStreamDemo {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         char []的CH = { 'A' ， 'B' ， 'C'   };
         DataOutputStream的= NULL ;
         = 新  DataOutputStream的（ 新的  文件输出流（文件））;
         （ 字符  气温：CH）{
             out.writeChar（临时）;
         }
         out.close（）;
     }
}

ABC

现在我们在上面例子的基础上，使用DataInputStream中读出内容

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
导入  java.io.DataInputStream;
进口  的java.io.File;
导入  java.io.FileInputStream;
进口  java.io.IOException异常;
 
公共  类  DataOutputStreamDemo {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         DataInputStream中输入= 新的  数据输入流（ 新的  文件输入流（文件））;
         的char [] CH = 新  的char [ 10 ];
          计数= 0 ;
         炭  温度;
         （（TEMP = input.readChar（））！= 'C' ）{
             CH [计数+ +] =温度;
         }
         System.out.println（CH）;
     }
}

【运行结果】：

AB

合并流SequenceInputStream

SequenceInputStream主要用来将2个流合并在一起，比如将两个txt中的内容合并为另外一个txt。下面给出一个实例：

？
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
进口  的java.io.File;
导入  java.io.FileInputStream;
导入  java.io.FileOutputStream;
进口  java.io.IOException异常;
导入  的java.io.InputStream;
导入  java.io.OutputStream;
导入  java.io.SequenceInputStream;
 
/ **
  *将两个文本文件合并为另外一个文本文件
  / **
公共  类  SequenceInputStreamDemo {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         file1文件= 新的  文件（ “D：”   +文件分割符+ “hello1.txt” ）;
         文件FILE2 = 新的  文件（ “D：”   +文件分割符+ “hello2.txt的的 ）;
         file3的文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         InputStream中输入1 = 新的  文件输入流（文件1）;
         InputStream中输入2 = 新的  文件输入流（文件2）;
         OutputStream的输出= 新的  文件输出流（文件3）;
         / /合并流
         SequenceInputStream SIS =： 新  （输入1，输入2）;
          温度= 0 ;
         而 （（临时= sis.read（））！= - 1 ）{
             output.write（临时）;
         }
         input1.close（）;
         input2.close（）;
         output.close（）;
         sis.close（）;
     }
}

【运行结果】

结果会在hello.txt的文件中包含hello1.txt 和hello2.txt 文件中的内容。

文件压缩 ZipOutputStream 类

先举一个压缩单个文件的例子吧：

？
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
进口  的java.io.File;
导入  java.io.FileInputStream;
导入  java.io.FileOutputStream;
进口  java.io.IOException异常;
导入  的java.io.InputStream;
导入  java.util.zip.ZipEntry;
导入  java.util.zip.ZipOutputStream;
 
公共  类  ZipOutputStreamDemo1 {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         文件zip文件= 新的  文件（ “D：”   +文件分割符+ “hello.zip的的 ）;
         InputStream中输入 新的  文件输入流（文件）;
         ZipOutputStream zipOut = 新  ZipOutputStream（ 新  文件输出流（
                 zip文件））;
         zipOut.putNextEntry（ 新  的ZipEntry（file.getName（）））;
         / /设置注释
         zipOut.setComment（ “ 你好” ）;
          温度= 0 ;
         而 （（临时= input.read（））！= - 1 ）{
             zipOut.write（临时）;
         }
         input.close（）;
         zipOut.close（）;
     }
}

【运行结果】

运行结果之前，我创建了一个hello.txt的文件，原本大小56个字节，但是压缩之后产生hello.zip之后，居然变成了175个字节，有点搞不懂。

不过结果肯定是正确的，我只是提出我的一个疑问而已。

上面的这个例子测试的是压缩单个文件，下面的们来看看如何压缩多个文件。

？
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
进口  的java.io.File;
导入  java.io.FileInputStream;
导入  java.io.FileOutputStream;
进口  java.io.IOException异常;
导入  的java.io.InputStream;
导入  java.util.zip.ZipEntry;
导入  java.util.zip.ZipOutputStream;
 
/ **
  *一次性压缩多个文件
  / **
公共  类  ZipOutputStreamDemo2 {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         / /要被压缩的文件夹
         档案文件= 新的  文件（ “D：”   + + 文件分割符 ）;
         文件zip文件= 新的  文件（ “D：”   +文件分割符+ “zipFile.zip的的 ）;
         InputStream中输入= 空 ;
         ZipOutputStream zipOut = 新  ZipOutputStream（ 新  文件输出流（
                 zip文件））;
         zipOut.setComment（ “ 你好” ）;
         ，如果 （file.isDirectory（））{
             文件[]文件= file.listFiles（）;
             （  I = 0 ; <files.length + +）{
                 输入 新的  文件输入流（文件[]）;
                 zipOut.putNextEntry（ 新  ZipEntry的（file.getName（）
                         +文件分割符+文件[I]的getName（）））;
                  温度= 0 ;
                 而 （（临时= input.read（））！= - 1 ）{
                     zipOut.write（临时）;
                 }
                 input.close（）;
             }
         }
         zipOut.close（）;
     }
}

【运行结果】

先看看要被压缩的文件吧：

接下来看看压缩之后的：

大家自然想到，既然能压缩，自然能解压缩，在谈解压缩之前，我们会用到一个ZipFile类，先给一个这个例子吧。java中的每一个压缩文件都是可以使用ZipFile来进行表示的

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
进口  的java.io.File;
进口  java.io.IOException异常;
导入  java.util.zip.ZipFile;
 
/ **
  * zip文件演示
  / **
公共  类  {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         档案文件= 新的  文件（ “D：”   +文件分割符+ “hello.zip的的 ）;
         zip文件zip文件= 新的  zip文件（文件）;
         （ 压缩文件的名称为：“   + zipFile.getName（））;
     }
}

【运行结果】：

压缩文件的名称为：D：\ hello.zip

 

现在我们呢是时候来看看如何加压缩文件了，和之前一样，先让我们来解压单个压缩文件（也就是压缩文件中只有一个文件的情况），我们采用前面的例子产生的压缩文件hello.zip

？
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
进口  的java.io.File;
导入  java.io.FileOutputStream;
进口  java.io.IOException异常;
导入  的java.io.InputStream;
导入  java.io.OutputStream;
导入  java.util.zip.ZipEntry;
导入  java.util.zip.ZipFile;
 
/ **
  *解压缩文件（压缩文件中只有一个文件的情况）
  / **
公共  类  ZipFileDemo2 {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         档案文件= 新的  文件（ “D：”   +文件分割符+ “hello.zip的的 ）;
         文件OUTFILE = 新的  文件（ “D：”   +文件分割符+ “unZipFile.txt的的” ）;
         zip文件zip文件= 新的  zip文件（文件）;
         ZipEntry的入门zipFile.getEntry（ “hello.txt的” ）;
         InputStream中输入= zipFile.getInputStream（项）;
         OutputStream的输出= 新的  文件输出流（不过outFile）;
          温度= 0 ;
         而 （（临时= input.read（））！= - 1 ）{
             output.write（临时）;
         }
         input.close（）;
         output.close（）;
     }
}

【运行结果】：

解压缩之前：

这个压缩文件还是175 字节

解压之后产生：

又回到了56 字节，表示郁闷。

 

现在让我们来解压一个压缩文件中包含多个文件的情况吧

ZipInputStream类类

当我们需要解压缩多个文件的时候，ZipEntry就无法使用了，如果想操作更加复杂的压缩文件，我们就必须使用ZipInputStream类

？
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
进口  的java.io.File;
导入  java.io.FileInputStream;
导入  java.io.FileOutputStream;
进口  java.io.IOException异常;
导入  的java.io.InputStream;
导入  java.io.OutputStream;
导入  java.util.zip.ZipEntry;
导入  java.util.zip.ZipFile;
导入  java.util.zip.ZipInputStream;
 
/ **
  *解压缩一个压缩文件中包含多个文件的情况
  / **
公共  类  ZipFileDemo3 {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         档案文件= 新的  文件（ “D：”   +文件分割符+ “zipFile.zip的的 ）;
         文件OUTFILE = 空 ;
         zip文件zip文件= 新的  zip文件（文件）;
         ZipInputStream类zipInput = 新  ZipInputStream类（ 新的  文件输入流（文件））;
         ZipEntry的条目= NULL ;
         InputStream中输入= 空 ;
         的OutputStream输出= NULL ;
         （的（进入= zipInput.getNextEntry（））！= 空 ）{
             （ “解压缩”   + entry.getName（）+ “文件” ）;
             OUTFILE = 新的  文件（ “D：”   +文件分割符+ entry.getName（））;
             如果 存在outFile.getParentFile（）（））{
                 MKDIR outFile.getParentFile（）（）;
             }
             （！outFile.exists（））{
                 outFile.createNewFile（）;
             }
             输入= zipFile.getInputStream（项）;
             输出= 新的  文件输出流（不过outFile）;
              温度= 0 ;
             而 （（临时= input.read（））！= - 1 ）{
                 output.write（临时）;
             }
             input.close（）;
             output.close（）;
         }
     }
}

【运行结果】：

被解压的文件：

解压之后再ð 盘下会出现一个临时文件夹，里面内容：

PushBackInputStream 回退流
？
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
导入  java.io.ByteArrayInputStream;
进口  java.io.IOException异常;
导入  java.io.PushbackInputStream;
 
/ **
  *回退流操作
  / **
公共  类  PushBackInputStreamDemo {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         字符串str = “你好，rollenholt” ;
         PushbackInputStream推= NULL ;
         ByteArrayInputStream的蝙蝠= NULL ;
         蝙蝠= 新  ByteArrayInputStream类（str.getBytes（点））;
         推=： 新  （蝙蝠）;
          温度= 0 ;
         而 （（临时= push.read（））！= - 1 ）{
             （临时== '，' ）{
                 push.unread（临时）;
                 温度= push.read（）;
                 （ （回退“   +（ 字符 ）温度+ “）” ）;
             其他 {
                 System.out.print（（ 炭 ）临时）;
             }
         }
     }
}

【运行结果】：

你好（回退）rollenholt

？
1
2
3
4
5
6
7
8
/ **
  *取得本地的默认编码
  / **
公共  类  CharSetDemo {
     公共  静态  无效的  主要（字串[] args）{
         （ 系统的默认编码为：“   +用System.getProperty（ “file.encoding的” ））;
     }
}

【运行结果】：

系统默认编码为GBK

 

乱码的产生：

？
进口  的java.io.File;
导入  java.io.FileOutputStream;
进口  java.io.IOException异常;
导入  java.io.OutputStream;
 
/ **
  *乱码的产生
  / **
公共  类  CharSetDemo2 {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         OutputStream中出= 新的  文件输出流（文件）;
         字节 []字节= “你好” 。getBytes的（ ISO8859-1“ ）;
         out.write（字节）;
         out.close（）;
     }
}

【运行结果】：

？

 

一般情况下产生乱码，都是由于编码不一致的问题。

对象的序列化

对象序列化就是把一个对象变为二进制数据流的一种方法。

一个类要想被序列化，就行必须实现java.io.Serializable接口。虽然这个接口中没有任何方法，就如同之前的cloneable接口一样。实现了这个接口之后，就表示这个类具有被序列化的能力。

先让我们实现一个具有序列化能力的类吧：

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
进口  java.io. *;
/ **
  *实现具有序列化能力的类
  / **
公共  类  实现了  Serializable {
     ：公共  SerializableDemo（）{
         
     }
     公共  SerializableDemo（字符串名称， INT   年龄）{
         这 名=名称;
         这个 年龄=年龄;
     }
     @覆盖
     公共  字符串的toString（）{
         返回  “姓名：” +姓名+ “年龄：” +年龄;
     }
     私人  弦乐名;
     私人  诠释  年龄;
}

这个类就具有实现序列化能力，

在继续将序列化之前，先将一下的ObjectInputStream 和ObjectOutputStream的这两个类

先给一个ObjectOutputStream中的例子吧：

？
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
进口  了java.io.Serializable;
进口  的java.io.File;
导入  java.io.FileOutputStream;
进口  java.io.IOException异常;
导入  java.io.ObjectOutputStream中;
 
/ **
  *实现具有序列化能力的类
  / **
公共  类  人 实现了  Serializable {
     公众  人士（）{
 
     }
 
     公众  人士（字符串名称， 诠释  年龄）{
         这 名=名称;
         这个 年龄=年龄;
     }
 
     @覆盖
     公共  字符串的toString（）{
         返回  “姓名：”   +姓名+ “年龄：”   +年龄;
     }
 
     私人  弦乐名;
     私人  诠释  年龄;
}
/ **
  *示范的ObjectOutputStream
  / **
公共  类  ObjectOutputStreamDemo {
     公共  静态  无效的  主要（字串[] args） 抛出  IOException异常{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         ObjectOutputStream的OOS = 新  的ObjectOutputStream（ 新  文件输出流（
                 文件））;
         oos.writeObject（  人（ “ROLLEN” ， 20 ））;
         oos.close（）;
     }
}

【运行结果】：

当我们查看产生的hello.txt的时候，看到的是乱码，呵呵。因为是二进制文件。

虽然我们不能直接查看里面的内容，但是我们可以使用ObjectＩｎｐｕｔＳｔｒｅａｍ类查看：

？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
进口  的java.io.File;
导入  java.io.FileInputStream;
导入的  java.io.ObjectInputStream中;
 
/ **
  * ObjectInputStream的示范
  / **
公共  类  ObjectInputStreamDemo {
     公共  静态  无效的  主要（字串[] args） 抛出  异常{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         ObjectInputStream的输入= 新  的ObjectInputStream（ 新  文件输入流（
                 文件））;
         对象obj = input.readObject（）;
         input.close（）;
         System.out.println（OBJ）;
     }
}

【运行结果】

姓名：ROLLEN   年龄：20

 

到底序列化什么内容呢？

其实只有属性会被序列化。

Externalizable的接口

被Serializable接口声明的类的对象的属性都将被序列化，但是如果想自定义序列化的内容的时候，就需要实现Externalizable接口。

当一个类要使用Externalizable这个接口的时候，这个类中必须要有一个无参的构造函数，如果没有的话，在构造的时候会产生异常，这是因为在反序列话的时候会默认调用无参的构造函数。

现在我们来演示一下序列化和反序列话：

？
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
包  IO;
 
导入  java.io.Externalizable;
进口  的java.io.File;
导入  java.io.FileInputStream;
导入  java.io.FileOutputStream;
进口  java.io.IOException异常;
导入  java.io.ObjectInput;
导入的  java.io.ObjectInputStream中;
导入  java.io.ObjectOutput;
导入  java.io.ObjectOutputStream中;
 
/ **
  *序列化和反序列化的操作
  / **
公共  类  {
     公共  静态  无效的  主要（字串[] args） 抛出  异常{
         SER（） / /序列化
         DSER（）;
     }
 
     公共  静态  无效  SER（） 抛出  异常{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         ObjectOutputStream的输出=   （ 新  文件输出流（
                 文件））;
         out.writeObject（  人（ “ROLLEN” ， 20 ））;
         out.close（）;
     }
 
     公共  静态的  无效  DSER（） 抛出  异常{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         ObjectInputStream的输入= 新  的ObjectInputStream（ 新  文件输入流（
                 文件））;
         对象obj = input.readObject（）;
         input.close（）;
         System.out.println（OBJ）;
     }
}
 
类  人 实现  了Externalizable {
     公众  人士（）{
 
     }
 
     公众  人士（字符串名称， 诠释  年龄）{
         这 名=名称;
         这个 年龄=年龄;
     }
 
     @覆盖
     公共  字符串的toString（）{
         返回  “姓名：”   +姓名+ “年龄：”   +年龄;
     }
 
     / /
     @覆盖
     公共  无效  writeExternal方法（ObjectOutput出）的 抛出  IOException异常{
         out.writeObject（ 名称）;
         out.writeInt（年龄）;
     }
 
     / /复写这个方法，根据需要读取内容反序列话的时候需要
     @覆盖
     公共  无效  的readExternal（ObjectInput的中） 抛出  IOException异常，
             ClassNotFoundException的{
         这 名=（字符串）in.readObject（）;
         这个 年龄= in.readInt（）;
     }
 
     私人  弦乐名;
     私人  诠释  年龄;
}

【运行结果】：

姓名：ROLLEN   年龄：20

本例中，我们将全部的属性都保留了下来，

Serializable接口实现的操作其实是吧一个对象中的全部属性进行序列化，当然也可以使用我们上使用是Externalizable接口以实现部分属性的序列化，但是这样的操作比较麻烦，

当我们使用Serializable接口实现序列化操作的时候，如果一个对象的某一个属性不想被序列化保存下来，那么我们可以使用transient关键字进行说明：

下面举一个例子：

？
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
包  IO;
 
进口  的java.io.File;
导入  java.io.FileInputStream;
导入  java.io.FileOutputStream;
导入的  java.io.ObjectInputStream中;
导入  java.io.ObjectOutputStream中;
进口  了java.io.Serializable;
 
/ **
  *序列化和反序列化的操作
  / **
公共  类  serDemo {
     公共  静态  无效的  主要（字串[] args） 抛出  异常{
         SER（） / /序列化
         DSER（）;
     }
 
     公共  静态  无效  SER（） 抛出  异常{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         ObjectOutputStream的输出=   （ 新  文件输出流（
                 文件））;
         out.writeObject（ 新  Person1的（ “ROLLEN” ， 20 ））;
         out.close（）;
     }
 
     公共  静态的  无效  DSER（） 抛出  异常{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         ObjectInputStream的输入= 新  的ObjectInputStream（ 新  文件输入流（
                 文件））;
         对象obj = input.readObject（）;
         input.close（）;
         System.out.println（OBJ）;
     }
}
 
类  Person1的 实现  Serializable接口{
     公共  Person1的（）{
 
     }
 
     公共  Person1的（字符串名称， INT   年龄）{
         这 名=名称;
         这个 年龄=年龄;
     }
 
     @覆盖
     公共  字符串的toString（）{
         返回  “姓名：”   +姓名+ “年龄：”   +年龄;
     }
 
     / /注意这里
     私人  瞬态  字符串名称;
     私人  诠释  年龄;
}

【运行结果】：

姓名：空 

最后在给一个序列化一组对象的例子吧：

？
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
进口  的java.io.File;
导入  java.io.FileInputStream;
导入  java.io.FileOutputStream;
导入的  java.io.ObjectInputStream中;
导入  java.io.ObjectOutputStream中;
进口  了java.io.Serializable;
 
/ **
  *序列化一组对象
  / **
公共  类  SerDemo1 {
     公共  静态  无效的  主要（字串[] args） 抛出  异常{
         [学生]学生= { 新的  学生（ “你好” ， 20 ）， 新的  学生（ “世界” ， 30 ），
                 新的  学生（ “ROLLEN” ， 40 ）};
         SER（STU）;
         Object []的OBJ = DSER（）;
         （  I = 0 ; <obj.length + +）{
             学生=（学生）obj的[];
             System.out.println（）;
         }
     }
 
     / /序列化
     公共  静态  无效  SER（Object []的OBJ） 抛出  异常{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         ObjectOutputStream的输出=   （ 新  文件输出流（
                 文件））;
         out.writeObject（OBJ）;
         out.close（）;
     }
 
     / /反序列化
     公共  静态  对象[] DSER（） 抛出  异常{
         档案文件= 新的  文件（ “D：”   + + 文件分割符 “ ）;
         ObjectInputStream的输入= 新  的ObjectInputStream（ 新  文件输入流（
                 文件））;
         Object []的OBJ =（对象[]）input.readObject（）;
         input.close（）;
         返回  obj的;
     }
}
 
类  实现了  Serializable {
     公开  学生（）{
 
     }
 
     公众  学生（字符串， 整型  年龄）{
         这 名=名称;
         这个 年龄=年龄;
     }
 
     @覆盖
     公共  字符串的toString（）{
         返回  “姓名：”   +姓名+ “年龄：”   +年龄;
     }
 
     私人  弦乐名;
     私人  诠释  年龄;
}

【运行结果】：

姓名：  你好  年龄：20

姓名：    年龄：30

姓名：  ROLLEN   年龄：40



njiang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8 常用的Stream流操作
语文课
09-12 2万+
概念：Steam 是Java8 提出的一个新概念，不是输入输出的 Stream 流，而是一种用函数式编程方式在集合类上进行复杂操作的工具。简而言之，是可以处理集合数据的操作。 在Java8以前，对集合的操作需要写出处理的过程，如在筛选出满足条件的数据，需要一一遍历集合中的每个元素，再把每个元素逐一判断是否满足条件，最后将满足条件的元素保存返回。而Stream 对集合筛选的操作提供了一种更为便捷的
tomcat编译jsp之后生成的Servlet书上说放在tomcat7\work\Catalina\localhost文件里，可是我找不到
evilcry2012的专栏
11-13 5184
tomcat编译jsp之后生成的Servlet书上说放在tomcat7\work\Catalina\localhost文件里，可是我找不到 2011-07-31 18:40everythingddd | 分类：其他编程语言 | 浏览3908次 tomcat编译jsp之后生成的Servlet书上说放在tomcat7\work\Catalina\localhost文件里，可是我找不到，，我的工
JAVA基础之 了解import java.io.*的作用
MiaChen的博客
03-03 2万+
在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。 import java.io.*; 这个命令行将会命令编译器载入java_installation/java/io路径下的所有类 如下图所示 ...
jdk源码学习——java篇——java.io.*
一剑轻语
08-26 672
java.io.*包含了11个接口和72个类 接口: java.io.Closaable, 继承自AutoCloseable。含有一个close方法 java.io.dataInput java.io.dataOutput 数据输入输出io接口涉及到数据和流的基本都是成对的，一个入一个出。 java.io.Serializable 仅一个接口名，无名称。序列化接口 java.i...
JavaSE 基础学习之五 —— IO 操作 (java. io.*)
琦小虾的代码世界
06-02 573
接上篇《JavaSE 基础学习之四 —— 异常的处理》 五. JavaSE 基础学习 —— IO 操作 (java. io.*) 1. 编码 字符编码就是按照某种格式某种规定将字符存储在计算机中。字符编码有非常多，每个国家都有自己规定的字符编码。常见的字符编码有几种：ASCII, Unicode, UTF-8, GBK（简体繁体融于一库）等 几种不同常用编码模式的特征： G...
Java中IO流简介_动力节点Java学院整理
08-30
IO流是Java中一个基本概念，理解IO流是Java开发中的一项重要技能。下面将对Java IO流进行详细的介绍。 什么是流 所谓“流”，就是一种抽象的数据的总称，它的本质是能够进行传输。流可以按照数据流向和处理数据的...
java中的IO整理完整版
04-14
以下是对Java IO的详细整理： 首先，Java中的`File`类是操作文件和目录的基础，它提供了许多方法来创建、删除、重命名文件以及检查文件属性。在案例1中，通过`new File("D:\\hello.txt")`创建了一个`File`对象，...
JAVA_IO流整理思维导图.emmx
06-04
JAVA_IO流整理思维导图.
Java IO复用_动力节点Java学院整理
08-30
在实际应用中，Java可以通过Java NIO（Non-blocking I/O）库来实现IO复用，NIO的Selector类对应于epoll的概念，可以注册多个Channel（对应于文件描述符），并在有事件发生时唤醒，从而实现高效的并发处理。...
javaIO流思维导图
07-20
自己整理了一下javaIO流的相关知识点 用xmind软件做了一下
MSOCache office问题
weixin_34019929的博客
08-24 345
\MSOCache 链接：https://pan.baidu.com/s/1dVvjYnD0D6DG6oFK_Mww2w密码：qrvp undefied 转载于:https://www.cnblogs.com/rhxuza1993/p/9530082.html
MSOCache文件夹能否删除？
Bobit - CSDN博客
06-07 9469
这就是Office安装时的缓存文件，如果删除的话，那么下次要补充安装一些组件的时候可能需要插入光盘，不过有安装光盘或ISO的话，就可以删除它了！
java基础（IO)（java.io.*)
luofengliubi的博客
03-03 545
java 1.8 api文档：https://www.mklab.cn/api/jdk/8/cn 1.流的概念 程序运行在内存中，而文件存储在存储设备（硬盘）中，所以需要流作为通道。 2.字节流 2.1.文件字节流 2.2.字节缓冲流 2.3.对象流 3.字符流 3.1.文件字符流 3.2.字符缓冲流 ...
Java基础之IO流详解及使用方式（建议收藏）
SeeYouAgain的博客
02-14 1802
Java基础的IO流的基本知识内容详细说明与使用规则
Java流操作——Stream（一）
s13073660520的博客
09-08 600
流是一种用来以“做什么而非怎么做”的方式处理集合。
JAVA中流（Stream）的操作
凌霰的博客
08-05 555
JAVA中流（Stream）的操作
Java 常用IO流操作详解
热门推荐
MAGIC
05-22 3万+
IO流大家肯定不陌生，简单整理了一下常用IO流基本用法，其他的IO流以后有时间在整理。 1.基本概念IO：Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。2.IO流的分类图示：（主要IO流） 3.字节流（1）.字节流基类1）.InputStreamInputStream：字节输入流基类，抽象类是表示字节输入流的所有
Java IO
weixin_34124939的博客
09-10 958
一、java io 概述 1.1 相关概念 Java IO Java IO即Java 输入输出系统。不管我们编写何种应用，都难免和各种输入输出相关的媒介打交道，其实和媒介进行IO的过程是十分复杂的，这要考虑的因素特别多，比如我们要考虑和哪种媒介进行IO（文件、控制台、网络），我们还要考虑具体和它们的通信方式（顺序、随机、二...
Java中IO流的使用方法之内存操作流
Ninja_Z的博客
03-21 2294
整理源于Java核心技术精讲 某个操作必须发生IO操作，但是又不希望有一些临时文件产生，肯定无法使用之前的文件操作流。为解决问题，提供了内存操作流，即对内存进行操作的终端，以发生IO操作关系。 字节内存操作流：内存输入流(ByteArrayInputStream) 内存输出流(ByteArrayOutputStream) 字符内存操作流：内存输入流(CharArrayReader) 内存输
java基础中IO知识点的整理
最新发布
06-01
好的，关于Java IO的知识点整理如下： 一、IO流的分类 1.按数据流向：输入流、输出流 2.按操作单元：字节流、字符流 3.按角色：节点流、处理流 二、字节流和字符流的区别 1.字节流操作的是8位字节，适用于二进制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值