Java IO 流详解-优快云博客

BufferedReader的小例子

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

1. BufferedReaderbuf=newBufferedReader(

2. newInputStreamReader(System.in));

下面给一个实例：

1. importjava.io.BufferedReader;

2. importjava.io.IOException;

3. importjava.io.InputStreamReader;

5. /**

6. *使用缓冲区从键盘上读入内容

7. **/

8. publicclassBufferedReaderDemo{

9. publicstaticvoidmain(String[]args){

10.BufferedReaderbuf=newBufferedReader(

11.newInputStreamReader(System.in));

12.Stringstr=null;

13.System.out.println("请输入内容");

14.try{

15.str=buf.readLine();

16.}catch(IOExceptione){

17.e.printStackTrace();

18.}

19.System.out.println("你输入的内容是："+str);

20.}

21.}

运行结果：

请输入内容

dasdas

你输入的内容是：dasdas

Scanner类

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

1. importjava.util.Scanner;

3. /**

4. *Scanner的小例子，从键盘读数据

5. **/

6. publicclassScannerDemo{

7. publicstaticvoidmain(String[]args){

8. Scannersca=newScanner(System.in);

9. //读一个整数

10.inttemp=sca.nextInt();

11.System.out.println(temp);

12.//读取浮点数

13.floatflo=sca.nextFloat();

14.System.out.println(flo);

15.//读取字符

16.//...等等的，都是一些太基础的，就不师范了。

17.}

18.}

其实Scanner可以接受任何的输入流

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

1. importjava.io.File;

2. importjava.io.FileNotFoundException;

3. importjava.util.Scanner;

5. /**

6. *Scanner的小例子，从文件中读内容

7. **/

8. publicclassScannerDemo{

9. publicstaticvoidmain(String[]args){

10.

11.Filefile=newFile("d:"+File.separator+"hello.txt");

12.Scannersca=null;

13.try{

14.sca=newScanner(file);

15.}catch(FileNotFoundExceptione){

16.e.printStackTrace();

17.}

18.Stringstr=sca.next();

19.System.out.println("从文件中读取的内容是："+str);

20.}

21.}

【运行结果】：

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

数据操作流DataOutputStream、DataInputStream类

1. importjava.io.DataOutputStream;

2. importjava.io.File;

3. importjava.io.FileOutputStream;

4. importjava.io.IOException;

6. publicclassDataOutputStreamDemo{

7. publicstaticvoidmain(String[]args)throwsIOException{

8. Filefile=newFile("d:"+File.separator+"hello.txt");

9. char[]ch={'A','B','C'};

10.DataOutputStreamout=null;

11.out=newDataOutputStream(newFileOutputStream(file));

12.for(chartemp:ch){

13.out.writeChar(temp);

14.}

15.out.close();

16.}

17.}

A B C

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

1. importjava.io.DataInputStream;

2. importjava.io.File;

3. importjava.io.FileInputStream;

4. importjava.io.IOException;

6. publicclassDataOutputStreamDemo{

7. publicstaticvoidmain(String[]args)throwsIOException{

8. Filefile=newFile("d:"+File.separator+"hello.txt");

9. DataInputStreaminput=newDataInputStream(newFileInputStream(file));

10.char[]ch=newchar[10];

11.intcount=0;

12.chartemp;

13.while((temp=input.readChar())!='C'){

14.ch[count++]=temp;

15.}

16.System.out.println(ch);

17.}

18.}

【运行结果】：

合并流 SequenceInputStream

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

1. importjava.io.File;

2. importjava.io.FileInputStream;

3. importjava.io.FileOutputStream;

4. importjava.io.IOException;

5. importjava.io.InputStream;

6. importjava.io.OutputStream;

7. importjava.io.SequenceInputStream;

9. /**

10.*将两个文本文件合并为另外一个文本文件

11.**/

