笔记总链接：http://bbs.itheima.com/thread-200600-1-1.html

8、IO

8.2 IO流

    8.2.7 File类

    需求：获取c盘目录下的隐藏文件。

    代码：

1. import java.io.File;
   
2. import java.io.FilenameFilter;
   
3. 
   
4. public class FileListDemo{
   
5.        public static void main(String[] args){
   
6.             listDemo();
   
7.       }
   
8. 
   
9.        public static void listDemo(){
   
10.             File dir = new File("c:\\" );
    
11. 
    
12.             File[] files = dir.listFiles( new FilterByHidden());
    
13. 
    
14.              for(File file : files){
    
15.                   System.out.println(file);
    
16.             }
    
17.       }
    
18. }
    
19. 
    
20. class FilterByHidden implements FilenameFilter{
    
21.        public boolean accept(File dir,String name){
    
22.              return dir.isHidden();
    
23.       }
    
24. }
    

复制代码

   运行结果：

    8.2.8 递归  

    函数自身直接或者间接的调用到了自身。
    一个功能在被重复使用，并每次使用时，参与运算的结果和上一次调用有关。这时可以用递归来解决问题。

    P.S.
    1、递归一定明确条件，否则容易栈溢出。
    2、注意一下递归的次数。

    需求：对指定目录进行所有内容的列出（包含子目录中的内容），也可以理解为深度遍历。

    代码：

1. import java.io.File;
   
2. 
   
3. public class FileListDemo{
   
4.        public static void main(String[] args){
   
5.             File dir = new File("D:\\Java\\jdk1.6.0_02\\include" );
   
6.             listAll(dir,0);
   
7.       }
   
8. 
   
9.        public static void listAll(File dir, int level){
   
10.             System.out.println(getSpace(level) + "dir:" + dir.getAbsolutePath());
    
11.              //获取指定目录下当前的所有文件夹或者文件对象
    
12.             level++;
    
13.             File[] files = dir.listFiles();
    
14. 
    
15.              for (int x = 0; x < files.length; x++){
    
16.                    if (files[x].isDirectory()){
    
17.                         listAll(files[x],level);
    
18.                   }
    
19.                   System.out.println(getSpace(level) + "file:" + files[x].getAbsolutePath());
    
20.             }
    
21.       }
    
22. 
    
23.        private static String getSpace( int level){
    
24.             StringBuilder sb = new StringBuilder();
    
25. 
    
26.             sb.append( "|--" );
    
27.              for (int x = 0; x < level; x++){
    
28.                   sb.append( "| " );
    
29.             }
    
30. 
    
31.              return sb.toString();
    
32.       }
    
33. }
    

复制代码

    运行结果：

    需求：利用递归求6的二进制值。

    代码：

1. public class DiGuiDemo{
   
2.        public static void main(String[] args){
   
3.             toBin(6);
   
4.       }
   
5. 
   
6.        public static void toBin(int num){
   
7.              if(num > 0){
   
8.                   toBin(num/2);
   
9.                   System.out.print(num%2);
   
10.             }
    
11.       }
    
12. }
    

复制代码

   运行结果：

    需求：利用递归求1到10的和。

    代码：

1. public class DiGuiDemo{
   
2.        public static void main(String[] args){
   
3.              int sum = getSum(10);
   
4.             System.out.println(sum);
   
5.       }
   
6. 
   
7.        public static int getSum(int num){
   
8.              if(num == 1)
   
9.                    return 1;
   
10.              return num + getSum(num - 1);
    
11.       }
    
12. }
    

复制代码

   运行结果：

    需求：删除一个带内容的目录。
    原理：必须从里面往外删，需要进行深度遍历。

    代码：

1. import java.io.File;
   
2. 
   
3. public class RemoveDirTest{
   
4.        public static void main(String[] args){
   
5.             File dir = new File("d:\\demo" );
   
6.             removeDir(dir);
   
7.       }
   
8. 
   
9.        public static void removeDir(File dir){
   
10.             File[] files = dir.listFiles();
    
11. 
    
12.              for(File file : files){
    
13.                    if(file.isDirectory()){
    
14.                         removeDir(file);
    
15.                   } else{
    
16.                         System.out.println(file + ":" + file.delete());
    
17.                   }
    
18.             }
    
19.             System.out.println(dir + ":" + dir.delete());
    
20.       }
    
21. }
    

