Java IO操作——字节流(OutputStream、InputStream)和字符流(Writer、Reader)

支持原创，谢谢原作者！

流的概念

在程序中所有的数据都是以流的方式进行传输或保存的，程序中需要数据的时候就用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。

程序中的输入输出都是以流的形式保存的，流中保存的实际上全部是字节文件。

字节流与字符流

在java.io包中操作文件内容的主要有两大类：字节流和字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成，输入使用InputStream，在字符流中输出主要是使用Writer类完成，输入主要是使用Reader类完成。

内容操作一共四个类：OutputStream、InputStream、Writer、Reader

操作流程：

在JAVA中IO操作也是有相应步骤的，以文件操作为例，主要操作流程如下：

A、使用File类打开一个文件

B、通过字节流或字符流的子类，指定输出的位置。

C、进行读/写操作

D、关闭输入/输出

使用File类操作的时候一定要有路径的问题，注意分隔符。

实际上四个操作类都是抽象类

IO操作属于资源操作，对于资源操作，操作的最后必须关闭，否则就有可能出现未知的错误。

字节流

字节流主要是操作byte类型的数据，以byte数组为准，主要操作类是OutputStream、InputStream

字节输出流：OutputStream

字节输入流：InputStream

Byte是字节，肯定使用字节流操作。所有的数据基本上都可以直接使用byte数组表示出来。

字节输出流OutputStream

OutputStream是整个io包中字节输出流的最大父类，此类的定义如下：

public abstract class OutputStream extends Object implements Closeable, Flushable

从以上的定义可以发现，此类是一个抽象类，如果要想使用此类的话，则首先必须通过子类实例化对象，那么如果现在要操作的是一个文件，则可以使用：FileOutputStream类。通过向上转型之后，可以为OutputStream实例化。

Closeable表示可以关闭的操作，因为程序运行到最后肯定要关闭。

Flushable接口表示刷新，清空内存中的数据。

OutputStream类的常用方法：

1、public void close() throws IOException  关闭输出流

2、public void flush() throws IOException  刷新缓冲区

3、public void write(byte[] b) throws IOException 将一个byte数组写入数据流

4、public void write(byte[] b,int off,int len) throws IOException 将一个指定范围的byte数组写入数据流

5、public abstract void write(int b) throws IOException  将一个字节数据写入数据流

要想使用以上方法，必须使用子类实例化，此时使用FileOutputStream子类，此类的构造方法如下：

public FileOutputStream(File file) throws IOException  

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.OutputStream ;  
3. import java.io.FileOutputStream ;  
4. public class OutputStreamDemo01{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         OutputStream out = null ;   // 准备好一个输出的对象  
10.         out = new FileOutputStream(f)  ;    // 通过对象多态性，进行实例化  
11.         // 第3步、进行写操作  
12.         String str = "Hello World!!!" ;     // 准备一个字符串  
13.         byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组  
14.         out.write(b) ;                      // 将内容输出，保存文件  
15.         // 第4步、关闭输出流  
16.         out.close() ;                       // 关闭输出流  
17.     }  
18. };  

在操作的时候，如果文件本身不存在，则会为用户自动创建新文件。

在操作输出流的时候，也可以使用write(int i)的方法写出数据

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.OutputStream ;  
3. import java.io.FileOutputStream ;  
4. public class OutputStreamDemo02{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         OutputStream out = null ;   // 准备好一个输出的对象  
10.         out = new FileOutputStream(f)  ;    // 通过对象多态性，进行实例化  
11.         // 第3步、进行写操作  
12.         String str = "Hello World!!!" ;     // 准备一个字符串  
13.         byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组  
14.         for(int i=0;i<b.length;i++){     // 采用循环方式写入  
15.             out.write(b[i]) ;   // 每次只写入一个内容  
16.         }  
17.         // 第4步、关闭输出流  
18.         out.close() ;                       // 关闭输出流  
19.     }  
20. };  

以上的操作中在写入数据之前，文件之前的内容已经不存在了，因为在IO操作中默认的情况是将其进行覆盖的，那么现在要想执行追加的功能，则必须设置追加的操作，找到FileOutputStream类：

追加新内容

