java.io包使用

目标

•了解java.io包

•运用File类对文件或目录的属性进行操作

•理解流，理解输入/输出流的概念

•运用FileInputStream类和FileOutputStream类读/写字节文件

•运用FileReader类和FileWriter类配合BufferedReader类和BufferedWriter类读/写字符文件

•使用BufferedReader类从控制台接受输入

•运用DataInputStream类和DataOutputStream类读写数据文件

java.io包简介

•java.io包也是Java内置的包，其中包含一系列对文件和目录的属性进行操作，对文件进行读写操作的类；

•程序中如果要使用到该包中的类，对文件或流进行操作，
       则必须显式地声明如下语句：

                                                         import java.io.*;

文件

•什么是文件？

  文件可以认为是相关记录或存放在一起的数据的集合；

•文件一般是存放在磁盘上的，例如：硬盘、软盘和光盘等等。

File类

•File类的对象不但可以表示文件，还可以表示目录，在程序中一个File类对象可以代表一个文件或目录；

•当创建一个文件对象后，就可以利用它来对文件或目录的属性进行操作，如：文件名、最后修改日期、文件大小等等；

•需要注意的是，File对象并不能直接对文件进行读/写操作(通过流进行读写操作)，只能查看文件的属性；

File类的构造方法

•File类的构造方法有4种重载方式，常用的如下：

构 造 方 法	说    明
File(String pathname)	指定文件（或目录）名和路径创建文件对象

实例：

[java]  view plain copy print ?

1.        //在当前目录下创建一个与aaa.txt文件名相关联的文件对象  
2. File f1 = new File("aaa.txt");  
3. //指明详细的路径以及文件名，请注意双斜线  
4. File f2 = new File("D:\\Java\\Hello.java");  

File类中的常用方法

方 法 原 型	说    明
boolean exists()	判断文件是否存在，存在返回true，否则返回false
boolean isFile()	判断是否为文件，是文件返回true，否则返回false
boolean isDirectory()	判断是否为目录，是目录返回true，否则返回false
String getName()	获得文件的名称
String getAbsolutePath()	获得文件的绝对路径
long length()	获得文件的长度（字节数）
boolean createNewFile() throws IOException	创建新文件，创建成功返回true，否则返回false，有可能抛出IOException异常，必须捕捉
boolean delete()	删除文件，删除成功返回true，否则返回false
File[] listFiles()	返回文件夹内的子文件与子文件夹的数组

File类示例

[java]  view plain copy print ?

1. public class FileDemo  
2. {  
3.   public static void main(String[] args)  
4.   {  
5.     //创建一个文件对象，使之与一个文件关联  
6.     File file = new File("test.txt");  
7.   
8.     //显示与文件有关的属性信息  
9.     System.out.println("文件或目录是否存在：" + file.exists());  
10.     System.out.println("是文件吗：" + file.isFile());  
11.     System.out.println("是目录吗：" + file.isDirectory());  
12.     System.out.println("名称：" + file.getName());  
13.     System.out.println("绝对路径：" + file.getAbsolutePath());  
14.     System.out.println("文件大小：" + file.length());  
15.   }  
16. }  

关于如何创建目录和文件.

请大家自行参阅相关API：createNewFile()     mkDir()   mkDirs()   isExists()

stream（流）

•流是指一连串流动的数据信号，是以先进先出的方式发送和接收数据的通道。

流的类型

•根据流动方向的不同，流分为输入流和输出流；

•对于输入和输出流，由于传输格式的不同，又分为字节流和字符流：

        >字节流是指8位的通用字节流，以字节为基本单位，在java.io包中，
                   对于字节流进行操作的类大部分继承于InputStream（输入字节流）类和OutputStream（输出字节流）类；

        >字符流是指16位的Unicode字符流，以字符（两个字节）为基本单位，

                   非常适合处理字符串和文本，对于字符流进行操作的类大部分继承于Reader（读取流）类和Writer（写入流）类

InputStream抽象类介绍

                                  稍后带来

使用FileInputStream类读文件

•FileInputStream类称为文件输入流，继承于InputStream类，是进行文件读操作的最基本类；