复制代码

   运行结果：

    8.2.9 Properties集合

    Map
          |--Hashtable
               |--Properties

    特点：
    1. 该集合中的键和值都是字符串类型。
    2. 集合中的数据可以保存到流中，或者从流中获取。

    3. 通常该集合用于操作以键值对形式存在的配置文件。

    Properties集合的存和取。

    示例1：

1. import java.util.Properties;
   
2. import java.util.Set;
   
3. 
   
4. public class PropertiesDemo{
   
5.        public static void main(String[] args){
   
6.             propertiesDemo();
   
7.       }
   
8. 
   
9.        public static void propertiesDemo(){
   
10.              //创建一个Properties集合
    
11.             Properties prop = new Properties();
    
12. 
    
13.              //存储元素
    
14.             prop.setProperty( "zhangsan","10" );
    
15.             prop.setProperty( "lisi","20" );
    
16.             prop.setProperty( "wangwu","30" );
    
17.             prop.setProperty( "zhaoliu","40" );
    
18.             
    
19.              //修改元素
    
20.             prop.setProperty( "wangwu","26" );
    
21. 
    
22.              //取出所有元素
    
23.             Set<String> names = prop.stringPropertyNames();
    
24. 
    
25.              for(String name : names){
    
26.                   String value = prop.getProperty(name);
    
27.                   System.out.println(name + ":" + value);
    
28.             }
    
29.       }
    
30. }
    

复制代码

   运行结果：

    演示Properties集合和流对象相结合的功能。

    示例2：

1. import java.util.Properties;
   
2. 
   
3. public class PropertiesDemo{
   
4.        public static void main(String[] args){
   
5.             propertiesDemo();
   
6.       }
   
7. 
   
8.        public static void propertiesDemo(){
   
9.             Properties prop = new Properties();
   
10. 
    
11.             prop.setProperty( "zhangsan","10" );
    
12.             prop.setProperty( "lisi","20" );
    
13.             prop.setProperty( "wangwu","30" );
    
14.             prop.setProperty( "zhaoliu","40" );
    
15.             
    
16.             prop.list(System.out);
    
17.       }
    
18. }
    

复制代码

    运行结果：

    示例3：  

1. import java.io.FileOutputStream;
   
2. import java.util.Properties;
   
3. 
   
4. public class PropertiesDemo{
   
5.        public static void main(String[] args) throws Exception  {
   
6.             propertiesDemo();
   
7.       }
   
8. 
   
9.        public static void propertiesDemo() throws Exception {
   
10.             Properties prop = new Properties();
    
11. 
    
12.             prop.setProperty( "zhangsan","10" );
    
13.             prop.setProperty( "lisi","20" );
    
14.             prop.setProperty( "wangwu","30" );
    
15.             prop.setProperty( "zhaoliu","40" );
    
16.             
    
17.              //想要将这些集合中的字符串键值信息持久化存储到文件中
    
18.              //需要关联输出流
    
19.             FileOutputStream fos = new FileOutputStream("info.txt" );
    
20. 
    
21.              //将集合中数据存储到文件中
    
22.             prop.store(fos, "name+age");
    
23. 
    
24.             fos.close();
    
25.       }
    
26. }
    

复制代码

    运行结果：

    示例4：

1. import java.io.BufferedReader;
   
2. import java.io.File;
   
3. import java.io.FileInputStream;
   
4. import java.io.FileReader;
   
5. import java.io.FileWriter;
   
6. import java.io.IOException;
   
7. import java.util.Properties;
   
8. 
   
