Java中的IO整理完整版（一）

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

1. import java.io.*;  
2. class hello{  
3.     public static void main(String[] args) {  
4.         File f=new File("D:\\hello.txt");  
5.         try{  
6.             f.createNewFile();  
7.         }catch (Exception e) {  
8.             e.printStackTrace();  
9.         }  
10.     }  
11. } 

【运行结果】：

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

【案例2】File类的两个常量

1. import java.io.*;  
2. class hello{  
3.     public static void main(String[] args) {  
4.         System.out.println(File.separator);  
5.         System.out.println(File.pathSeparator);  
6.     }  
7. } 

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

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

1. import java.io.*;  
2. class hello{  
3.     public static void main(String[] args) {  
4.         String fileName="D:"+File.separator+"hello.txt";  
5.         File f=new File(fileName);  
6.         try{  
7.             f.createNewFile();  
8.         }catch (Exception e) {  
9.             e.printStackTrace();  
10.         }  
11.     }  
12. } 

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

删除一个文件

1. /**  
2.  * 删除一个文件  
3.  * */ 
4. import java.io.*;  
5. class hello{  
6.     public static void main(String[] args) {  
7.         String fileName="D:"+File.separator+"hello.txt";  
8.         File f=new File(fileName);  
9.         if(f.exists()){  
10.             f.delete();  
11.         }else{  
12.             System.out.println("文件不存在");  
13.         }  
14.           
15.     }  
16. } 

创建一个文件夹

1. /**  
2.  * 创建一个文件夹  
3.  * */ 
4. import java.io.*;  
5. class hello{  
6.     public static void main(String[] args) {  
7.         String fileName="D:"+File.separator+"hello";  
8.         File f=new File(fileName);  
9.         f.mkdir();  
10.     }  
11. } 

【运行结果】：

D盘下多了一个hello文件夹

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

1. /**  
2.  * 使用list列出指定目录的全部文件  
3.  * */ 
4. import java.io.*;  
5. class hello{  
6.     public static void main(String[] args) {  
7.         String fileName="D:"+File.separator;  
8.         File f=new File(fileName);  
9.         String[] str=f.list();  
10.         for (int i = 0; i < str.length; i++) {  
11.             System.out.println(str[i]);  
12.         }  
13.     }  
14. } 

【运行结果】：

$RECYCLE.BIN

360

360Downloads

360Rec

360SoftMove

Config.Msi

da

Downloads

DriversBackup

eclipse

java web整合开发和项目实战

Lenovo

MSOCache

Program

Program Files

python

RECYGLER.{8F92DA15-A229-A4D5-B5CE-5280C8B89C19}

System Volume Information

Tomcat6

var

vod_cache_data

新建文件夹

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

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

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

1. /**  
2.  * 使用listFiles列出指定目录的全部文件  
3.  * listFiles输出的是完整路径  
4.  * */ 
5. import java.io.*;  
6. class hello{  
7.     public static void main(String[] args) {  
8.         String fileName="D:"+File.separator;  
9.         File f=new File(fileName);  
10.         File[] str=f.listFiles();  
11.         for (int i = 0; i < str.length; i++) {  
12.             System.out.println(str[i]);  
13.         }  
14.     }  
15. } 

【运行结果】：

D:\$RECYCLE.BIN

D:\360

D:\360Downloads

D:\360Rec

D:\360SoftMove

D:\Config.Msi

D:\da

D:\Downloads

D:\DriversBackup

D:\eclipse

D:\java web整合开发和项目实战

D:\Lenovo

D:\MSOCache

D:\Program

D:\Program Files

D:\python

D:\RECYGLER.{8F92DA15-A229-A4D5-B5CE-5280C8B89C19}

D:\System Volume Information

D:\Tomcat6

D:\var

D:\vod_cache_data

D:\新建文件夹

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

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

1. /**  
2.  * 使用isDirectory判断一个指定的路径是否为目录  
3.  * */ 
4. import java.io.*;  
5. class hello{  
6.     public static void main(String[] args) {  
7.         String fileName="D:"+File.separator;  
8.         File f=new File(fileName);  
9.         if(f.isDirectory()){  
10.             System.out.println("YES");  
11.         }else{  
12.             System.out.println("NO");  
13.         }  
14.     }  
15. } 

【运行结果】：YES

搜索指定目录的全部内容

