黑马程序员_IO流2

-----------android培训、java培训、期待与您交流！ ------------

1.File概述
File类是文件和目录路径名的抽象表示形式。 
用户界面和操作系统使用与系统相关的路径名字符串 来命名文件和目录。此类呈现分层路径名的一个抽象的、与系统无关的视图。
抽象路径名 有两个组件： 
a.一个可选的与系统有关的前缀 字符串，比如盘符，"/" 表示 UNIX 中的根目录，"\\\\" 表示 Microsoft Windows UNC 路径名。 
b.零个或更多字符串名称 的序列。 
如何建立一个File对象？
File f1 = new File("C:\\a.txt");


2.File对象功能
创建：
boolean createNewFile();当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
eg:

[java]  view plain copy

1. import java.io.File;  
2. import java.io.IOException;  
3.   
4. class Test{  
5.     public static void main(String[] args) throws IOException {  
6.         method();  
7.     }  
8.     public static void method() throws IOException {  
9.         File f = new File("file.txt");  
10.         System.out.println("create:"+f.createNewFile());//运行一次输出true，第二次输出false  
11.     }  
12. }  

boolean mkdir();创建文件夹
boolean mkdir();创建多级文件夹
eg:

[java]  view plain copy

1. File dir = new File("C:\\a\\b\\c\\d\\e");  
2. System.out.println(dir.mkdir());  
3. System.out.println(dir.mkdirs());  

删除：
boolean delete();删除此抽象路径名表示的文件或目录,删除失败返回false
void deteleOnExit();在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
eg:
File f = new File("file.txt");
f.deleteOnExit();
//System.out.println("delete:"+f.delete());


判断
boolean exists();测试此抽象路径名表示的文件或目录是否存在。
boolean canExecute();测试应用程序是否可以执行此抽象路径名表示的文件。
eg:
File f = new File("fa.txt");
System.out.println(fa.exists());
boolean isDirectory();判断是否是一个目录
boolean isFile();判断是否是一个文件
eg:
//在判断文件对象是否是文件或是目录时，必须先判断文件对象中的内容是否存在
//通过exists方法判断是否存在
File file = new File("x.txt");
System.out.println(x.isDirectory());
System.out.println(x.isFile());
boolean isHidden();判断是否是隐藏文件


获取
String getName(); 返回由此抽象路径名表示的文件或目录的名称。
String getPath();将此抽象路径名转换为一个路径名字符串
String getParent();返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
String getAbsolutePath();返回此抽象路径名的绝对路径名字符串。
File getAbsoluteFile();返回此抽象路径名的绝对路径名形式。
long lastModified();返回此抽象路径名表示的文件最后一次被修改的时间。
long length();返回由此抽象路径名表示的文件的长度。
eg:

[java]  view plain copy

1. import java.io.File;  
2.   
3. class Test {  
4.     public static void main(String[] args) {  
5.         File f = new File("fa.txt");  
6.         System.out.println(f.getName());//fa.txt  
7.         System.out.println(f.getPath());//fa.txt  
8.         System.out.println(f.getAbsolutePath());//F:\javaworkspace\learnjava\fa.txt  
9.         System.out.println(f.getParent());//null  
10.         System.out.println(f.length());//0  
11.     }  
12. }  

文件列表
String[] list();返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
static File[] listRoots(); 列出可用的文件系统根。
String[] list(FilenameFilter filter);返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[] listFiles();返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
File[] listFiles();返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
eg:

[java]  view plain copy