之前的所有操作中，如果重新执行程序，则肯定会覆盖文件中的已有内容，那么此时就可以通过FileOutputStream向文件中追加内容，FileOutputStream的另外一个构造方法：

public FileOutputStream(File file,boolean append) throws FileNotFoundException

在构造方法中，如果将append的值设置为true，则表示在文件的末尾追加内容。

程序代码如下：

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.OutputStream ;  
3. import java.io.FileOutputStream ;  
4. public class OutputStreamDemo03{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         OutputStream out = null ;   // 准备好一个输出的对象  
10.         out = new FileOutputStream(f,true)  ;   // 此处表示在文件末尾追加内容  
11.         // 第3步、进行写操作  
12.         String str = "Hello World!!!" ;     // 准备一个字符串  
13.         byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组  
14.         for(int i=0;i<b.length;i++){     // 采用循环方式写入  
15.             out.write(b[i]) ;   // 每次只写入一个内容  
16.         }  
17.         // 第4步、关闭输出流  
18.         out.close() ;                       // 关闭输出流  
19.     }  
20. };  

执行完毕后打开文件test.txt如下：

程序本身是可以追加内容的，但是没有换行，是直接在末尾追加的。

如果在文件操作中想换行的话，使用"\r\n" 完成。

代码如下：

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.OutputStream ;  
3. import java.io.FileOutputStream ;  
4. public class OutputStreamDemo04{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         OutputStream out = null ;   // 准备好一个输出的对象  
10.         out = new FileOutputStream(f,true)  ;   // 此处表示在文件末尾追加内容  
11.         // 第3步、进行写操作  
12.         String str = "\r\nHello World!!!" ;     // 准备一个字符串  
13.         byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组  
14.         for(int i=0;i<b.length;i++){     // 采用循环方式写入  
15.             out.write(b[i]) ;   // 每次只写入一个内容  
16.         }  
17.         // 第4步、关闭输出流  
18.         out.close() ;                       // 关闭输出流  
19.     }  
20. };  

字节输入流：InputStream

 既然程序可以向文件中写入内容，则就可以通过InputStream从文件中读取出来，首先看InputStream类的定义：

public abstract class InputStream extends Object implements Closeable

与OutputStream类一样，InputStream本身也是一个抽象类，必须依靠其子类，如果现在是从文件中读取，子类肯定是FileInputStream。观察FileInputStream类的构造方法：

public FileInputStream(File file) throws FileNotFoundException

InputStream类的常用方法如下：

1、public int available() throws IOException  可以取得输入文件的大小。

2、public void close() throws IOException  关闭输入流

3、public abstract int read() throws IOException 读取内容数字的方式读取

4、public int read(byte[] b) throws IOException 将内容读取到byte数组之中，同时返回读入的个数

程序代码如下：

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.InputStream ;  
3. import java.io.FileInputStream ;  
4. public class InputStreamDemo01{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         InputStream input = null ;  // 准备好一个输入的对象  
10.         input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化  
11.         // 第3步、进行读操作  
12.         byte b[] = new byte[1024] ;     // 所有的内容都读到此数组之中  
13.         input.read(b) ;     // 读取内容  
14.         // 第4步、关闭输出流  
15.         input.close() ;                     // 关闭输出流  
16.         System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出  
17.     }  
18. };  

此时，内容确实已经被读取出来了，但是存在问题。

初步修改代码后如下：

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.InputStream ;  
3. import java.io.FileInputStream ;  
4. public class InputStreamDemo02{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         InputStream input = null ;  // 准备好一个输入的对象  
10.         input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化  
11.         // 第3步、进行读操作  
12.         byte b[] = new byte[1024] ;     // 所有的内容都读到此数组之中  
13.         int len = input.read(b) ;       // 读取内容  
14.         // 第4步、关闭输出流  
15.         input.close() ;                     // 关闭输出流\  
16.         System.out.println("读入数据的长度：" + len) ;  
17.         System.out.println("内容为：" + new String(b,0,len)) ;  // 把byte数组变为字符串输出  
18.     }  
19. };  

以上代码还是存在问题，现在文件没有那么大，但是开辟了很大的数组空间，肯定浪费很多内存，应该根据文件的大小来开辟数组空间。如果想知道文件的大小，直接使用File类即可：

public long length()