12.publicclassSequenceInputStreamDemo{

13.publicstaticvoidmain(String[]args)throwsIOException{

14.Filefile1=newFile("d:"+File.separator+"hello1.txt");

15.Filefile2=newFile("d:"+File.separator+"hello2.txt");

16.Filefile3=newFile("d:"+File.separator+"hello.txt");

17.InputStreaminput1=newFileInputStream(file1);

18.InputStreaminput2=newFileInputStream(file2);

19.OutputStreamoutput=newFileOutputStream(file3);

20.//合并流

21.SequenceInputStreamsis=newSequenceInputStream(input1,input2);

22.inttemp=0;

23.while((temp=sis.read())!=-1){

24.output.write(temp);

25.}

26.input1.close();

27.input2.close();

28.output.close();

29.sis.close();

30.}

31.}

【运行结果】

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

文件压缩 ZipOutputStream类

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

1. importjava.io.File;

2. importjava.io.FileInputStream;

3. importjava.io.FileOutputStream;

4. importjava.io.IOException;

5. importjava.io.InputStream;

6. importjava.util.zip.ZipEntry;

7. importjava.util.zip.ZipOutputStream;

9. publicclassZipOutputStreamDemo1{

10.publicstaticvoidmain(String[]args)throwsIOException{

11.Filefile=newFile("d:"+File.separator+"hello.txt");

12.FilezipFile=newFile("d:"+File.separator+"hello.zip");

13.InputStreaminput=newFileInputStream(file);

14.ZipOutputStreamzipOut=newZipOutputStream(newFileOutputStream(

15.zipFile));

16.zipOut.putNextEntry(newZipEntry(file.getName()));

17.//设置注释

18.zipOut.setComment("hello");

19.inttemp=0;

20.while((temp=input.read())!=-1){

21.zipOut.write(temp);

22.}

23.input.close();

24.zipOut.close();

25.}

26.}

【运行结果】

运行结果之前，我创建了一个hello.txt的文件，原本大小56个字节，但是压缩之后产生hello.zip之后，居然变成了175个字节，有点搞不懂。
不过结果肯定是正确的，我只是提出我的一个疑问而已。

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

1. importjava.io.File;

2. importjava.io.FileInputStream;

3. importjava.io.FileOutputStream;

4. importjava.io.IOException;

5. importjava.io.InputStream;

6. importjava.util.zip.ZipEntry;

7. importjava.util.zip.ZipOutputStream;

9. /**

10.*一次性压缩多个文件

11.**/

12.publicclassZipOutputStreamDemo2{

13.publicstaticvoidmain(String[]args)throwsIOException{

14.//要被压缩的文件夹

15.Filefile=newFile("d:"+File.separator+"temp");

16.FilezipFile=newFile("d:"+File.separator+"zipFile.zip");

17.InputStreaminput=null;

18.ZipOutputStreamzipOut=newZipOutputStream(newFileOutputStream(

19.zipFile));

20.zipOut.setComment("hello");

21.if(file.isDirectory()){

22.File[]files=file.listFiles();

23.for(inti=0;i<files.length;++i){

24.input=newFileInputStream(files[i]);

25.zipOut.putNextEntry(newZipEntry(file.getName()

26.+File.separator+files[i].getName()));

27.inttemp=0;

28.while((temp=input.read())!=-1){

29.zipOut.write(temp);

30.}

31.input.close();

32.}

33.}

34.zipOut.close();

35.}

36.}

【运行结果】

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

接下来看看压缩之后的：

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

1. importjava.io.File;

2. importjava.io.IOException;

3. importjava.util.zip.ZipFile;

5. /**

6. *ZipFile演示

7. **/

8. publicclassZipFileDemo{

9. publicstaticvoidmain(String[]args)throwsIOException{

10.Filefile=newFile("d:"+File.separator+"hello.zip");

11.ZipFilezipFile=newZipFile(file);

12.System.out.println("压缩文件的名称为："+zipFile.getName());

13.}

14.}

【运行结果】：

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

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

1. importjava.io.File;

2. importjava.io.FileOutputStream;

3. importjava.io.IOException;

4. importjava.io.InputStream;

5. importjava.io.OutputStream;

6. importjava.util.zip.ZipEntry;

7. importjava.util.zip.ZipFile;

9. /**

10.*解压缩文件（压缩文件中只有一个文件的情况）

11.**/