9. public class PropertiesDemo{
   
10.        public static void main(String[] args) throws Exception {
    
11.             propertiesDemo();
    
12.       }
    
13. 
    
14.        public static void propertiesDemo() throws Exception {
    
15.             Properties prop = new Properties();
    
16. 
    
17.              //集合中的数据来自于一个文件。
    
18.              //注意：必须要保证该文件中的数据是键值对。
    
19.              //需要使用到读取流
    
20.             FileInputStream fis = new FileInputStream("info.txt" );
    
21. 
    
22.              //使用load方法
    
23.             prop.load(fis);
    
24.             prop.list(System.out);
    
25. 
    
26.             test();
    
27.             myLoad();
    
28.       }
    
29.       
    
30.        //对已有的配置文件中的信息进行修改。
    
31.        //读取这个文件。并将这个文件中的键值数据存储到集合中。再通过集合对数据进行修改。
    
32.        //再通过流将修改后的数据存储到文件中
    
33.        public static void test() throws Exception {
    
34.              //读取这个文件
    
35.             File file = new File("info.txt" );
    
36.              if(!file.exists()){
    
37.                   file.createNewFile();   
    
38.             }
    
39.             FileReader fr = new FileReader("info.txt" );
    
40. 
    
41.              //创建集合存储配置信息
    
42.             Properties prop = new Properties();
    
43. 
    
44.              //将流中信息存储到集合中
    
45.             prop.load(fr);
    
46. 
    
47.             prop.setProperty( "wangwu","26" );
    
48. 
    
49.             FileWriter fw = new FileWriter(file);
    
50. 
    
51.             prop.store(fw, "");
    
52. 
    
53.             fr.close();
    
54.       }
    
55. 
    
56.        //模拟一下load方法
    
57.        public static void myLoad() throws Exception {
    
58.             Properties prop = new Properties();
    
59. 
    
60.             BufferedReader bufr = new BufferedReader(new FileReader("info.txt" ));
    
61.       
    
62.             String line = null;
    
63. 
    
64.              while((line = bufr.readLine()) != null){
    
65.                    if(line.startsWith("#" ))
    
66.                          continue;
    
67.                   String[] arr = line.split( "=");
    
68.                   prop.setProperty(arr[0],arr[1]);
    
69.             }
    
70. 
    
71.             prop.list(System.out);
    
72.             bufr.close();
    
73.       }
    
74. }
    

复制代码

  运行结果：

    需求：获取一个应用程序运行的次数，如果超过5次，给出使用次数已到请注册的提示，并不要再运行程序。

    思路：
    1、应该有计数器
    每次程序启动都需要计数一次，并且是在原有的次数上进行计数。
    2、计数器就是一个变量。突然冒出一想法，程序启动时进行计数，计数器必须存在于内存并进行运算。
    可是程序一结束，计数器消失了。那么再次启动该程序，计数器又重新被初始化了。
    而我们需要多次启动同一个应用程序，使用的是同一个计数器。
    这就需要计数器的生命周期边长，从内存存储到硬盘文件中。
    3、如何使用这个计数器呢？
    首先，程序启动时，应该先读取这个用于记录计数器信息的配置文件。
    获取上一次计数器次数。并进行使用次数的判断。
    其次，对该次数进行自增，并自增后的次数重新存储到配置文件中。
    4、文件中的信息该如何进行存储并体现。
    直接存储次数值可以，但是不明确该数据的含义。所以起名字就变得很重要。
    这就有了名字和值的对应，所以可以使用键值对。
    可是映射关系map集合搞定，又需要读取硬盘上的数据，所以map+io=properties。

    代码：

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. public class PropertiesTest{
   
8.        public static void main(String[] args) throws IOException{
   
9.             getAppCount();
   
10.       }
    
11. 
    
12.        public static void getAppCount() throws IOException {
    
13.              //将配置文件封装成File对象
    
14.             File confile = new File("count.properties" );
    
15. 
    
16.              if(!confile.exists()){
    
17.                   confile.createNewFile();
    
18.             }
    
19. 
    
20.             FileInputStream fis = new FileInputStream(confile);
    
21.       
    
22.             Properties prop = new Properties();
    
23. 
    
24.             prop.load(fis);
    
25. 
    
26.              //从集合中通过键获取次数
    
27.             String value = prop.getProperty( "time");
    
28.             
    
29.              //定义计数器，记录获取到的次数
    
30.              int count = 0;
    
31.              if(value != null){
    
32.                   count = Integer.parseInt(value);
    
33.                    if(count >= 5){
    
34.                          throw new RuntimeException("使用次数已到，请注册，给钱！" );
    
35.                   }
    
36.             }
    
37.             count++;
    
38. 
    
39.              //将改变后的次数重新存储到集合中。
    
40.             prop.setProperty( "time",count + "" );
    
41. 
    
42.             FileOutputStream fos = new FileOutputStream(confile);
    
43. 
    
44.             prop.store(fos, "");
    
45. 
    
46.             fos.close();
    
47.             fis.close();
    
48.       }
    
49. }
    