1. /**  
2.  * 列出指定目录的全部内容  
3.  * */ 
4. import java.io.*;  
5. class hello{  
6.     public static void main(String[] args) {  
7.         String fileName="D:"+File.separator;  
8.         File f=new File(fileName);  
9.         print(f);  
10.     }  
11.     public static void print(File f){  
12.         if(f!=null){  
13.             if(f.isDirectory()){  
14.                 File[] fileArray=f.listFiles();  
15.                 if(fileArray!=null){  
16.                     for (int i = 0; i < fileArray.length; i++) {  
17.                         //递归调用  
18.                         print(fileArray[i]);  
19.                     }  
20.                 }  
21.             }  
22.             else{  
23.                 System.out.println(f);  
24.             }  
25.         }  
26.     }  
27. } 

【运行结果】：

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\framepages\web4welcome_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\transit_jsp.class

……

【使用RandomAccessFile写入文件】

1. /**  
2.  * 使用RandomAccessFile写入文件  
3.  * */ 
4. import java.io.*;  
5. class hello{  
6.     public static void main(String[] args) throws IOException {  
7.         String fileName="D:"+File.separator+"hello.txt";  
8.         File f=new File(fileName);  
9.         RandomAccessFile demo=new RandomAccessFile(f,"rw");  
10.         demo.writeBytes("asdsad");  
11.         demo.writeInt(12);  
12.         demo.writeBoolean(true);  
13.         demo.writeChar('A');  
14.         demo.writeFloat(1.21f);  
15.         demo.writeDouble(12.123);  
16.         demo.close();     
17.     }  
18. } 

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

字节流

【向文件中写入字符串】

1. /**  
2.  * 字节流  
3.  * 向文件中写入字符串  
4.  * */ 
5. import java.io.*;  
6. class hello{  
7.     public static void main(String[] args) throws IOException {  
8.         String fileName="D:"+File.separator+"hello.txt";  
9.         File f=new File(fileName);  
10.         OutputStream out =new FileOutputStream(f);  
11.         String str="你好";  
12.         byte[] b=str.getBytes();  
13.         out.write(b);  
14.         out.close();  
15.     }  
16. } 

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

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

1. /**  
2.  * 字节流  
3.  * 向文件中一个字节一个字节的写入字符串  
4.  * */ 
5. import java.io.*;  
6. class hello{  
7.     public static void main(String[] args) throws IOException {  
8.         String fileName="D:"+File.separator+"hello.txt";  
9.         File f=new File(fileName);  
10.         OutputStream out =new FileOutputStream(f);  
11.         String str="你好";  
12.         byte[] b=str.getBytes();  
13.         for (int i = 0; i < b.length; i++) {  
14.             out.write(b[i]);  
15.         }  
16.         out.close();  
17.     }  
18. } 

结果还是：“你好”

向文件中追加新内容：

1. /**  
2.  * 字节流  
3.  * 向文件中追加新内容：  
4.  * */ 
5. import java.io.*;  
6. class hello{  
7.     public static void main(String[] args) throws IOException {  
8.         String fileName="D:"+File.separator+"hello.txt";  
9.         File f=new File(fileName);  
10.         OutputStream out =new FileOutputStream(f,true);  
11.         String str="Rollen";  
12.         //String str="\r\nRollen";  可以换行  
13.         byte[] b=str.getBytes();  
14.         for (int i = 0; i < b.length; i++) {  
15.             out.write(b[i]);  
16.         }  
17.         out.close();  
18.     }  
19. } 

【运行结果】：

你好Rollen

【读取文件内容】

1. /**  
2.  * 字节流  
3.  * 读文件内容  
4.  * */ 
5. import java.io.*;  
6. class hello{  
7.     public static void main(String[] args) throws IOException {  
8.         String fileName="D:"+File.separator+"hello.txt";  
9.         File f=new File(fileName);  
10.         InputStream in=new FileInputStream(f);  
11.         byte[] b=new byte[1024];  
12.         in.read(b);  
13.         in.close();  
14.         System.out.println(new String(b));  
15.     }  
16. } 

【运行结果】
你好Rollen

Rollen_

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

1. /**  
2.  * 字节流  
3.  * 读文件内容  
4.  * */ 
5. import java.io.*;  
6. class hello{  
7.     public static void main(String[] args) throws IOException {  
8.         String fileName="D:"+File.separator+"hello.txt";  
9.         File f=new File(fileName);  
10.         InputStream in=new FileInputStream(f);  
11.         byte[] b=new byte[1024];  
12.         int len=in.read(b);  
13.         in.close();  
14.         System.out.println("读入长度为："+len);  
15.         System.out.println(new String(b,0,len));  
16.     }  
17. } 

【运行结果】：

读入长度为：18

你好Rollen

Rollen

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