•它的作用是将文件中的数据输入到内存中，我们可以利用它来读文件；

•由于它属于字节流，因此在读取Unicode字符（如中文）的文件时可能会出现问题。

FileInputStream类的构造方法

•FileInputStream类的构造方法有3种重载方式，以下是常用的几种。

构 造 方 法	说    明
FileInputStream(File file) throws FileNotFoundException	使用File对象创建文件输入流对象，如果文件打开失败，将抛出异常
FileInputStream(String name) throws FileNotFoundException	使用文件名或路径创建文件输入流对象，如果文件打开失败，将抛出异常

FileInputStream类的常用方法

方 法 原 型	说    明
int read() throws IOException	读取文件中的数据，一次读取一个字节，读取的数据作为返回值返回，如果读到文件末尾则返回-1，有可能抛异常，必须捕捉
int read(byte[] b) throws IOException	读取文件中的数据，将读到的数据存放到byte型数组中，并返回读取的字节的数量，未读到数据返回-1，有可能抛异常，必须捕捉
void close() throws IOException	关闭流对象，有可能抛异常，必须捕捉

FileInputStream对象读文件示例1：

[java]  view plain copy print ?

1. public class FileInputStreamDemo1 {  
2.   public static void main(String[] args) {  
3.     try {  
4.       File file = new File("test.txt");  //创建文件对象  
5.       //使用文件对象创建文件输入流对象，相当于打开文件  
6.       FileInputStream fis = new FileInputStream(file);  
7.       for (int i = 0; i < file.length(); i++) {  
8.         char ch = (char)(fis.read());  //循环读取字符  
9.         System.out.print(ch);  
10.       }  
11.       System.out.println();  
12.       fis.close();     //关闭流  
13.     } catch (FileNotFoundException fnfe) {  
14.       System.out.println("文件打开失败。");  
15.     } catch (IOException ioe) {  
16.       ioe.printStackTrace();  
17.     }  
18.   }  
19. }  

FileInputStream对象读文件示例2：

[java]  view plain copy print ?

1. public class FileInputStreamDemo2 {  
2.   public static void main(String[] args) {  
3.     try {  
4.       File file = new File("test.txt");  //创建文件对象  
5.       FileInputStream fis = new FileInputStream(file);  
6.       //根据文件的字节长度创建字节数组  
7.       byte[] buf = new byte[(int)(file.length())];  
8.       fis.read(buf);  //读取文件中的数据存放到字节数组中  
9.       String str = new String(buf);  //利用字节数组创建字符串  
10.       System.out.println(str);   //打印字符串  
11.       fis.close();     //关闭流  
12.     } catch (FileNotFoundException fnfe) {  
13.       System.out.println("文件打开失败。");  
14.     } catch (IOException ioe) {  
15.       ioe.printStackTrace();  
16.     }  
17.   }  
18. }  

案例

•图片数据的读取

[java]  view plain copy print ?

1. import java.io.File;  
2. import java.io.FileInputStream;  
3. import java.io.FileNotFoundException;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.io.OutputStream;  
8.   
9. /** 
10.  * 复制数据 
11.  */  
12. public class Test3 {  
13.     public static void main(String[] args) throws IOException {  
14.         File f=new File("r:\\io\\DSC_4539.JPG");  
15.         File of=new File("r:\\io\\b.JPG");  
16.         if(!of.exists()){  
17.             of.createNewFile();  
18.         }  
19.         if(f.exists()){  
20.             InputStream fis=new FileInputStream(f);  
21.             OutputStream fos=new FileOutputStream(of,true);  
22.               
23.             byte[] temp=new byte[1024];  
24.             int flag=-1;  
25.             while((flag=fis.read(temp))!=-1){  
26.                 fos.write(temp);  
27.             }  
28.             fis.close();  
29.             fos.close();  
30.         }  
31.           
32.     }  
33.   
34. }  

OutputStream抽象类介绍

                                                稍后带来

使用FileOutputStream类写文件

•FileOutputStream类称为文件输出流，继承于OutputStream类，是进行文件写操作的最基本类；

•它的作用是将内存中的数据输出到文件中，我们可以利用它来写文件。