12.publicclassZipFileDemo2{

13.publicstaticvoidmain(String[]args)throwsIOException{

14.Filefile=newFile("d:"+File.separator+"hello.zip");

15.FileoutFile=newFile("d:"+File.separator+"unZipFile.txt");

16.ZipFilezipFile=newZipFile(file);

17.ZipEntryentry=zipFile.getEntry("hello.txt");

18.InputStreaminput=zipFile.getInputStream(entry);

19.OutputStreamoutput=newFileOutputStream(outFile);

20.inttemp=0;

21.while((temp=input.read())!=-1){

22.output.write(temp);

23.}

24.input.close();

25.output.close();

26.}

27.}

【运行结果】：
解压缩之前：

这个压缩文件还是175字节
解压之后产生：

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

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

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

1. importjava.io.File;

2. importjava.io.FileInputStream;

3. importjava.io.FileOutputStream;

4. importjava.io.IOException;

5. importjava.io.InputStream;

6. importjava.io.OutputStream;

7. importjava.util.zip.ZipEntry;

8. importjava.util.zip.ZipFile;

9. importjava.util.zip.ZipInputStream;

10.

11./**

12.*解压缩一个压缩文件中包含多个文件的情况

13.**/

14.publicclassZipFileDemo3{

15.publicstaticvoidmain(String[]args)throwsIOException{

16.Filefile=newFile("d:"+File.separator+"zipFile.zip");

17.FileoutFile=null;

18.ZipFilezipFile=newZipFile(file);

19.ZipInputStreamzipInput=newZipInputStream(newFileInputStream(file));

20.ZipEntryentry=null;

21.InputStreaminput=null;

22.OutputStreamoutput=null;

23.while((entry=zipInput.getNextEntry())!=null){

24.System.out.println("解压缩"+entry.getName()+"文件");

25.outFile=newFile("d:"+File.separator+entry.getName());

26.if(!outFile.getParentFile().exists()){

27.outFile.getParentFile().mkdir();

28.}

29.if(!outFile.exists()){

30.outFile.createNewFile();

31.}

32.input=zipFile.getInputStream(entry);

33.output=newFileOutputStream(outFile);

34.inttemp=0;

35.while((temp=input.read())!=-1){

36.output.write(temp);

37.}

38.input.close();

39.output.close();

40.}

41.}

42.}

【运行结果】：
被解压的文件：

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

PushBackInputStream回退流

1. importjava.io.ByteArrayInputStream;

2. importjava.io.IOException;

3. importjava.io.PushbackInputStream;

5. /**

6. *回退流操作

7. **/

8. publicclassPushBackInputStreamDemo{

9. publicstaticvoidmain(String[]args)throwsIOException{

10.Stringstr="hello,rollenholt";

11.PushbackInputStreampush=null;

12.ByteArrayInputStreambat=null;

13.bat=newByteArrayInputStream(str.getBytes());

14.push=newPushbackInputStream(bat);

15.inttemp=0;

16.while((temp=push.read())!=-1){

17.if(temp==','){

18.push.unread(temp);

19.temp=push.read();

20.System.out.print("(回退"+(char)temp+")");

21.}else{

22.System.out.print((char)temp);

23.}

24.}

25.}

26.}

【运行结果】：
hello(回退,) rollenholt

1. /**

2. *取得本地的默认编码

3. **/

4. publicclassCharSetDemo{

5. publicstaticvoidmain(String[]args){

6. System.out.println("系统默认编码为："+System.getProperty("file.encoding"));

7. }

8. }

【运行结果】：

系统默认编码为：GBK

乱码的产生：

1. importjava.io.File;

2. importjava.io.FileOutputStream;

3. importjava.io.IOException;

4. importjava.io.OutputStream;

6. /**

7. *乱码的产生

8. **/

9. publicclassCharSetDemo2{

10.publicstaticvoidmain(String[]args)throwsIOException{

11.Filefile=newFile("d:"+File.separator+"hello.txt");

12.OutputStreamout=newFileOutputStream(file);

13.byte[]bytes="你好".getBytes("ISO8859-1");

14.out.write(bytes);

15.out.close();

16.}

17.}