开辟指定大小的空间

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.InputStream ;  
3. import java.io.FileInputStream ;  
4. public class InputStreamDemo03{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         InputStream input = null ;  // 准备好一个输入的对象  
10.         input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化  
11.         // 第3步、进行读操作  
12.         byte b[] = new byte[(int)f.length()] ;      // 数组大小由文件决定  
13.         int len = input.read(b) ;       // 读取内容  
14.         // 第4步、关闭输出流  
15.         input.close() ;                     // 关闭输出流\  
16.         System.out.println("读入数据的长度：" + len) ;  
17.         System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出  
18.     }  
19. };  

以上是直接使用byte数组的方式完成的，还可以使用以下方式进行读取

public abstract int read() throws IOException逐个字节进行内容读取

代码如下：

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.InputStream ;  
3. import java.io.FileInputStream ;  
4. public class InputStreamDemo04{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         InputStream input = null ;  // 准备好一个输入的对象  
10.         input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化  
11.         // 第3步、进行读操作  
12.         byte b[] = new byte[(int)f.length()] ;      // 数组大小由文件决定  
13.         for(int i=0;i<b.length;i++){  
14.             b[i] = (byte)input.read() ;     // 读取内容  
15.         }  
16.         // 第4步、关闭输出流  
17.         input.close() ;                     // 关闭输出流\  
18.         System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出  
19.     }  
20. };  

以上的操作，只适合于知道输入流大小的时候，如果现在不知道大小呢？

需要根据读取的标志-1进行判断是否结束，代码如下：

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.InputStream ;  
3. import java.io.FileInputStream ;  
4. public class InputStreamDemo05{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         InputStream input = null ;  // 准备好一个输入的对象  
10.         input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化  
11.         // 第3步、进行读操作  
12.         byte b[] = new byte[1024] ;     // 数组大小由文件决定  
13.         int len = 0 ;   
14.         int temp = 0 ;          // 接收每一个读取进来的数据  
15.         while((temp=input.read())!=-1){  
16.             // 表示还有内容，文件没有读完  
17.             b[len] = (byte)temp ;  
18.             len++ ;  
19.         }  
20.         // 第4步、关闭输出流  
21.         input.close() ;                     // 关闭输出流\  
22.         System.out.println("内容为：" + new String(b,0,len)) ;  // 把byte数组变为字符串输出  
23.     }  
24. };  

当不知道读取的内容有多大的时候，就只能以读取的数据是否为-1为读完的标志。

字符流

在程序中一个字符等于2个字节，那么JAVA提供了Reader、Writer两个专门操作字符流的类。

字符输出流：Writer

Writer本身是一个字符流的输出类，此类的定义如下：

public abstract class Writer extends Object implements Appendable，Closeable,，Flushable

此类也是一个抽象类，如果要想使用此类，则肯定要使用其子类。此时如果是向文件中写入内容，所以应该使用FileWriter的子类。

FileWriter类的构造方法定义如下：

public FileWriter(File file) throws IOException

Writer类的常用方法

1、public abstract void close() throws IOException  关闭输出流

2、public void write(String str) throws IOException 将字符串输出

3、public void write(char[] cbuf) throws IOException 将字符数组输出

4、public abstract void flush() throws IOException 强制性清空缓存

字符流的操作比字节流操作好在一点，就是可以直接输出字符串。不在用再像之前那样进行字节转换操作了。

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.Writer ;  
3. import java.io.FileWriter ;  
4. public class WriterDemo01{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         Writer out = null ; // 准备好一个输出的对象  
10.         out = new FileWriter(f)  ;  // 通过对象多态性，进行实例化  
11.         // 第3步、进行写操作  
12.         String str = "Hello World!!!" ;     // 准备一个字符串  
13.         out.write(str) ;                        // 将内容输出，保存文件  
14.         // 第4步、关闭输出流  
15.         out.close() ;                       // 关闭输出流  
16.     }  
17. };  