FileOutputStream类的构造方法

•FileOutputStream类的构造方法有5种重载方式，以下是常用的几种。

构 造 方 法	说    明
FileOutputStream(File file) throws FileNotFoundException	使用File对象创建文件输出流对象，如果文件打开失败，将抛出异常
FileOutputStream(File file, boolean append) throws FileNotFoundException	使用File对象创建文件输出流对象，并由参数append指定是否追加文件内容，true为追加，false为不追加，异常情况同上
FileOutputStream(String name) throws FileNotFoundException	直接使用文件名或路径创建文件输出流对象，异常情况同上
FileOutputStream(String name, boolean append) throws FileNotFoundException	直接使用文件名或路径创建文件输出流对象，并由参数append指定是否追加，异常情况同上

FileOutputStream类的常用方法

方 法 原 型	说    明
void write(int b) throws IOException	往文件中写数据，一次写一个字节，有可能抛异常，必须捕捉
void write(byte[] b) throws IOException	往文件中写数据，将byte数组中的数据全部写入到文件中，有可能抛异常，必须捕捉
void close() throws IOException	关闭流对象，有可能抛异常，必须捕捉

FileOutputStream对象写文件示例1：

[java]  view plain copy print ?

1. public class FileOutputStreamDemo1  
2. {  
3.   //在函数内部不进行异常处理，将异常抛出函数外部  
4.   public static void main(String[] args) throws IOException  
5.   {  
6.     String str = "Hello world!";  
7.     File file = new File("test.txt");  //创建文件对象  
8.     //通过文件对象创建文件输出流对象  
9.     //附加第二个参数true，指定进行文件追加，默认为不追加  
10.     FileOutputStream fos = new FileOutputStream(file, true);  
11.       
12.     //逐个将字符写入到文件中  
13.     for (int i = 0; i < str.length(); i++)  
14.     {  
15.       fos.write(str.charAt(i));  
16.     }  
17.     fos.close();    //关闭流  
18.   }  
19. }  

FileOutputStream对象写文件示例2：

[java]  view plain copy print ?

1. public class FileOutputStreamDemo2  
2. {  
3.   //在函数内部不进行异常处理，将异常抛出函数外部  
4.   public static void main(String[] args) throws Exception  
5.   {  
6.     String str = "I Love Java";  
7.     //通过文件名创建文件输出流对象  
8.     FileOutputStream fos = new FileOutputStream("test.txt");  
9.       
10.     //将字符串转化为字节数组  
11.     byte[] buffer = str.getBytes();  
12.     //将字节数组中包含的数据一次性写入到文件中  
13.     fos.write(buffer);  
14.     //关闭流  
15.     fos.close();  
16.   }  
17. }  

FileInputStream/FileOutputStream小结

•FileInputStream类和FileOutputStream类是成对出现的，一个进行输入（读文件）操作，一个进行输出（写文件）操作；

•由于采用字节方式进行数据传输，不必考虑数据的格式问题，这两个类对文件操作的效率较高；

•可以使用这两个类完成复制文件的操作。

复制文件示例

[java]  view plain copy print ?

1. public class CopyFileDemo {  
2.   public static void main(String[] args) throws IOException {  
3.     File srcFile = new File("src.dat");    //源文件对象  
4.     File destFile = new File("dest.dat");  //目标文件对象  
5.     if (!(destFile.exists())) {  //判断目标文件是否存在  
6.       destFile.createNewFile();  //如果不存在则创建新文件  
7.     }  
8.     //使用源文件对象创建文件输入流对象  
9.     FileInputStream fis = new FileInputStream(srcFile);  
10.     //使用目标文件对象创建文件输出流对象  
11.     FileOutputStream fos = new FileOutputStream(destFile);  
12.     byte[] buf = new byte[1024];  //创建字节数组，作为临时缓冲  
13.     System.out.println("开始复制文件...");  
14.     while (fis.read(buf) != -1) {  //循环从文件输入流中读取数据  
15.       fos.write(buf);    //写入到文件输出流中  
16.     }  
17.     System.out.println("文件复制成功！");  
18.     fis.close();    //关闭流  
19.     fos.close();  
20.   }  
21. }  

 字符流

