`
zys08
  • 浏览: 145538 次
  • 性别: Icon_minigender_1
  • 来自: 济南
社区版块
存档分类
最新评论

java中IO操作整理 1

 
阅读更多

说明:此文章转摘自网络博客

【案例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.     }  

【运行结果】:

程序运行之后,在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.     }  

【运行结果】:
\
;
此处多说几句:有些同学可能认为,我直接在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.     }  

你看,没有多写多少吧,呵呵。所以建议使用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.     }  

创建一个文件夹

  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.     }  

【运行结果】:

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.     }  

【运行结果】:

$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.     }  

【运行结果】:

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.     }  

【运行结果】: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.     }  

【运行结果】:

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.     }  

如果你此时打开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.     }  

查看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.     }  

结果还是:“你好”

向文件中追加新内容:

  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.     }  

【运行结果】:

你好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.     }  

【运行结果】
你好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.     }  

【运行结果】:

读入长度为: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.     }  

文件长度为: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.     }  

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

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

  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.     }  

【运行结果】

你好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.     }  

当你打开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

内容为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.     }  

运行结果:

内容为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.     }  

然后在命令行下面

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.     }  

运行结果:文件中内容为: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.     }  

【运行结果】: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.     }  

【运行结果】:

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.     }  

【运行结果】:
 

接受的内容为 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.     }  

【运行结果】:

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.     }  

【运行结果】:

姓名: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.     }  

【运行结果】:

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.     }  

【运行结果】:

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.     }  

【运行结果】:

你会在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.     }  

【运行结果】:

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

分享到:
评论

相关推荐

    java中的IO整理完整版

    在案例1中,通过`new File("D:\\hello.txt")`创建了一个`File`对象,然后调用`createNewFile()`方法创建了一个名为`hello.txt`的文件。如果文件已存在或创建失败,此方法将抛出异常。 案例2展示了`File`类的两个...

    java中的IO流整理

    总结,Java中的IO流体系庞大且功能强大,理解并熟练掌握IO流的使用对于Java开发者至关重要,无论是进行文件操作、网络通信还是数据存储,都能发挥关键作用。通过学习不同类型的流以及它们的应用场景,开发者可以更加...

    Java中的IO整理完整版

    在案例1中,通过`File`类的`createNewFile()`方法,我们可以创建一个新的文本文件。例如: ```java File f = new File("D:\\hello.txt"); try { f.createNewFile(); } catch (Exception e) { e.printStackTrace()...

    Java IO复用_动力节点Java学院整理

    在Java中,IO复用允许一个线程同时处理多个连接的读写事件,从而避免了线程频繁地在睡眠和唤醒状态之间切换,提高了系统性能。 传统的并发编程模型通常与线程绑定,每个连接由一个独立的线程处理。虽然这种方法简单...

    Java IO流分析、IO整理与IO优化.pdf

    **输入流**接口`InputStream`和**输出流**接口`OutputStream`构成了Java中基于字节的IO操作基础。这两个接口都有多个子类,用于实现不同类型的数据操作。例如,`FileInputStream`和`FileOutputStream`分别用于从文件...

    Java中IO流简介_动力节点Java学院整理

    Java io系统的设计初衷,就是为了实现“文件、控制台、网络设备”这些io设置的通信。例如,对于一个文件,我们...而到了java 1.1,为了与国际化进行接轨,在java io中添加了许多以字符(Unicode)为单位进行操作的类。

    j0601IO_chicken_Java-IO_prettyjtt_

    Java IO(Input/Output)是Java编程语言中用于处理输入和输出操作的重要部分。这个"j0601IO_chicken_Java-IO_prettyjtt_"标题可能指的是一个关于Java IO的学习资源,其中"chicken"可能是一个比喻,表示初学者或者...

    Java NIO:浅析IO模型_动力节点Java学院整理

    非阻塞IO是指在IO操作过程中,如果条件不满足,会立即返回一个标志信息告知条件不满足,不会一直等待。 四、同步IO和异步IO 同步IO是指在IO操作过程中,一个事件或者任务的执行会导致整个流程的暂时等待。异步IO是...

    javaio流电子书整理面试必考io流帮助你入职阿里腾讯

    Java IO流是Java平台中用于处理输入输出操作的重要部分,对于任何Java开发者,尤其是准备面试或希望在大型公司如阿里、腾讯工作的候选人来说,掌握IO流的知识是必不可少的。以下是对Java IO流的详细解析: **一、为...

    IO流体系继承结构图_动力节点Java学院整理

    Java的IO流体系是Java平台的核心特性之一,用于处理数据的输入和输出。这个体系结构设计得相当丰富和灵活,可以适应多种不同的场景。我们主要从两个方面来理解这个体系:对称性质和处理器模式。 首先,IO流的对称...

    java常用的工具类整理28个

    16. **java.io.ByteArrayInputStream**和**java.io.ByteArrayOutputStream**:用于内存中的字节流操作。 17. **java.util.zip.***:包括`ZipInputStream`、`ZipOutputStream`等,用于处理ZIP文件的压缩和解压。 18...

    Java-IO流基础例题 & 例题源码 & PPT教学文档(黑马程序员详细版).rar

    总结,Java IO流是Java编程中的基石,掌握了流的操作,意味着你能够有效地处理程序的数据输入输出,无论是本地文件、网络通信还是内存数据交换。通过学习提供的资源,包括例题、源码和PPT,你可以全面掌握Java IO流...

    JAVA高级知识点整理.rar

    本资料"JAVA高级知识点整理.rar"主要涵盖了多线程、虚拟机、Java IO/NIO以及Java集合框架等核心主题,旨在帮助开发者深入理解Java平台的高级特性和最佳实践。 首先,多线程是Java编程中的重要组成部分,它允许程序...

    JAVA核心面试知识整理

    Java中的IO操作包括输入和输出操作,提供了一套标准的Java IO库供用户使用。 2.8.1 阻塞IO模型 在阻塞IO模型中,应用程序在进行I/O操作时,必须等待数据准备好后才能进行,期间线程会被阻塞。 2.8.2 非阻塞IO模型 ...

    JAVA核心知识点整理.pdf

    从给定文件的标题、描述、标签以及部分内容中整理出的Java核心知识点如下: 首先,标题中的"JAVA核心知识点整理.pdf"说明这份文档是一个关于Java编程语言的核心知识集合,很可能是为了面试准备而编写的资料。描述中...

    Java常用代码整理

    在"Java常用代码整理"这个主题中,我们可以探讨多个Java编程中的关键知识点,包括基础语法、面向对象特性、异常处理、集合框架、IO流、多线程、网络编程以及实用工具类等。 1. **基础语法**:Java的基础语法包括...

    Java学习资料 包含了java SE中的集合、String类和IO流中一些常用的API的知识点整理

    这份"Java学习资料"涵盖了Java标准版(Java SE)中的几个关键部分:集合框架、String类以及输入/输出(IO)流。这些知识点是每个Java开发者必须掌握的基础。 首先,让我们深入了解一下Java集合框架。集合框架是Java...

Global site tag (gtag.js) - Google Analytics