使用字符流默认情况下依然是覆盖已有的文件，如果想追加的话，则直接在FileWriter上增加一个可追加的标记即可。

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.Writer ;  
3. import java.io.FileWriter ;  
4. public class WriterDemo02{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         Writer out = null ; // 准备好一个输出的对象  
10.         out = new FileWriter(f,true)  ; // 通过对象多态性，进行实例化  
11.         // 第3步、进行写操作  
12.         String str = "\r\n刘勋\r\nHello World!!!" ;       // 准备一个字符串  
13.         out.write(str) ;                        // 将内容输出，保存文件  
14.         // 第4步、关闭输出流  
15.         out.close() ;                       // 关闭输出流  
16.     }  
17. };  

字符输入流：Reader

Reader是使用字符的方式从文件之中取出数据，Reader类的定义如下：

public abstract class Reader extends Object implements Readable，Closeable

Reader本身也是抽象类，如果现在要从文件中读取内容，则可以直接使用FileReader子类。

FileReader的构造方法定义如下：

public FileReader(File file) throws FileNotFOundException

Reader类的常用方法：

1、public abstract void close() throws IOException 关闭输出流

2、public int read() throws IOException 读取单个字符

3、public int read(char[] cbuf) throws IOException 将字符读取到字符数组之中，返回读入的长度。

以字符数组的形式读取数据

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.Reader ;  
3. import java.io.FileReader ;  
4. public class ReaderDemo01{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         Reader input = null ;   // 准备好一个输入的对象  
10.         input = new FileReader(f)  ;    // 通过对象多态性，进行实例化  
11.         // 第3步、进行读操作  
12.         char c[] = new char[1024] ;     // 所有的内容都读到此数组之中  
13.         int len = input.read(c) ;       // 读取内容  
14.         // 第4步、关闭输出流  
15.         input.close() ;                     // 关闭输出流  
16.         System.out.println("内容为：" + new String(c,0,len)) ;  // 把字符数组变为字符串输出  
17.     }  
18. };  

也可以通过循环的方式，通过判断文件是否读取到底的形式读取《如下所示：

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.Reader ;  
3. import java.io.FileReader ;  
4. public class ReaderDemo02{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         Reader input = null ;   // 准备好一个输入的对象  
10.         input = new FileReader(f)  ;    // 通过对象多态性，进行实例化  
11.         // 第3步、进行读操作  
12.         char c[] = new char[1024] ;     // 所有的内容都读到此数组之中  
13.         int temp = 0 ;  // 接收每一个内容  
14.         int len = 0 ;       // 读取内容  
15.         while((temp=input.read())!=-1){  
16.             // 如果不是-1就表示还有内容，可以继续读取  
17.             c[len] = (char)temp ;  
18.             len++ ;  
19.         }  
20.         // 第4步、关闭输出流  
21.         input.close() ;                     // 关闭输出流  
22.         System.out.println("内容为：" + new String(c,0,len)) ;  // 把字符数组变为字符串输出  
23.     }  
24. };  

字节流与字符流的区别

字节流在操作的时候本身是不会用到缓冲区(内存)的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的。

通过一个代码来验证字符流使用到了缓存。

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.OutputStream ;  
3. import java.io.FileOutputStream ;  
4. public class OutputStreamDemo05{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         OutputStream out = null ;   // 准备好一个输出的对象  
10.         out = new FileOutputStream(f)  ;    // 实例化  
11.         // 第3步、进行写操作  
12.         String str = "Hello World!!!" ;     // 准备一个字符串  
13.         byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组  
14.         out.write(b) ;      // 写入数据  
15.         // 第4步、关闭输出流  
16.         // out.close() ;                        // 关闭输出流  
17.     }  
18. };  

在使用字节流操作中，即使没有关闭，最终也是可以输出的

使用字符流，如果不关闭，如下：

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.Writer ;  
3. import java.io.FileWriter ;  
4. public class WriterDemo03{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         Writer out = null ; // 准备好一个输出的对象  
10.         out = new FileWriter(f)  ;  // 通过对象多态性，进行实例化  
11.         // 第3步、进行写操作  
12.         String str = "Hello World!!!" ;     // 准备一个字符串  
13.         out.write(str) ;                        // 将内容输出，保存文件  
14.         // 第4步、关闭输出流  
15.         // out.close() ;                        // 此时，没有关闭  
16.     }  
17. };  

以上的操作，没有输出任何的内容，以前的内容也会被清空，也就是说，所有的内容现在都是保存在缓冲区中，如果执行关闭操作的时候会强制刷新缓冲区，所以可以把内容输出。