•FileInputStram类和FileOutputStream类虽然可以高效率地读/写文件，但对于Unicode编码的文件，使用它们有可能出现乱码；

•考虑到Java是跨平台的语言，要经常操作Unicode编码的文件，使用字符流操作文件是有必要的；

•使用字符流将涉及到以下4个类：

                                                      >FileReader类和FileWriter类；

                                                      >BufferedReader类和BufferedWriter类。

FileReader类

•FileReader类称为文件读取流，允许以字符流的形式对文件进行读操作，其构造方法有3种重载方式，
   以下是常用的几种：

构 造 方 法	说    明
FileReader(File file) throws FileNotFoundException	使用File对象创建文件读取流对象，如果文件打开失败，将抛出异常
FileReader(String name) throws FileNotFoundException	使用文件名或路径创建文件读取流对象，如果文件打开失败，将抛出异常

•该类将从文件中逐个地读取字符，效率比较低下，因此一般将该类对象包装到缓冲流中进行操作。

BufferedReader类

•BufferedReader类主要为字符流提供缓冲，以提高效率，其构造方法有2种重载方式，以下是常用的几种：

构 造 方 法	说    明
BufferedReader(Reader in)	将字符读取流对象包装成缓冲读取流对象

•以下是BufferedReader类的常用方法：

方 法 原 型	说    明
String readLine() throws IOException	从缓冲读取流中读取一行字符，以字符串的形式返回，有可能抛异常，必须捕捉
void close() throws IOException	关闭流对象，有可能抛异常，必须捕捉

FileReader配合BufferedReader读文件示例

[java]  view plain copy print ?

1. public class RraderDemo  
2. {  
3.   public static void main(String[] args) throws IOException  
4.   {  
5.     File file = new File("test.txt");  
6.     //通过文件对象创建文件读取流对象  
7.     FileReader fr = new FileReader(file);  
8.     //将文件读取流包装成缓冲读取流  
9.     BufferedReader br = new BufferedReader(fr);  
10.       
11.     String str;  
12.     while ((str = br.readLine()) != null)  //逐行读取数据  
13.     {  
14.       System.out.println(str);  
15.     }  
16.     br.close();   //关闭流  
17.     fr.close();   //关闭流  
18.   }  
19. }  

FileWriter类

•FileWriter类称为文件写入流，以字符流的形式对文件进行写操作，其构造方法有5种重载，
  以下是常用的几种：

构 造 方 法	说    明
FileWriter(File file) throws IOException	使用File对象创建文件写入流对象，如果文件打开失败，将抛出异常，必须捕捉
FileWriter(File file, boolean append) throws IOException	使用File对象创建文件写入流对象，并由参数append指定是否追加，异常情况同上
FileWriter(String name) throws IOException	直接使用文件名或路径创建文件写入流对象，异常情况同上
FileWriter(String name, boolean append) throws IOException	直接使用文件名或路径创建文件写入流对象，并由参数append指定是否追加，异常情况同上

•与FileReader类相似，FileWriter类同样需要使用缓冲流进行包装。

BufferedWriter类

•BufferedWriter类可以为FileWriter类提供缓冲，其构造方法有2种重载方式，
  以下是常用的几种：

构 造 方 法	说    明
BufferedWriter(Writer out)	将字符写入流对象包装成缓冲写入流对象

•以下是BufferedWriter类的常用方法：

方 法 原 型	说    明
void write(String str) throws IOException	将一行字符串写入到缓冲写入流中，有可能抛异常，必须捕捉
void newLine() throws IOException	将一个回车换行符写入到文件中，从而达到换行的效果，有可能抛异常，必须捕捉

FileWriter配合BufferedWriter写文件示例

[java]  view plain copy print ?