1. /**  
2.  * 字节流  
3.  * 读文件内容,节省空间  
4.  * */ 
5. import java.io.*;  
6. class hello{  
7.     public static void main(String[] args) throws IOException {  
8.         String fileName="D:"+File.separator+"hello.txt";  
9.         File f=new File(fileName);  
10.         InputStream in=new FileInputStream(f);  
11.         byte[] b=new byte[(int)f.length()];  
12.         in.read(b);  
13.         System.out.println("文件长度为："+f.length());  
14.         in.close();  
15.         System.out.println(new String(b));  
16.     }  
17. } 

文件长度为：18

你好Rollen

Rollen

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

1. /**  
2.  * 字节流  
3.  * 读文件内容,节省空间  
4.  * */ 
5. import java.io.*;  
6. class hello{  
7.     public static void main(String[] args) throws IOException {  
8.         String fileName="D:"+File.separator+"hello.txt";  
9.         File f=new File(fileName);  
10.         InputStream in=new FileInputStream(f);  
11.         byte[] b=new byte[(int)f.length()];  
12.         for (int i = 0; i < b.length; i++) {  
13.             b[i]=(byte)in.read();  
14.         }  
15.         in.close();  
16.         System.out.println(new String(b));  
17.     }  
18. } 

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

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

1. /**  
2.  * 字节流  
3.  *读文件  
4.  * */ 
5. import java.io.*;  
6. class hello{  
7.     public static void main(String[] args) throws IOException {  
8.         String fileName="D:"+File.separator+"hello.txt";  
9.         File f=new File(fileName);  
10.         InputStream in=new FileInputStream(f);  
11.         byte[] b=new byte[1024];  
12.         int count =0;  
13.         int temp=0;  
14.         while((temp=in.read())!=(-1)){  
15.             b[count++]=(byte)temp;  
16.         }  
17.         in.close();  
18.         System.out.println(new String(b));  
19.     }  
20. } 

【运行结果】

你好Rollen

Rollen_

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

现在我们使用字符流

1. /**  
2.  * 字符流  
3.  * 写入数据  
4.  * */ 
5. import java.io.*;  
6. class hello{  
7.     public static void main(String[] args) throws IOException {  
8.         String fileName="D:"+File.separator+"hello.txt";  
9.         File f=new File(fileName);  
10.         Writer out =new FileWriter(f);  
11.         String str="hello";  
12.         out.write(str);  
13.         out.close();  
14.     }  
15. } 

当你打开hello。txt的时候，会看到hello

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

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

Writer out =new FileWriter(f,true);

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

hellohello如果想在文件中换行的话，需要使用“\r\n”

比如将str变为String str="\r\nhello";

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

从文件中读内容：

1. /**  
2.  * 字符流  
3.  * 从文件中读出内容  
4.  * */ 
5. import java.io.*;  
6. class hello{  
7.     public static void main(String[] args) throws IOException {  
8.         String fileName="D:"+File.separator+"hello.txt";  
9.         File f=new File(fileName);  
10.         char[] ch=new char[100];  
11.         Reader read=new FileReader(f);  
12.         int count=read.read(ch);  
13.         read.close();  
14.         System.out.println("读入的长度为："+count);  
15.         System.out.println("内容为"+new String(ch,0,count));  
16.     }  
17. } 

【运行结果】：

读入的长度为：17

内容为hellohello

hello

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

1. /**  
2.  * 字符流  
3.  * 从文件中读出内容  
4.  * */ 
5. import java.io.*;  
6. class hello{  
7.     public static void main(String[] args) throws IOException {  
8.         String fileName="D:"+File.separator+"hello.txt";  
9.         File f=new File(fileName);  
10.         char[] ch=new char[100];  
11.         Reader read=new FileReader(f);  
12.         int temp=0;  
13.         int count=0;  
14.         while((temp=read.read())!=(-1)){  
15.             ch[count++]=(char)temp;  
16.         }  
17.         read.close();  
18.         System.out.println("内容为"+new String(ch,0,count));  
19.     }  
20. } 

运行结果：

内容为hellohello

hello

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

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

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

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

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

文件的复制

其实DOS下就有一个文件复制功能，比如我们想把d盘下面的hello.txt文件复制到d盘下面的rollen.txt文件中，那么我们就可以使用下面的命令：

copy d:\hello.txt d:\rollen.txt

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

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

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

首先编写下面的代码：

