疯狂java学习笔记1113---输入与输出

File 类

      不管是文件，还是目录都是使用File来操作的，File能新建，删除和重命名文件和目录，File不能访问文件内容本身。如果需要访问文件内容，需要使用输入/输出流。

      File类可以使用文件路径字符串来创建File实例，该文件路径字符串既可以是绝对路径，也可以是相对路径，默认运行java虚拟机时所在的路径。
 程序范例：

1. package TestDemo;  
2.  
3. import java.io.File;  
4.  
5. public class FileTest   
6. {  
7.     public static void main(String[] args)  
8.     {  
9.         //以当前路径来创建一个File对象  
10.         File file = new File(".");  
11.         //直接获取文件名，输出一点  
12.         System.out.println(file.getName());  
13.         //获取相对路径的父路径可能出错，下面代码输出null  
14.         System.out.println(file.getParent());  
15.         //获取绝对路径  
16.         System.out.println(file.getAbsoluteFile());  
17.         //在当前路径下创建一个临时文件  
18.         File tmpFile = File.createTempFile("aaa",".txt",file);  
19.         //指定jvm退出时删除该文件  
20.         tmpFile.deleteOnExit();  
21.         //以系统当前时间作为新文件名来创建新文件  
22.         File newFile = new File(System.currentTimeMillis()+"");  
23.         System.out.println("newFile对象是否存在："+ newFile.exists());  
24.         //以指定newFile对象来创建一个文件  
25.         newFile.createNewFile();  
26.         String[] fileList = file.list();  
27.         //使用list方法来列出当前路径下的所有文件和路径  
28.         System.out.println("====当前路径下所有文件和路径如下====");  
29.         for(String fileName : fileList)  
30.         {  
31.             System.out.println(fileName);  
32.         }  
33.         //listRoots静态方法列出所有的磁盘根路径。  
34.         File[] roots = File.listRoots();  
35.         System.out.print("====系统所有根路径如下====");  
36.         for(File root : roots)  
37.         {  
38.             System.out.println(root);  
39.         }  
40.     }  
41. }
42. /*
43. 结果：newFile对象是否存在：false
    ====当前路径下所有文件和路径如下====
    .classpath
    .project
    .settings
    1352804494328
    aaa2845250731390905188.txt
    bin
    src
    ====系统所有根路径如下====C:\
    D:\
    E:\
44. */ 

 

文件过滤器

         FilenameFilter接口里包含了一个accept(File dir,String name)方法，该方法讲一次对指定
File的所有子目录，子文件夹进行迭代，如果该方法返回true,则list方法会列出该子目录或者子
文件夹。
 

程序范例：

1. package TestDemo;  
2.  
3. import java.io.File;  
4. import java.io.FilenameFilter;  
5.  
6. public class FilenameFilterTest   
7. {  
8.     public static void main(String[] args)  
9.     {  
10.         File file = new File(".");  
11.         String[] nameList = file.list(new MyFilenameFilter());  
12.         for(String name:nameList)  
13.         {  
14.             System.out.println(name);  
15.         }  
16.     }  
17. }  
18. class MyFilenameFilter implements FilenameFilter  
19. {  
20.     public boolean accept(File dir,String name)  
21.     {  
22.         //如果文件名以.java结尾，或者文件对应一个路径，返回true  
23.         return name.endsWith(".java")||new File(name).isDirectory();  
24.     }  
25. }  

 

节点流和处理流

         可以从/向一个特定的IO设备（如磁盘、网络）读/写数据的流，称为节点流。(低级流)
         当使用节点流来进行输入/输出时，程序直接连接到实际的数据源，和实际的输入/输出节点连接。
      处理流用于对一个已存在的流进行连接或封装，通过封装后流来实现数据读/写功能。（高级流）
        当使用处理流来进行输入/输出时，程序并不会直接连接到实际的数据源，没有和实际的输入/输出节点连接。

        通过使用处理流来包装不同的节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入/输出功能。因此处理流也被称为包装流。

字节流和字符流

InputStream和Reader都是抽象类，本身不能创建实例，但他们分别有一个用于读取文件的输入流：FileInputStream 和 FileReader,他们都是节点流-------会直接和指定文件关联。
程序范例：

1. package TestDemo;  
2.  
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.IOException;  
6.  
7. public class FileInputStreamTest   
8. {  
9.     public static void main(String[] args) throws IOException  
10.     {  
11.         //创建字节输入流  
12.         FileInputStream fis = new FileInputStream("FileInputStreamTest.java");  
13.         // 创建一个长度为1024的”竹筒“  
14.         byte[] bbuf = new byte[1024];  
15.         //用于保存实际读取的字节数  
16.         int hasRead = 0;  
17.         //使用循环来重复”取水“过程  
18.         while((hasRead = fis.read(bbuf))>0)  
19.         {  
20.             //取出”竹筒“中水滴（字节），将字节数组转换成字符串输入  
21.             System.out.println(new String(bbuf,0,hasRead));  
22.         }  
23.         //关闭文件输入流，放在finally块里更安全  
24.         fis.close();  
25.     }  
26. }  
27. /*  
28.  * 结果：输出这个程序的源码  
29.  * */ 

 