1. public class WriterDemo  
2. {  
3.   public static void main(String[] args) throws IOException  
4.   {  
5.     File file = new File("test.txt");  
6.     //通过文件对象创建文件输出字符流对象  
7.     FileWriter fw = new FileWriter(file);  
8.     //将文件输出字符流包装成缓冲流  
9.     BufferedWriter bw = new BufferedWriter(fw);  
10.     bw.write("大家好！");  
11.     bw.write("我正在学习Java。");  
12.     bw.newLine();    //换个新行  
13.     bw.write("请多多指教。");  
14.     bw.newLine();    //换新行  
15.     bw.write("Luckybug@21cn.com");  
16.     bw.close();      //关闭流  
17.     fw.close();      //关闭流  
18.   }  
19. }  

案例:

•使用字符流和缓冲流完成一个word文档的复制.

[java]  view plain copy print ?

1. import java.io.BufferedReader;  
2. import java.io.BufferedWriter;  
3. import java.io.File;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileReader;  
6. import java.io.FileWriter;  
7. import java.io.IOException;  
8.   
9.   
10. public class Test11 {  
11.   
12.       
13.     public static void main(String[] args) throws IOException {  
14.         String s="abcd中国家@#$%"+System.getProperty("line.separator")+"asdfsdf顺右面";  
15.         Test11 t=new Test11();  
16.         t.writeFile(s);  
17.         t.readFile();  
18.   
19.     }  
20.       
21.     public void readFile() throws IOException{  
22.         File f=new File("r:\\io\\reader.doc");  
23.         FileReader fr=new FileReader(f);  
24.         BufferedReader br=new BufferedReader(fr);  
25.         String ss=null;  
26.         while((ss=br.readLine())!=null){  
27.             System.out.println(ss);  
28.         }  
29.         br.close();  
30.         fr.close();  
31.     }  
32.       
33.     public void writeFile(String s) throws IOException{  
34.         File f=new File("r:\\io\\reader.doc");  
35.         FileWriter fr=new FileWriter(f);  
36.         BufferedWriter br=new BufferedWriter(fr);  
37.           
38.         br.write(s);  
39.           
40.         br.close();  
41.         fr.close();  
42.     }  
43.   
44. }  

过渡流

•InputStreamReader, InputStreamWriter

•字节流与字符流之间的桥梁.

•作用:   设置字符集的编码等

从控制台接受输入

•System.in的read方法可以从控制台接受输入；

•但由于in实际上是一个InputStream类的对象，它只能以字节形式接收数据，并且一次只能接受一个字节，这使输入操作很不便；

•必须将System.in进行处理，才可以顺利地从控制台接受输入，这将使用到:

                                                                                                                        >InputStreamReader类

                                                                                                                        >BufferedReader类

转换和包装System.in

•InputStreamReader类用于将InputStream类型的字节输入流对象转换成Reader类型的字符读取流对象；

•其构造方法有4种重载方式，常用的如下：

构 造 方 法	说    明
InputStreamReader(InputStream in)	将InputStream对象转换成Reader对象

•可以使用它来转换System.in，如：

  InputStreamReader isr = new InputStreamReader(System.in);

•这样的字符流效率很低，再使用BufferedReader类来为其建立缓冲，如：

   BufferedReader br = new BufferedReader(isr);

•这样，就可以从控制台接受输入了。

从控制台接受输入示例

[java]  view plain copy print ?

1. public class ConsoleInputDemo  
2. {  
3.   public static void main(String[] args) throws IOException  
4.   {  
5.     //将System.in转化成字符流对象  
6.     InputStreamReader isr = new InputStreamReader(System.in);  
7.     //用缓冲流进行包装  
8.     BufferedReader br = new BufferedReader(isr);  
9.       
10.     System.out.println("请输入您的姓名：");  
11.     String name = br.readLine();  //接受输入  
12.     System.out.println("请输入您的年龄：");  
13.     int age = Integer.parseInt(br.readLine());  //接受输入  
14.       
15.     System.out.println("您的姓名：" + name);  
16.     System.out.println("您的年龄：" + age);  
17.       
18.     br.close();   //关闭流  
19.     isr.close();  //关闭流  
20.   }  
21. }  

从控制台输入并写入到文件示例

[java]  view plain copy print ?