【运行结果】：

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

对象的序列化

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

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

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

1. importjava.io.*;

2. /**

3. *实现具有序列化能力的类

4. **/

5. publicclassSerializableDemoimplementsSerializable{

6. publicSerializableDemo(){

8. }

9. publicSerializableDemo(Stringname,intage){

10.this.name=name;

11.this.age=age;

12.}

13.@Override

14.publicStringtoString(){

15.return"姓名："+name+"年龄："+age;

16.}

17.privateStringname;

18.privateintage;

19.}

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

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

先给一个ObjectOutputStream的例子吧：

1. importjava.io.Serializable;

2. importjava.io.File;

3. importjava.io.FileOutputStream;

4. importjava.io.IOException;

5. importjava.io.ObjectOutputStream;

7. /**

8. *实现具有序列化能力的类

9. **/

10.publicclassPersonimplementsSerializable{

11.publicPerson(){

12.

13.}

14.

15.publicPerson(Stringname,intage){

16.this.name=name;

17.this.age=age;

18.}

19.

20.@Override

21.publicStringtoString(){

22.return"姓名："+name+"年龄："+age;

23.}

24.

25.privateStringname;

26.privateintage;

27.}

28./**

29.*示范ObjectOutputStream

30.**/

31.publicclassObjectOutputStreamDemo{

32.publicstaticvoidmain(String[]args)throwsIOException{

33.Filefile=newFile("d:"+File.separator+"hello.txt");

34.ObjectOutputStreamoos=newObjectOutputStream(newFileOutputStream(

35.file));

36.oos.writeObject(newPerson("rollen",20));

37.oos.close();

38.}

39.}

【运行结果】：

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

虽然我们不能直接查看里面的内容，但是我们可以使用ObjectInputStream类查看：

1. importjava.io.File;

2. importjava.io.FileInputStream;

3. importjava.io.ObjectInputStream;

5. /**

6. *ObjectInputStream示范

7. **/

8. publicclassObjectInputStreamDemo{

9. publicstaticvoidmain(String[]args)throwsException{

10.Filefile=newFile("d:"+File.separator+"hello.txt");

11.ObjectInputStreaminput=newObjectInputStream(newFileInputStream(

12.file));

13.Objectobj=input.readObject();

14.input.close();

15.System.out.println(obj);

16.}

17.}

【运行结果】

姓名：rollen年龄：20

到底序列化什么内容呢?

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

Externalizable接口

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

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

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

1. packageIO;

3. importjava.io.Externalizable;

4. importjava.io.File;

5. importjava.io.FileInputStream;

6. importjava.io.FileOutputStream;

7. importjava.io.IOException;

8. importjava.io.ObjectInput;

9. importjava.io.ObjectInputStream;

10.importjava.io.ObjectOutput;

11.importjava.io.ObjectOutputStream;

12.

13./**

14.*序列化和反序列化的操作

15.**/

16.publicclassExternalizableDemo{

17.publicstaticvoidmain(String[]args)throwsException{

18.ser();//序列化

19.dser();//反序列话

20.}

21.

22.publicstaticvoidser()throwsException{

23.Filefile=newFile("d:"+File.separator+"hello.txt");

24.ObjectOutputStreamout=newObjectOutputStream(newFileOutputStream(

25.file));

26.out.writeObject(newPerson("rollen",20));

27.out.close();

28.}

29.

30.publicstaticvoiddser()throwsException{

31.Filefile=newFile("d:"+File.separator+"hello.txt");

32.ObjectInputStreaminput=newObjectInputStream(newFileInputStream(

33.file));

34.Objectobj=input.readObject();

35.input.close();

36.System.out.println(obj);

37.}

38.}

39.