复制代码

   运行结果：

    需求：获取指定目录下，指定扩展名的文件（包含子目录中的），并且将这些文件的绝对路径写入到一个文本文件中。
    简单说：就是建立一个指定扩展名的文件的列表。

    思路：
    1. 必须进行深度遍历。
    2. 要在遍历的过程中进行过滤，将符合条件的内容都存储到容器中。
    3. 对容器中的内容进行遍历并将绝对路径写入到文件中。

    代码：

1. import java.io.BufferedWriter;
   
2. import java.io.File;
   
3. import java.io.FileWriter;
   
4. import java.io.FilenameFilter;
   
5. import java.io.IOException;
   
6. import java.util.ArrayList;
   
7. import java.util.List;
   
8. 
   
9. public class Test{
   
10.        public static void main(String[] args) throws IOException {
    
11.             File dir = new File("d:\\code" );
    
12.             FilenameFilter filter = new FilenameFilter(){
    
13.                    public boolean accept(File dir,String name){
    
14.                          return name.endsWith(".java" );
    
15.                   }
    
16.             };
    
17. 
    
18.             List<File> list = new ArrayList<File>();
    
19.             getFiles(dir,filter,list);
    
20.             File destFile = new File(dir,"javalist.txt" );
    
21.             write2File(list,destFile);
    
22.       }
    
23.        /*
    
24.       对指定目录中的内容进行深度遍历，并按照指定过滤器，进行过滤。
    
25.       将过滤后的内容存储到指定容器List中。
    
26.       */
    
27.        public static void getFiles(File dir,FilenameFilter filter,List<File> list){
    
28.             File[] files = dir.listFiles();
    
29.             
    
30.              for(File file : files){
    
31.                    //递归
    
32.                    if(file.isDirectory()){
    
33.                         getFiles(file,filter,list);
    
34.                   } else{
    
35.                          //对便利到的文件进行过滤器的过滤。将符合条件File对象，存储到List集合中
    
36.                          if(filter.accept(dir,file.getName())){
    
37.                               list.add(file);
    
38.                         }
    
39.                   }
    
40.             }
    
41.       }
    
42. 
    
43.        public static void write2File(List<File> list,File destFile) throws IOException{
    
44.             BufferedWriter bufw = null;
    
45.              try{
    
46.                   bufw = new BufferedWriter(new FileWriter(destFile));
    
47.                   
    
48.                    for(File file : list){
    
49.                         bufw.write(file.getAbsolutePath());
    
50.                         bufw.newLine();
    
51.                         bufw.flush();
    
52.                   }
    
53.             } finally{
    
54.                    if(bufw!=null)
    
55.                          try{
    
56.                               bufw.close();
    
57.                         } catch(IOException e){
    
58.                                throw new RuntimeException("关闭失败");
    
59.                         }
    
60.             }
    
61.       }
    
62. }
    

复制代码

    运行结果：

    8.2.10 IO包中的其他类

    打印流

    PrintWriter与PrintStream：可以直接操作输入流和文件。

    PrintStream为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
    与其他输出流不同，PrintStream永远不会抛出IOException。
    PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。
    在需要写入字符而不是写入字节的情况下，应该使用PrintWriter类。

    PrintStream:
    1. 提供了打印方法可以对多种数据类型值进行打印，并保持数据的表示形式
    2. 它不抛IOException

    构造函数，接收三种类型的值：
    1. 字符串路径
    2. File对象
    3. 字节输出流

    示例1：

1. import java.io.PrintStream;
   
2. 
   
3. public class PrintStreamDemo{
   
4.        public static void main(String[] args) throws Exception {
   
5.             PrintStream out = new PrintStream("print.txt" );
   
6.             
   
7.              //write(int b)方法只写最低8位
   
8.             out.write(97); //a
   
9.             //print方法将97先变成字符串保持原样将数据打印到目的地
   
10.             out.print(97); //97
    
11. 
    
12.             out.close();
    
13.       }
    
14. }
    

复制代码

   运行结果：

    PrintWriter：字符打印流

    构造函数参数：
    1. 字符串路径
    2. File对象
    3. 字节输出流
    4. 字符输出流

    示例2：

1. import java.io.BufferedReader;
   
2. import java.io.InputStreamReader;
   
3. import java.io.PrintWriter;
   