1. /**  
2.  * 文件的复制  
3.  * */ 
4. import java.io.*;  
5. class hello{  
6.     public static void main(String[] args) throws IOException {  
7.         if(args.length!=2){  
8.             System.out.println("命令行参数输入有误，请检查");  
9.             System.exit(1);  
10.         }  
11.         File file1=new File(args[0]);  
12.         File file2=new File(args[1]);  
13.           
14.         if(!file1.exists()){  
15.             System.out.println("被复制的文件不存在");  
16.             System.exit(1);  
17.         }  
18.         InputStream input=new FileInputStream(file1);  
19.         OutputStream output=new FileOutputStream(file2);  
20.         if((input!=null)&&(output!=null)){  
21.             int temp=0;  
22.             while((temp=input.read())!=(-1)){  
23.                 output.write(temp);  
24.             }  
25.         }  
26.         input.close();  
27.         output.close();   
28.     }  
29. } 

然后在命令行下面

javac hello.java

java hello d:\hello.txt d:\rollen.txt

现在你就会在d盘看到rollen。txt了，

OutputStreramWriter 和InputStreamReader类

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

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

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

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

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

1. /**  
2.  * 将字节输出流转化为字符输出流  
3.  * */ 
4. import java.io.*;  
5. class hello{  
6.     public static void main(String[] args) throws IOException {  
7.         String fileName= "d:"+File.separator+"hello.txt";  
8.         File file=new File(fileName);  
9.         Writer out=new OutputStreamWriter(new FileOutputStream(file));  
10.         out.write("hello");  
11.         out.close();  
12.     }  
13. } 

运行结果：文件中内容为：hello

将字节输入流变为字符输入流

1. /**  
2.  * 将字节输入流变为字符输入流  
3.  * */ 
4. import java.io.*;  
5. class hello{  
6.     public static void main(String[] args) throws IOException {  
7.         String fileName= "d:"+File.separator+"hello.txt";  
8.         File file=new File(fileName);  
9.         Reader read=new InputStreamReader(new FileInputStream(file));  
10.         char[] b=new char[100];  
11.         int len=read.read(b);  
12.         System.out.println(new String(b,0,len));  
13.         read.close();  
14.     }  
15. } 

【运行结果】：hello

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

ByteArrayInputStream 主要将内容写入内容

ByteArrayOutputStream 主要将内容从内存输出

使用内存操作流将一个大写字母转化为小写字母

1. /**  
2.  * 使用内存操作流将一个大写字母转化为小写字母  
3.  * */ 
4. import java.io.*;  
5. class hello{  
6.     public static void main(String[] args) throws IOException {  
7.         String str="ROLLENHOLT";  
8.         ByteArrayInputStream input=new ByteArrayInputStream(str.getBytes());  
9.         ByteArrayOutputStream output=new ByteArrayOutputStream();  
10.         int temp=0;  
11.         while((temp=input.read())!=-1){  
12.             char ch=(char)temp;  
13.             output.write(Character.toLowerCase(ch));  
14.         }  
15.         String outStr=output.toString();  
16.         input.close();  
17.         output.close();  
18.         System.out.println(outStr);  
19.     }  
20. } 

【运行结果】：

rollenholt

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

管道流

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

PipedOutputStream 管道输出流

PipedInputStream 管道输入流

验证管道流

1. /**  
2.  * 验证管道流  
3.  * */ 
4. import java.io.*;  
5.  
6. /**  
7.  * 消息发送类  
8.  * */ 
9. class Send implements Runnable{  
10.     private PipedOutputStream out=null;  
11.     public Send() {  
12.         out=new PipedOutputStream();  
13.     }  
14.     public PipedOutputStream getOut(){  
15.         return this.out;  
16.     }  
17.     public void run(){  
18.         String message="hello , Rollen";  
19.         try{  
20.             out.write(message.getBytes());  
21.         }catch (Exception e) {  
22.             e.printStackTrace();  
23.         }try{  
24.             out.close();  
25.         }catch (Exception e) {  
26.             e.printStackTrace();  
27.         }  
28.     }  
29. }  
30.  
31. /**  
32.  * 接受消息类  
33.  * */ 
34. class Recive implements Runnable{  
35.     private PipedInputStream input=null;  
36.     public Recive(){  
37.         this.input=new PipedInputStream();  
38.     }  
39.     public PipedInputStream getInput(){  
40.         return this.input;  
41.     }  
42.     public void run(){  
43.         byte[] b=new byte[1000];  
44.         int len=0;  
45.         try{  
46.             len=this.input.read(b);  
47.         }catch (Exception e) {  
48.             e.printStackTrace();  
49.         }try{  
50.             input.close();  
51.         }catch (Exception e) {  
52.             e.printStackTrace();  
53.         }  
54.         System.out.println("接受的内容为 "+(new String(b,0,len)));  
55.     }  
56. }  
57. /**  
58.  * 测试类  
59.  * */ 
60. class hello{  
61.     public static void main(String[] args) throws IOException {  
62.         Send send=new Send();  
63.         Recive recive=new Recive();  
64.         try{  
65. //管道连接  
66.             send.getOut().connect(recive.getInput());  
67.         }catch (Exception e) {  
68.             e.printStackTrace();  
69.         }  
70.         new Thread(send).start();  
71.         new Thread(recive).start();  
72.     }  
73. } 