1. /*本例从控制台接受输入，然后写入到文件中，直到用户输入"!!!"为止*/  
2. File file = new File("input.txt");   //创建文件对象  
3. if (!file.exists())                  //判断该文件是否存在，如果不存在则创建新文件  
4. {  
5.     file.createNewFile();  
6. }  
7. FileWriter fr = new FileWriter(file);   //针对文件对象创建文件写入流对象  
8. BufferedWriter bw = new BufferedWriter(fr);   //为文件写入流建立缓冲流  
9.   
10. //将控制台输入对象转化成字符流，并建立缓冲流  
11. BufferedReader bin = new BufferedReader(new InputStreamReader(System.in));  
12.   
13. String str = bin.readLine();    //接受从控制台输入的一行字符串  
14. while (!(str.equals("!!!")))    //如果输入"!!!"则代表输入结束  
15. {  
16.     bw.write(str);              //将从控制台输入的字符串写入到文件中  
17.     bw.newLine();               //换新行  
18.     str = bin.readLine();       //再从控制台接受输入  
19. }  
20.   
21. //关闭所有已经打开的流  
22. bw.close();  
23. fr.close();  
24. bin.close();  

基本数据类型的读/写

•FileInputStream和FileOutputStream在读写文件时不考虑数据的类型；

•FileWriter和FileReader在读写文件时，将所有的数据都看做字符；

•有时候，我们需要将各种类型的数据写入文件或是从文件中读取，
                     DataInputStream类和DataOutputStream类可以满足需要。

DataInputStream类

•DataInputStream类可以输入任何类型的数据，但它不可以单独使用，需要要配合其它字节输入流一起使用；

•DataInputStream类的构造方法只有一种方式：

构 造 方 法	说    明
DataInputStream(InputStream in)	利用其它的字节输入流创建数据输入流对象

示例：

[java]  view plain copy print ?

1. //将文件输入流包装成数据输入流，以便从文件中读取各种类型的数据  
2.     FileInputStream fis = new FileInputStream("data.dat");  
3.     DataInputStream dis = new DataInputStream(fis);  

DataInputStream类的常用方法

方 法 原 型	说    明
final boolean readBoolean() throws IOException	从数据输入流中读取一个boolean型数据
final char readChar() throws IOException	从数据输入流中读取一个char型数据
final int readInt() throws IOException	从数据输入流中读取一个int型数据
final long readLong() throws IOException	从数据输入流中读取一个long型数据
final float readFloat() throws IOException	从数据输入流中读取一个float型数据
final double readDouble() throws IOException	从数据输入流中读取一个double型数据

DataOutputStream类

•DataOutputStream类可以输出任何类型的数据，同样也需要配合其他字节输出流一起使用；

•DataOutputStream类的构造方法如下：

构 造 方 法	说    明
DataOutputStream(OutputStream out)	利用其它的字节输出流创建数据输出流对象

示例：

[java]  view plain copy print ?

1. //将文件输出流包装成数据输出流，以便往文件中写入各种类型的数据  
2.     FileOutputStream fos = new FileOutputStream("data.dat");  
3.     DataOutputStream dos = new DataOutputStream(fos);  

DataOutputStream类的常用方法

方 法 原 型	说    明
final void writeBoolean(boolean v) throws IOException	往数据输出流中写入一个boolean型数据
final void writeChar(char v) throws IOException	往数据输出流中写入一个char型数据
final void writeInt(int v) throws IOException	往数据输出流中写入一个int型数据
final void writeLong(long v) throws IOException	往数据输出流中写入一个long型数据
final void writeFloat(float v) throws IOException	往数据输出流中写入一个float型数据
final void writeDouble(double v) throws IOException	往数据输出流中写入一个double型数据

中间处理流

•DataOutputStream流

   作用: 用来处理java的基本数据类型的.

   注意点: 怎么写入数据的顺序，就怎么读出来.

 示例：

[java]  view plain copy print ?