1. package TestDemo;  
2.  
3. import java.io.FileReader;  
4. import java.io.IOException;  
5.  
6. public class FileReaderTest   
7. {  
8.     public static void main(String[] args) throws IOException  
9.     {  
10.         FileReader fr = null;  
11.         try 
12.         {  
13.             //创建字符输入流  
14.             fr = new FileReader("FileReaderTest.java");  
15.             //创建一个长度为32的“竹筒”  
16.             char[] cbuf = new char[32];  
17.             //用于保存实际读取的字符数  
18.             int hasRead  = 0;  
19.             //使用循环来重复“取水”过程  
20.             while((hasRead = fr.read(cbuf))>0)  
21.             {  
22.                 //取出“竹筒”中的水滴（字节），将字符数转换成字符串输入  
23.                 System.out.println(new String(cbuf,0,hasRead));  
24.             }  
25.         }  
26.         catch(IOException ioe)  
27.         {  
28.             ioe.printStackTrace();  
29.         }  
30.         finally 
31.         {  
32.             //使用finally块来关闭文件输入流  
33.             if(fr != null)  
34.             {  
35.                 fr.close();  
36.             }  
37.         }  
38.     }  
39. }  

 

1. package TestDemo;  
2.  
3. import java.io.FileInputStream;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6.  
7. public class FileOutputStreamTest   
8. {  
9.     public static void main(String[] args) throws IOException  
10.     {  
11.         FileInputStream fis = null;  
12.         FileOutputStream fos = null;  
13.         try 
14.         {  
15.             //创建字节输入流  
16.             fis = new FileInputStream("FileOutputStreamTest.java");  
17.             //创建字节输出流  
18.             fos = new FileOutputStream("newFile.txt");  
19.             byte [] bbuf  = new byte[32];  
20.             int hasRead = 0;  
21.             //循环从输入流中取出数据  
22.             while((hasRead = fis.read(bbuf))>0)  
23.             {  
24.                 //每读取一次，即写入文件输出流，读了多少，就写多少  
25.                 fos.write(bbuf,0,hasRead);  
26.             }  
27.         }  
28.         catch(IOException ioe)  
29.         {  
30.             ioe.printStackTrace();  
31.         }  
32.         finally 
33.         {  
34.             if(fis != null)  
35.             {  
36.                 fis.close();  
37.             }  
38.             if(fos != null)  
39.             {  
40.                 fos.close();  
41.             }  
42.         }  
43.     }  
44. }  

 

1. package TestDemo;  
2.  
3. import java.io.FileWriter;  
4. import java.io.IOException;  
5.  
6. public class FileWriterTest  
7. {  
8.     public static void main(String[] args) throws IOException  
9.     {  
10.         FileWriter fw = null;  
11.         try 
12.         {  
13.             //创建字符输出流  
14.             fw = new FileWriter("poem.txt");  
15.             fw.write("蛋疼\r\n");  
16.             fw.write("你蛋疼吗？\r\n");  
17.         }  
18.         catch(IOException ioe)  
19.         {  
20.             ioe.printStackTrace();  
21.         }  
22.         finally 
23.         {  
24.             if(fw != null)  
25.             {  
26.                 fw.close();  
27.             }  
28.               
29.         }  
30.     }  
31. }  
32. /*  
33.  *    "/r/n"是Windows平台的换行符，可以让输出内容换行。如果是Unix/Linux/BSD  
34.  *    平台，只要使用\n就可以了  
35.  * */ 

处理流的用法：

 

1. package J1114;  
2.  
3. import java.io.FileOutputStream;  
4. import java.io.IOException;  
5. import java.io.PrintStream;  
6.  
7. /*  
8.  * 使用PrintStream处理流来包装InputStream  
9.  * */ 
10. public class PrintStreamTest   
11. {  
12.     public static void main(String[] args)throws IOException  
13.     {  
14.         PrintStream ps = null;  
15.         try 
16.         {  
17.             //创建一个节点输出流：FileOutputStream  
18.             FileOutputStream fos = new FileOutputStream("test.txt");  
19.             //以PrintStream来包装FileOutputStream输出流  
20.             ps = new PrintStream(fos);  
21.             //使用PrintStream执行输出  
22.             ps.println("普通字符串");  
23.             //直接使用PrintStream输出对象  
24.             ps.println(new PrintStreamTest());  
25.         }  
26.         catch(IOException ioe)  
27.         {  
28.             ioe.printStackTrace();  
29.         }  
30.         finally 
31.         {  
32.             ps.close();  
33.         }  
34.     }  
35. }  

从前面代码可以看出，程序使用处理流非常简单，通常只需要在创建处理流时传入一个节点流构造参数即可，这样创建的处理流就是包装了该节点的处理流。

        当我们使用处理流来包装底层节点流之后，关闭输入输出流资源时，只要关闭最上层的处理流即可。关闭最上层的处理流时，系统会自动关闭被该处理流包装的节点流。

转载于:https://blog.51cto.com/chengxuyuan/1059291