4. import java.io.IOException;
   
5. 
   
6. public class PrintWriterDemo{
   
7.        public static void main(String[] args) throws IOException {
   
8.             BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
   
9.             PrintWriter out = new PrintWriter(System.out);
   
10. 
    
11.             String line = null;
    
12.              while((line = bufr.readLine()) != null){
    
13.                    if("over" .equals(line))
    
14.                          break;
    
15.                   out.println(line.toUpperCase());
    
16.                   out.flush();
    
17.             }
    
18. 
    
19.             out.close();
    
20.             bufr.close();
    
21.       }
    
22. }
    

复制代码

    运行结果：

    示例3：  

1. import java.io.BufferedReader;
   
2. import java.io.FileWriter;
   
3. import java.io.InputStreamReader;
   
4. import java.io.PrintWriter;
   
5. import java.io.IOException;
   
6. 
   
7. //写入到out.txt文件中
   
8. public class PrintWriterDemo{
   
9.        public static void main(String[] args) throws IOException {
   
10.             BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    
11.              //PrintWriter构造函数的第二个参数设置为true，表示自动刷新
    
12.             PrintWriter out = new PrintWriter(new FileWriter("out.txt" ),true);
    
13. 
    
14.             String line = null;
    
15.              while((line = bufr.readLine()) != null){
    
16.                    if("over" .equals(line))
    
17.                          break;
    
18.                   out.println(line.toUpperCase());
    
19.             }
    
20. 
    
21.             out.close();
    
22.             bufr.close();
    
23.       }
    
24. }
    

复制代码

    运行结果：

    序列流
    SequenceInputStream：对多个流进行合并。

    需求：将1.txt、2.txt、3、txt文件中的数据合并到一个文件中。

    代码：

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

复制代码

   运行结果：

    使用ArrayList比Vector效率更高。

    改进后代码：

1. import java.io.FileInputStream;
   
2. import java.io.FileOutputStream;
   
3. import java.io.SequenceInputStream;
   
4. import java.util.ArrayList;
   
5. import java.util.Collections;
   
6. import java.util.Enumeration;
   
7. import java.util.Iterator;
   
8. 
   
9. public class SequenceInputStreamDemo{
   
10.        public static void main(String[] args) throws Exception {
    
11. 
    
12.             ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
    
13.              for(int x = 1; x <= 3; x++){
    
14.                   al.add( new FileInputStream(x + ".txt" ));
    
15.             }
    
16.             
    
17.              final Iterator<FileInputStream> it = al.iterator();
    
18.             
    
19.             Enumeration<FileInputStream> en = Collections.enumeration(al);
    
20. 
    
21.              /*
    
22.             //Collections工具类的enumeration方法核心代码：
    
23.             Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){
    
24.                   public boolean hasMoreElements(){
    
25.                         return it.hasMoreElements();
    
26.                   }
    
27. 
    
28.                   public FileInputStream nextElement(){
    
29.                         return it.next();
    
30.                   }
    
31.             };*/
    
32. 
    
33.             SequenceInputStream sis = new SequenceInputStream(en);
    
34. 
    
35.             FileOutputStream fos = new FileOutputStream("4.txt" );
    
36. 
    
37.              byte[] buf = new byte[1024];
    
38.             
    
39.              int len = 0;
    
40. 
    
41.              while((len = sis.read(buf)) != -1){
    
42.                   fos.write(buf,0,len);   
    
43.             }
    
44. 
    
45.             fos.close();
    
46.             sis.close();
    
47.       }
    
48. }
    

复制代码

~END~

阳哥笔记好全面啊.必须转走

更新速度挺快的，赞一个

阳哥，神速，根本停不下啦

阳哥，很好！很强大！

阳哥真的好厉害哈，继续加油了哈

赞！赞！赞！赞！赞！赞！

学习ing学习ing

阳哥，神速，根本停不下啦

赞一个。。。

正在学IO，刚好来看看

更新速度挺快的，赞一个

分享快乐 赞一个

阳哥笔记超赞哦 ！！

又来顶帖子了！赞一个!！！！！！！！！！！！！！！！！！！！！！！！！！

不错   顶！！！！！！！！！！！！！！！！！！！！！！！！！！！

不错呀！真心不过呀！

不错 、顶！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

我能和阳哥交个朋友吗？

最近正在学，好赞。。