1. import java.io.File;  
2.   
3. class Test {  
4.     public static void main(String[] args) {  
5.         File[] files = File.listRoots();  
6.         for (File file : files) {   //高级for循环  
7.             System.out.println(file);  
8.         }  
9.     }  
10. }  
11. /* 
12. 输出结果： 
13. C:\ 
14. D:\ 
15. F:\ 
16.  */  
17.    
18. eg:  
19.  import java.io.File;  
20.   
21. class Test {  
22.     public static void main(String[] args) {  
23.         File f = new File("f:\\java");  
24.         String[] list = f.list();//调用list方法的file对象必须是封装了一个目录，该目录必须存在  
25.         for (String string : list) {  
26.             System.out.println(string);  
27.         }  
28.     }  
29. }  
30. /* 
31. 输出结果： 
32. cmd.exe 
33. Test.java 
34. Test.class 
35. Test1.class 
36. AException.class 
37. FuShuException.class 
38.  */  
39.   
40. eg:  
41. package cn.itcast;  
42.   
43. import java.io.File;  
44. import java.io.FilenameFilter;  
45.   
46. class Test {  
47.     public static void main(String[] args) {  
48.   
49.         File dir = new File("f:\\java");  
50.         String[] list = dir.list(new FilenameFilter() {//匿名内部类  
51.             public boolean accept(File dir, String name) {  
52.                 return name.endsWith(".java");//过滤出.java文件  
53.             }  
54.         });  
55.         for (String string : list) {  
56.             System.out.println(string);  
57.         }  
58.     }  
59. }  
60. /* 
61. 运行结果： 
62. Test.java 
63. */  

3.列出目录下所有内容
递归：
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可
在列出过程中出现的还是目录的话，还可以再次调用本功能
也就是函数自身调用自身
这种表现形式，或者说是编程手法叫做递归


递归注意事项：
a.限定条件
b.要注意递归的次数，尽量避免内存溢出
//列出指定目录下文件或者文件夹，包含子目录中的内容

[java]  view plain copy

1. import java.io.File;  
2. import java.io.FilenameFilter;  
3.   
4. class Test {  
5.     public static void main(String[] args) {  
6.         File dir = new File("F:\\javaworkspace");  
7.         showDir(dir);  
8.     }  
9.   
10.     public static void showDir(File dir) {  
11.         System.out.println(dir);  
12.         File[] files = dir.listFiles();  
13.         for (int x = 0; x < files.length; x++) {  
14.             //递归的条件：是目录就递归，不是目录就不递归  
15.             if (files[x].isDirectory())  
16.                 showDir(files[x]);  
17.             else  
18.                 System.out.println(files[x]);  
19.         }  
20.     }  
21. }  

带层次：

[java]  view plain copy

1. import java.io.File;  
2.   
3. class Test {  
4.     public static void main(String[] args) {  
5.         File dir = new File("F:\\javaworkspace");  
6.         showDir(dir,0);  
7.     }  
8.   
9.     public static String getLevel(int level) {  //分层  
10.         StringBuilder sb = new StringBuilder();  
11.         for (int x = 0; x < level; x++) {  
12.             sb.append("  ");  
13.         }  
14.         return sb.toString();  
15.     }  
16.   
17.     public static void showDir(File dir,int level) {  
18.         System.out.println(getLevel(level) + dir.getName());  
19.         level++;    
20.         File[] files = dir.listFiles();  
21.         for (int x = 0; x < files.length; x++) {  
22.             if (files[x].isDirectory())  
23.                 showDir(files[x],level);  
24.             else  
25.                 System.out.println(getLevel(level)+files[x]);  
26.         }  
27.     }  
28. }  

4.删除带内容的目录
删除原理：
在windows中，删除目录从里面往外面删除
既然是从里往外删除，就需要用到递归

[java]  view plain copy

1. import java.io.File;  
2.   
3. class Test {  
4.     public static void main(String[] args) {  
5.         File dir = new File("f:\\java");  
6.         removeDir(dir);  
7.     }  
8.     public static void removeDir(File dir) {  
9.         File[] files = dir.listFiles();  
10.         for(int x=0; x<files.length; x++){  
11.             if(!files[x].isHidden() && files[x].isDirectory())  
12.                 removeDir(files[x]);    //递归  
13.             else  
14.                 System.out.println(files[x].toString()+"  "+files[x].delete());  
15.         }  
16.         System.out.println(dir+"::dir::"+dir.delete());  
17.     }  
18.   
19. }  

5.创建java文件列表

[java]  view plain copy