【运行结果】：
 

接受的内容为 hello , Rollen

打印流

1. /**  
2.  * 使用PrintStream进行输出  
3.  * */ 
4. import java.io.*;  
5.  
6. class hello {  
7.     public static void main(String[] args) throws IOException {  
8.         PrintStream print = new PrintStream(new FileOutputStream(new File("d:" 
9.                 + File.separator + "hello.txt")));  
10.         print.println(true);  
11.         print.println("Rollen");  
12.         print.close();  
13.     }  
14. } 

【运行结果】：

true

Rollen

当然也可以格式化输出

1. /**  
2.  * 使用PrintStream进行输出  
3.  * 并进行格式化  
4.  * */ 
5. import java.io.*;  
6. class hello {  
7.     public static void main(String[] args) throws IOException {  
8.         PrintStream print = new PrintStream(new FileOutputStream(new File("d:" 
9.                 + File.separator + "hello.txt")));  
10.         String name="Rollen";  
11.         int age=20;  
12.         print.printf("姓名：%s. 年龄：%d.",name,age);  
13.         print.close();  
14.     }  
15. } 

【运行结果】：

姓名：Rollen. 年龄：20.

使用OutputStream向屏幕上输出内容

1. /**  
2.  * 使用OutputStream向屏幕上输出内容   
3.  * */ 
4. import java.io.*;  
5. class hello {  
6.     public static void main(String[] args) throws IOException {  
7.         OutputStream out=System.out;  
8.         try{  
9.             out.write("hello".getBytes());  
10.         }catch (Exception e) {  
11.             e.printStackTrace();  
12.         }  
13.         try{  
14.             out.close();  
15.         }catch (Exception e) {  
16.             e.printStackTrace();  
17.         }  
18.     }  
19. } 

【运行结果】：

hello

输入输出重定向

1. import java.io.File;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileOutputStream;  
4. import java.io.PrintStream;  
5.  
6. /**  
7.  * 为System.out.println()重定向输出  
8.  * */ 
9. public class systemDemo{  
10.     public static void main(String[] args){  
11.         // 此刻直接输出到屏幕  
12.         System.out.println("hello");  
13.         File file = new File("d:" + File.separator + "hello.txt");  
14.         try{  
15.             System.setOut(new PrintStream(new FileOutputStream(file)));  
16.         }catch(FileNotFoundException e){  
17.             e.printStackTrace();  
18.         }  
19.         System.out.println("这些内容在文件中才能看到哦！");  
20.     }  
21. } 

【运行结果】：

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

1. import java.io.File;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileOutputStream;  
4. import java.io.PrintStream;  
5.  
6. /**  
7.  * System.err重定向 这个例子也提示我们可以使用这种方法保存错误信息  
8.  * */ 
9. public class systemErr{  
10.     public static void main(String[] args){  
11.         File file = new File("d:" + File.separator + "hello.txt");  
12.         System.err.println("这些在控制台输出");  
13.         try{  
14.             System.setErr(new PrintStream(new FileOutputStream(file)));  
15.         }catch(FileNotFoundException e){  
16.             e.printStackTrace();  
17.         }  
18.         System.err.println("这些在文件中才能看到哦！");  
19.     }  
20. } 

【运行结果】：

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

1. import java.io.File;  
2. import java.io.FileInputStream;  
3. import java.io.FileNotFoundException;  
4. import java.io.IOException;  
5.  
6. /**  
7.  * System.in重定向  
8.  * */ 
9. public class systemIn{  
10.     public static void main(String[] args){  
11.         File file = new File("d:" + File.separator + "hello.txt");  
12.         if(!file.exists()){  
13.             return;  
14.         }else{  
15.             try{  
16.                 System.setIn(new FileInputStream(file));  
17.             }catch(FileNotFoundException e){  
18.                 e.printStackTrace();  
19.             }  
20.             byte[] bytes = new byte[1024];  
21.             int len = 0;  
22.             try{  
23.                 len = System.in.read(bytes);  
24.             }catch(IOException e){  
25.                 e.printStackTrace();  
26.             }  
27.             System.out.println("读入的内容为：" + new String(bytes, 0, len));  
28.         }  
29.     }  
30. } 

【运行结果】：

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

转自:http://zhaohe162.blog.163.com/blog/static/3821679720118309710914/