如果现在假设，没有关闭的话，也可以手工强制性调用刷新方法

public abstract void flush() throws IOException

程序代码如下：

[java]  view plain  copy

 

1. import java.io.File ;  
2. import java.io.Writer ;  
3. import java.io.FileWriter ;  
4. public class WriterDemo04{  
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理  
6.         // 第1步、使用File类找到一个文件  
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象  
8.         // 第2步、通过子类实例化父类对象  
9.         Writer out = null ; // 准备好一个输出的对象  
10.         out = new FileWriter(f)  ;  // 通过对象多态性，进行实例化  
11.         // 第3步、进行写操作  
12.         String str = "Hello World!!!" ;     // 准备一个字符串  
13.         out.write(str) ;                        // 将内容输出，保存文件  
14.         // 第4步、关闭输出流  
15.         out.flush() ;   // 强制性清空缓冲区中的内容  
16.         // out.close() ;                        // 此时，没有关闭  
17.     }  
18. };  

问题：

 开发中是使用字节流好还是使用字符流好

 在所有的硬盘上保存文件或是进行传输的时候都是以字节的方式进行的，包括图片也是按照字节完成，而字符是只有在内存中才会形成的，所以使用字节操作是最多的。

操作范例

文件拷贝：在DOS命令中存在一个文件的拷贝命令(copy)，例如：现在要将D盘中的test.txt文件拷贝到D盘中的demo.txt文件中，则只要在命令行输入copy即可完成

copy命令的语法格式如下：

copy 源文件 目标文件

如果要采用以上的格式，则肯定要使用初始化参数的形式，输入两个路径，所以此时就必须对输入参数的个数进行验证，判断其是否为2

是使用字符流还是使用字节流呢？答案是肯定选择字节流，因为万一拷贝的是一个图片。

  实现一：将源文件中的内容全部读取进来，之后一次性的写入到目标文件

  实现二：边度边写的方式

很明显是使用第二种方式

程序代码如下：

[java]  view plain  copy

 

1. import java.io.* ;  
2. public class Copy{  
3.     public static void main(String args[]){  
4.         if(args.length!=2){     // 判断是否是两个参数  
5.             System.out.println("输入的参数不正确。") ;  
6.             System.out.println("例：java Copy 源文件路径 目标文件路径") ;  
7.             System.exit(1) ;    // 系统退出  
8.         }  
9.         File f1 = new File(args[0]) ;   // 源文件的File对象  
10.         File f2 = new File(args[1]) ;   // 目标文件的File对象  
11.         if(!f1.exists()){  
12.             System.out.println("源文件不存在！") ;  
13.             System.exit(1) ;  
14.         }  
15.         InputStream input = null ;      // 准备好输入流对象，读取源文件  
16.         OutputStream out = null ;       // 准备好输出流对象，写入目标文件  
17.         try{  
18.             input = new FileInputStream(f1) ;  
19.         }catch(FileNotFoundException e){  
20.             e.printStackTrace() ;  
21.         }  
22.         try{  
23.             out = new FileOutputStream(f2) ;  
24.         }catch(FileNotFoundException e){  
25.             e.printStackTrace() ;  
26.         }  
27.         if(input!=null && out!=null){   // 判断输入或输出是否准备好  
28.             int temp = 0 ;    
29.             try{  
30.                 while((temp=input.read())!=-1){ // 开始拷贝  
31.                     out.write(temp) ;   // 边读边写  
32.                 }  
33.                 System.out.println("拷贝完成！") ;  
34.             }catch(IOException e){  
35.                 e.printStackTrace() ;  
36.                 System.out.println("拷贝失败！") ;  
37.             }  
38.             try{  
39.                 input.close() ;     // 关闭  
40.                 out.close() ;       // 关闭  
41.             }catch(IOException e){  
42.                 e.printStackTrace() ;  
43.             }  
44.         }  
45.     }     
46. }  

总结：

1、掌握流的概念

2、掌握字节流和字符流操作文件的基本步骤（以后所有操作都可以使用以上代码完成）

3、字节流和字符流的区别

    字节流：没有使用到缓冲区

    字符流：使用到了缓冲区

4、边度边写的方式是开发中非常有用的方式