40.classPersonimplementsExternalizable{

41.publicPerson(){

42.

43.}

44.

45.publicPerson(Stringname,intage){

46.this.name=name;

47.this.age=age;

48.}

49.

50.@Override

51.publicStringtoString(){

52.return"姓名："+name+"年龄："+age;

53.}

54.

55.//复写这个方法，根据需要可以保存的属性或者具体内容，在序列化的时候使用

56.@Override

57.publicvoidwriteExternal(ObjectOutputout)throwsIOException{

58.out.writeObject(this.name);

59.out.writeInt(age);

60.}

61.

62.//复写这个方法，根据需要读取内容反序列话的时候需要

63.@Override

64.publicvoidreadExternal(ObjectInputin)throwsIOException,

65.ClassNotFoundException{

66.this.name=(String)in.readObject();

67.this.age=in.readInt();

68.}

69.

70.privateStringname;

71.privateintage;

72.}

【运行结果】：

姓名：rollen年龄：20

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

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

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

下面举一个例子：

1. packageIO;

3. importjava.io.File;

4. importjava.io.FileInputStream;

5. importjava.io.FileOutputStream;

6. importjava.io.ObjectInputStream;

7. importjava.io.ObjectOutputStream;

8. importjava.io.Serializable;

10./**

11.*序列化和反序列化的操作

12.**/

13.publicclassserDemo{

14.publicstaticvoidmain(String[]args)throwsException{

15.ser();//序列化

16.dser();//反序列话

17.}

18.

19.publicstaticvoidser()throwsException{

20.Filefile=newFile("d:"+File.separator+"hello.txt");

21.ObjectOutputStreamout=newObjectOutputStream(newFileOutputStream(

22.file));

23.out.writeObject(newPerson1("rollen",20));

24.out.close();

25.}

26.

27.publicstaticvoiddser()throwsException{

28.Filefile=newFile("d:"+File.separator+"hello.txt");

29.ObjectInputStreaminput=newObjectInputStream(newFileInputStream(

30.file));

31.Objectobj=input.readObject();

32.input.close();

33.System.out.println(obj);

34.}

35.}

36.

37.classPerson1implementsSerializable{

38.publicPerson1(){

39.

40.}

41.

42.publicPerson1(Stringname,intage){

43.this.name=name;

44.this.age=age;

45.}

46.

47.@Override

48.publicStringtoString(){

49.return"姓名："+name+"年龄："+age;

50.}

51.

52.//注意这里

53.privatetransientStringname;

54.privateintage;

55.}

【运行结果】：

姓名：null年龄：20

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

1. importjava.io.File;

2. importjava.io.FileInputStream;

3. importjava.io.FileOutputStream;

4. importjava.io.ObjectInputStream;

5. importjava.io.ObjectOutputStream;

6. importjava.io.Serializable;

8. /**

9. *序列化一组对象

10.**/

11.publicclassSerDemo1{

12.publicstaticvoidmain(String[]args)throwsException{

13.Student[]stu={newStudent("hello",20),newStudent("world",30),

14.newStudent("rollen",40)};

15.ser(stu);

16.Object[]obj=dser();

17.for(inti=0;i<obj.length;++i){

18.Students=(Student)obj[i];

19.System.out.println(s);

20.}

21.}

22.

23.//序列化

24.publicstaticvoidser(Object[]obj)throwsException{

25.Filefile=newFile("d:"+File.separator+"hello.txt");

26.ObjectOutputStreamout=newObjectOutputStream(newFileOutputStream(

27.file));

28.out.writeObject(obj);

29.out.close();

30.}

31.

32.//反序列化

33.publicstaticObject[]dser()throwsException{

34.Filefile=newFile("d:"+File.separator+"hello.txt");

35.ObjectInputStreaminput=newObjectInputStream(newFileInputStream(

36.file));

37.Object[]obj=(Object[])input.readObject();

38.input.close();

39.returnobj;

40.}

41.}

42.

43.classStudentimplementsSerializable{

44.publicStudent(){

45.

46.}

47.

48.publicStudent(Stringname,intage){

49.this.name=name;

50.this.age=age;

51.}

52.

53.@Override

54.publicStringtoString(){

55.return"姓名："+name+"年龄："+age;

56.}

57.

58.privateStringname;

59.privateintage;

60.}

【运行结果】：

姓名： hello年龄：20

姓名： world年龄：30

姓名： rollen年龄：40

JAVA_IO2