1. import java.io.DataInputStream;  
2. import java.io.DataOutputStream;  
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileNotFoundException;  
6. import java.io.FileOutputStream;  
7.   
8. public class Test8 {  
9.   
10.     public static void main(String[] args) throws Exception {  
11.         File f = new File("r:\\io\\dat.dat");  
12.   
13.         FileOutputStream fos = new FileOutputStream(f);  
14.         DataOutputStream dos = new DataOutputStream(fos);  
15.         dos.write(22);  
16.         dos.writeBoolean(true);  
17.         dos.writeChar('a');  
18.         dos.writeUTF("abc中国家####");  
19.   
20.         dos.close();  
21.         fos.close();  
22.           
23.           
24.         FileInputStream fis=new FileInputStream(f);  
25.         DataInputStream dis=new DataInputStream(fis);  
26.           
27.       System.out.println(  dis.read());  
28.       System.out.println(  dis.readBoolean());  
29.     }  
30.   
31. }  

•ObjectInputStream流

   作用：用来处理Object对象的流, 能将原来只能存在于VM中的对象存入到我们要求的存储介质中去了. 可以用来做数据缓存.

   注意点:1.  处理的对象都必须实现Serializable接口.  2. transiant关键字来修饰无需序列化的属性

示例：

[java]  view plain copy print ?

1. import java.io.DataInputStream;  
2. import java.io.DataOutputStream;  
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileNotFoundException;  
6. import java.io.FileOutputStream;  
7. import java.io.ObjectInputStream;  
8. import java.io.ObjectOutputStream;  
9. import java.io.Serializable;  
10.   
11. public class Test9 {  
12.   
13.     public static void main(String[] args) throws Exception {  
14.         File f = new File("r:\\io\\dat2.dat");  
15.   
16.         FileOutputStream fos = new FileOutputStream(f);  
17.         ObjectOutputStream dos = new ObjectOutputStream(fos);  
18.           
19.         Person p=new Person("zy",22);  
20.           
21.         dos.writeObject(p);  
22.   
23.         dos.close();  
24.         fos.close();  
25.           
26.         FileInputStream fis=new FileInputStream(f);  
27.         ObjectInputStream ois=new ObjectInputStream(fis);  
28.           
29.         Person ps=(Person)ois.readObject();  
30.           
31.         System.out.println(ps.getName()+"\t"+ps.getId());  
32.           
33.   
34.     }  
35.   
36. }  
37.   
38. class Person implements Serializable{  
39.     private String name;  
40.     private transient int id;  
41.       
42.       
43.       
44.     public Person() {  
45.         super();  
46.     }  
47.     public Person(String name, int id) {  
48.         super();  
49.         this.name = name;  
50.         this.id = id;  
51.     }  
52.     public String getName() {  
53.         return name;  
54.     }  
55.     public void setName(String name) {  
56.         this.name = name;  
57.     }  
58.     public int getId() {  
59.         return id;  
60.     }  
61.     public void setId(int id) {  
62.         this.id = id;  
63.     }     
64.       
65. }  

•RandomAccessFile： 随机文件读取

   使用场景:支持对随机访问文件的读取和写入.

   特点:  1. 类中既有存的方法也有读的方法

              2. 须指定访问文件模式

              3. seek()和skip()

示例：操作日志

[java]  view plain copy print ?

1. import java.io.File;  
2. import java.io.FileNotFoundException;  
3. import java.io.IOException;  
4. import java.io.RandomAccessFile;  
5. import java.text.SimpleDateFormat;  
6. import java.util.Date;  
7.   
8.   
9. public class Test10 {  
10.   
11.     public static void main(String[] args) throws IOException {  
12.         BankAccount ba=new BankAccount(1000);  
13.         for(int i=0;i<10;i++){  
14.         ba.withDrawal(100);  
15.         }  
16.   
17.     }  
18. }  
19.   
20.   
21. class BankAccount{  
22.     private int money;  
23.     public BankAccount(int money){  
24.         this.money=money;  
25.     }  
26.       
27.     public void withDrawal(int money) throws IOException{  
28.         this.money=this.money-money;  
29.         log("您取了"+money+",账户余额:"+this.money);  
30.     }  
31.   
32.     private void log(String string) throws IOException {  
33.         File f=new File("r:\\io\\log.txt");  
34.         RandomAccessFile raf=new RandomAccessFile(f,"rwd");  
35.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日");  
36.         Date d=new Date();  
37.         String dd=sdf.format(d);  
38.           
39.         raf.seek(raf.length());  
40.           
41.         String s="\r\n"+dd+"\t"+string;  
42.         raf.write(s.getBytes("gbk"));  
43.         raf.close();  
44.           
45.     }  
46.       
47. }  

