程序博客网 > 淘宝怎么邮费退款

JAVA中IO整理

来源：互联网 发布：淘宝怎么邮费退款 编辑：程序博客网 时间：2024/05/16 15:45

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



淘宝怎么邮费退款 淘宝怎么邮费退款
原创粉丝点击
热门IT博客
linux 查看服务器类型linux 查看服务器类型
c语言long doublec语言long double
桌面desktop.ini 知乎
淘宝好评价可以修改吗
房网通软件
sql语句修改字段属性
资源优化配置理论
mysql设置主键自增长
中国人工智能产品
织梦软件频道
java b2b2c 开源下载
把mac照片怎么传邮箱
王小二果园淘宝店铺
电视控软件
代码优化的方法和准则
淘宝怎么领内部优惠券
专业手机视频数据恢复
广告公司设计软件
淘宝上,货返是什么意思
缠论均线指标公式源码
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 工程学专业 通信工程学啥 装饰人体工程学 生物工程学 办公室人体工程学 工程学采矿 金融工程学什么 工程学300 工程学选择 电气工程学 电子工程学 交通运输工程学 交通工程学第二版 wow工程学 分子工程学 汽车工程学 车辆工程学什么 人体工程学手机 人体工程学下载 工程学机器人 工程学附魔 人体工程学数据 工程学1 600攻略 符合人体工程学 人体工程学概论 航空维修工程学 系统工程学 魔兽怀旧服工程学攻略 魔兽工程学攻略1到300 怀旧魔兽工程学攻略1到300 怀旧服工程学150以上在哪学 人体工程学与室内设计 魔兽世界工程学攻略 工程学225以后哪儿学 工程学包括哪些专业 徐州工程学院校学生会 工程专业排名 黑工程专业 质量工程专业 工程学习网 魔兽世界怀旧服工程学攻略

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里