1. /* 
2. 将一个指定目录下的java文件的绝对路径，存储到一个文本文件中 
3. 建立一个java文件列表文件 
4.  */  
5. import java.io.BufferedWriter;  
6. import java.io.File;  
7. import java.io.FileWriter;  
8. import java.io.IOException;  
9. import java.util.ArrayList;  
10. import java.util.List;  
11.   
12. /* 
13.  * 思路： 
14.  * 1.对指定的目录进行递归 
15.  * 2.获取递归过程中所有的java文件的路径 
16.  * 3.将这些路径存储到集合中 
17.  * 4.将集合中的数据写入到一个文件中 
18.  */  
19. class Test {  
20.     public static void main(String[] args) throws IOException {  
21.         File dir = new File("F:\\java");  
22.         List<File> list = new ArrayList<File>();  
23.         fileToList(dir, list);  
24.         File file = new File(dir,"javalist.txt");  
25.         writeToFile(list,file.toString());  
26.     }  
27.   
28.     public static void fileToList(File dir, List<File> list) {  
29.         File[] files = dir.listFiles();  
30.         for (File file : files) {  
31.             if (file.isDirectory())  
32.                 fileToList(file, list);  
33.             else {  
34.                 if (file.getName().endsWith(".java"))  
35.                     list.add(file);  
36.             }  
37.         }  
38.     }  
39.   
40.     public static void writeToFile(List<File> list, String javaListFile)  
41.             throws IOException {  
42.         BufferedWriter bufw = null;  
43.         try {  
44.             bufw = new BufferedWriter(new FileWriter(javaListFile));  
45.             for (File file : list) {  
46.                 String path = file.getAbsolutePath();  
47.                 bufw.write(path);  
48.                 bufw.newLine();  
49.                 bufw.flush();  
50.             }  
51.         } catch (IOException e) {  
52.             throw e;  
53.         } finally {  
54.             try {  
55.                 if (bufw != null)  
56.                     bufw.close();  
57.             } catch (IOException e) {  
58.                 throw e;  
59.             }  
60.         }  
61.     }  
62. }  

6.Properties概述
Properties是hashtable的字类
也就是说他具备map集合的特点，而且她里面存储的键值对都是字符串
是集合中和IO技术相结合的集合容器
该对象的特点，可以用于键值对形式的配置文件
加载数据时，需要数据有固定格式


7.Properties存取
相关方法：
Object setProperty(String key, String value);  调用 Hashtable 的方法 put。
String getProperty(String key)用指定的键在此属性列表中搜索属性。
Set<String> stringPropertyName()返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。
eg:

[java]  view plain copy

1. import java.util.Properties;  
2. import java.util.Set;  
3.   
4. public class Test1 {  
5.   
6.     public static void main(String[] args) {  
7.         setAndGet();  
8.     }  
9.       
10.     public static void setAndGet() {  
11.         Properties prop = new Properties(); //创建Properties对象  
12.         prop.setProperty("zhangsan", "23"); //存储  
13.         prop.setProperty("lisi", "38");  
14.         String value = prop.getProperty("lisi"); //通过键值获取属性  
15.         System.out.println(value);  
16.         System.out.println(prop);  
17.           
18.         prop.setProperty("lisi", 89+"");  
19.         Set<String> names = prop.stringPropertyNames();//返回属性列表中的键集  
20.         for (String string : names) {  
21.             System.out.println(string+"..."+prop.getProperty(string));  
22.         }  
23.     }  
24.   
25. }  

8.Properties存取配置文件
相关方法：
void list(PrintStream out)将属性列表输出到指定的输出流。
void load(InputStream inStream)从输入流中读取属性列表（键和元素对）。
void store(OutputStream out,String comments);以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。

[java]  view plain copy