总结

•java.io包是Java内置的包，其中包含一系列对输入/输出进行操作的类；

•File类的对象可以访问文件（或目录）的属性，但不可以进行读/写操作；

•从方向上讲，流分为输入流和输出流，但从格式上区分的话，流分为字节流和字符流；

•使用FileInputStream类和FileOutputStream类以字节流方式对文件进行读/写操作，这是操作文件最基本的两个类；

•FileReader类和FileWriter类配合BufferedReader类和BufferedWriter类可以以字符流方式对文件进行读/写操作；

•从控制台接受输入要使用到InputStreamReader类和BufferedReader类；

•DataInputStream类和DataOutputStream类允许读/写各种基本数据类型；

•绝大部分的IO操作都可能抛出IOException。

补充

•Properties类

           >该类是位于util包里的一个工具类，与IO的结合能十分有效地读写文件，特别在准确快速读取方面效率十分高！

           >该类结合了util包里的HashMap的存储方法，使用了键值对方式

构 造 方 法	说    明
Properties()	创建一个Properties对象

Properties类的常用方法

方 法 原 型	说    明
void load(Reader reader)	通过字符流加载一个文件
void load(InputStream in)	通过字节流加载一个文件
String getProperty(String key)	通过键获得文件中对应的值
Object setProperty(String key,String value)	存入一对键值对
void store(OutputStream out, String comments)	以适合使用 load 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。

案例：

•将当前系统的配置信息输出到一个properties文件保存，并且做一个方法可以读取这个properties文件.

     提示:   Properties类与流的结合使用

[java]  view plain copy print ?

1. import java.io.FileInputStream;  
2. import java.io.FileOutputStream;  
3. import java.io.IOException;  
4. import java.io.InputStream;  
5. import java.io.OutputStream;  
6. import java.util.Iterator;  
7. import java.util.Properties;  
8. import java.util.Set;  
9.   
10. public class Test7 {  
11.     public static void main(String[] args) throws IOException {  
12.           OutputStream fos=new FileOutputStream("r:\\io\\p.properties");  
13.           Properties p=SystemInfoUtil1.getInfo();  
14.           p.store(fos, "");  
15.             
16.           InputStream fis=new FileInputStream("r:\\io\\p.properties");  
17.           Properties p2=new Properties();  
18.           p2.load(fis);  
19.             
20.           System.out.println(p2.toString());  
21.     }  
22.   
23. }  
24. class SystemInfoUtil1{  
25.       
26.     public static Properties getInfo(){  
27.         //解决记事本中换行符的问题  
28.         String lineSeparator=System.getProperty("line.separator");  
29.         StringBuffer result=new StringBuffer();  
30.         Properties p=System.getProperties();  
31.         return p;  
32.     }  
33.       
34. }  

扩展知识

•File中的方法:

   publicFile[] listFiles(FilenameFilter filter): 返回此目录中满足指定过滤器的文件和目录。

扩展阅读

•密码学知识

                                  http://download.csdn.net/detail/nisior/3981671

扩展案例

需求: 要求用户输入账号和金额。如果当前该账号不存在则创建。

         将钱存入该账号，然后用户可以选择择继续或退出。

          当程序再次运行时，银行数据被存储并重新加载.

作业

1.

•使用IO技术，创建一个目录，然后复制一个文件到该目录！

•使用IO技术，开发出一个控制台的资源管理器！

           >要求：

                      >从命令行输入一个路径！如果存在将该目录下所有的文件和文件夹列举出来，包括子目录下的

                      >如果不存在则输出不存在该路径。

2.

•从控制台输入一些字符串，并将该类信息保存到日志文件中去。

•从控制台进行输入用户名以及用户密码，判断是否登录成功！要求准确的用户名和密码存在配置文件中！

3.

•采用递归调用输出指定目录下所有的文件名及子文件夹中的子文件名

•删除目录或文件，如果参数file代表目录，会删除当前目录及以下的所有内容