1. //将info.txt中键值数据存到集合中进行操作  
2. /* 
3.     1.用一个流和info.txt文件关联 
4.     2.读取一行数据，将改行数据用“=”进行切割 
5.     3.等号左边作为键，右边作为值，存入到Properties集合中即可 
6.  */  
7.   
8. //JDK1.6之前的做法  
9. import java.io.BufferedReader;  
10. import java.io.FileReader;  
11. import java.io.IOException;  
12. import java.util.Properties;  
13.   
14. public class Test1 {  
15.   
16.     public static void main(String[] args) throws IOException {  
17.         BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));  
18.         String line = null;  
19.         Properties prop = new Properties();  
20.         while ((line=bufr.readLine())!=null) {  
21.             String[] arr = line.split("="); //字符串切割  
22.             prop.setProperty(arr[0], arr[1]);  
23.         }  
24.         bufr.close();  
25.         System.out.println(prop);  
26.     }  
27.   
28. }  
29.   
30. //使用JDK1.6之后的load方法  
31. import java.io.FileInputStream;  
32. import java.io.IOException;  
33. import java.util.Properties;  
34.   
35. public class Test1 {  
36.   
37.     public static void main(String[] args) throws IOException {  
38.         Properties prop = new Properties();  
39.         FileInputStream fis = new FileInputStream("info.txt");  
40.         //调用load方法将流中的数据加载进集合  
41.         prop.load(fis);  
42.         //System.out.println(prop);  
43.         //列出集合目录  
44.         prop.list(System.out);  
45.         prop.setProperty("wangwu","39");//修改prop中的内容，并不能修改文件中的数据  
46.         FileOutputStream fos = new FileOutputStream("info.txt");  
47.         prop.store(fos,"haha");//haha为注释信息  
48.         fos.close();  
49.         fis.close();  
50.     }  
51.   
52. }  

9.Properties练习

[java]  view plain copy

1. import java.io.File;  
2. import java.io.FileInputStream;  
3. import java.io.FileOutputStream;  
4. import java.io.IOException;  
5. import java.util.Properties;  
6.   
7. /* 
8.  * 用于记录应用程序运行次数 
9.  * 如果使用次数已到，那么给注册提示 
10.  * 本例无法使用计数器，因为随着程序退出，计数器也会消失 
11.  * 因此要建立一个配置文件，用于记录该软件的使用次数 
12.  * 配置文件可以使用键值对的形式 
13.  * 这样便于阅读数据并且操作数据 
14.  */  
15. public class Test1 {  
16.   
17.     public static void main(String[] args) throws IOException {  
18.         Properties prop = new Properties();  
19.         File file = new File("count.ini");//封装成File对象  
20.         if (!file.exists()) {  
21.             file.createNewFile();//如果文件不存在则创建新文件  
22.         }  
23.         FileInputStream fis = new FileInputStream(file);//输入流  
24.         prop.load(fis);//将流中数据加载进集合  
25.         int count = 0;  
26.         String value = prop.getProperty("times");  
27.         if (value!=null) {  
28.             count = Integer.parseInt(value);//获取上次运行结束后的次数  
29.             if (count >= 5) {  
30.                 System.out.println("您好，使用次数已到");  
31.                 return;  
32.             }  
33.         }  
34.         count++;  
35.         prop.setProperty("times", count+"");//修改属性  
36.         FileOutputStream fos = new FileOutputStream(file);  
37.         prop.store(fos, "");//写入文件，无注释信息  
38.         fos.close();//关闭流  
39.         fis.close();  
40.     }  
41.   
42. }  

10.打印流
向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream 中的所有 print 方法。它不包含用于写入原始字节的方法，对于这些字节，程序应该使用未编码的字节流进行写入。
与 PrintStream 类不同，如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作，而不是每当正好输出换行符时才完成。这些方法使用平台自有的行分隔符概念，而不是换行符。 
打印流提供了打印方法，可以各种数据类型的数据都原样打印
字节打印流
PrintStream
构造函数可以接收的参数类型有：
1.file对象 File
2.字符串路径 String
3.字节输出流 OutputStream


字符打印流
PrintWriter
构造函数可以接收的参数类型有：
1.file对象 File
2.字符串路径 String
3.字节输出流 OutputStream
4.字符输出流 Writer

eg:

[java]  view plain copy

1. import java.io.BufferedReader;  
2. import java.io.IOException;  
3. import java.io.InputStreamReader;  
4. import java.io.PrintWriter;  
5.   
6. public class Test1 {  
7.   
8.     public static void main(String[] args) throws IOException {  
9.         //读取流  
10.         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
11.         //true表示自动刷新  
12.         PrintWriter out = new PrintWriter(System.out,true);  
13.         //PrintWriter out = new PrintWriter("a.txt");//写入文件  
14.         //PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);//自动刷新  
15.           
16.         String line = null;  
17.         while ((line = bufr.readLine())!=null) {  
18.             if("over".equals(line))  
19.                 break;  
20.             out.println(line.toUpperCase());  
21.             //out.flush();//刷新  
22.         }  
23.         out.close();  
24.         bufr.close();  
25.     }  
26.   
27. }  

11.合并流
SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。 


构造函数
SequenceInputStream(InputStream s1, InputStream s2) 
通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个参数，先读取 s1，然后读取 s2），以提供从此 SequenceInputStream 读取的字节。

eg:

[java]  view plain copy

1. import java.io.FileInputStream;  
2. import java.io.FileOutputStream;  
3. import java.io.IOException;  
4. import java.io.SequenceInputStream;  
5. import java.util.Enumeration;  
6. import java.util.Vector;  
7.   
8. public class Test1 {  
9.   
10.     public static void main(String[] args) throws IOException {  
11.         Vector<FileInputStream> v = new Vector<FileInputStream>();  
12.   
13.         v.add(new FileInputStream("c:\\1.txt"));  
14.         v.add(new FileInputStream("c:\\2.txt"));  
15.         v.add(new FileInputStream("c:\\3.txt"));  
16.           
17.         //多个读取流合并成一个流  
18.         Enumeration<FileInputStream> en = v.elements();  
19.         SequenceInputStream sis = new SequenceInputStream(en);  
20.         FileOutputStream fos = new FileOutputStream("c:\\4.txt");  
21.   
22.         byte[] buf = new byte[1024];  
23.         int len = 0;  
24.         while ((len = sis.read(buf)) != -1) {  
25.             fos.write(buf, 0, len);  
26.         }  
27.         fos.close();  
28.         sis.close();  
29.     }  
30.   
31. }  

12.切割文件
实例：

[java]  view plain copy

1. import java.io.FileInputStream;  
2. import java.io.FileOutputStream;  
3. import java.io.IOException;  
4. import java.io.SequenceInputStream;  
5. import java.util.ArrayList;  
6. import java.util.Enumeration;  
7. import java.util.Iterator;  
8.   
9. public class Test1 {  
10.   
11.     public static void main(String[] args) throws IOException {  
12.         splitFile();// 切割文件  
13.         merge();//合并碎片文件  
14.     }  
15.   
16.     public static void merge() throws IOException {  
17.         ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();  
18.         for (int i = 0; i < 3; i++) {  
19.             al.add(new FileInputStream("c:\\splitfiles\\" + i + ".part"));  
20.         }  
21.         //局部内部类  
22.         final Iterator<FileInputStream> it = al.iterator();  
23.         Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() {  
24.             public boolean hasMoreElements() {  
25.                 return it.hasNext();  
26.             }  
27.   
28.             public FileInputStream nextElement() {  
29.                 return it.next();  
30.             }  
31.         };  
32.         SequenceInputStream sis = new SequenceInputStream(en);  
33.         FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");  
34.         byte[] buf = new byte[1024];  
35.         int len = 0;  
36.         while ((len=sis.read(buf))!=-1) {  
37.             fos.write(buf,0,len);  
38.         }  
39.         fos.close();//关闭流  
40.         sis.close();  
41.     }  
42.   
43.     public static void splitFile() throws IOException {  
44.         FileInputStream fis = new FileInputStream("c:\\1.bmp");  
45.   
46.         FileOutputStream fos = null;  
47.         byte[] buf = new byte[1024 * 1024];// 1M  
48.   
49.         int len = 0;  
50.         int count = 1;  
51.         while ((len = fis.read(buf)) != -1) {  
52.             // 分割成count个部分，1M一个部分  
53.             fos = new FileOutputStream("c\\splitfiles\\" + (count++) + ".part");  
54.             fos.write(buf, 0, len);  
55.             fos.close();  
56.         }  
57.         fis.close();  
58.     }  
59.   
60. }  

-----------android培训、java培训、期待与您交流！ ------------