黑马程序员技术交流社区

标题: 【阳哥笔记】极速秒杀Java基础之笔记系列—Day23（ IO ）！ [打印本页]
作者: 阳哥忠粉    时间: 2015-6-7 20:16
标题: 【阳哥笔记】极速秒杀Java基础之笔记系列—Day23（ IO ）！


笔记总链接：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;

  4. public class FileListDemo{
  5.        public static void main(String[] args){
  6.             listDemo();
  7.       }

  9.        public static void listDemo(){
  10.             File dir = new File("c:\\" );

  12.             File[] files = dir.listFiles( new FilterByHidden());

  14.              for(File file : files){
  15.                   System.out.println(file);
  16.             }
  17.       }
  18. }

  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;

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

  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();

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

  23.        private static String getSpace( int level){
  24.             StringBuilder sb = new StringBuilder();

  26.             sb.append( "|--" );
  27.              for (int x = 0; x < level; x++){
  28.                   sb.append( "| " );
  29.             }

  31.              return sb.toString();
  32.       }
  33. }
复制代码
    运行结果：

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

    代码：
  1. public class DiGuiDemo{
  2.        public static void main(String[] args){
  3.             toBin(6);
  4.       }

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

  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;

  3. public class RemoveDirTest{
  4.        public static void main(String[] args){
  5.             File dir = new File("d:\\demo" );
  6.             removeDir(dir);
  7.       }

  9.        public static void removeDir(File dir){
  10.             File[] files = dir.listFiles();

  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;

  4. public class PropertiesDemo{
  5.        public static void main(String[] args){
  6.             propertiesDemo();
  7.       }

  9.        public static void propertiesDemo(){
  10.              //创建一个Properties集合
  11.             Properties prop = new Properties();

  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" );

  22.              //取出所有元素
  23.             Set<String> names = prop.stringPropertyNames();

  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;

  3. public class PropertiesDemo{
  4.        public static void main(String[] args){
  5.             propertiesDemo();
  6.       }

  8.        public static void propertiesDemo(){
  9.             Properties prop = new Properties();

  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;

  4. public class PropertiesDemo{
  5.        public static void main(String[] args) throws Exception  {
  6.             propertiesDemo();
  7.       }

  9.        public static void propertiesDemo() throws Exception {
  10.             Properties prop = new Properties();

  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" );

  21.              //将集合中数据存储到文件中
  22.             prop.store(fos, "name+age");

  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;

  9. public class PropertiesDemo{
  10.        public static void main(String[] args) throws Exception {
  11.             propertiesDemo();
  12.       }

  14.        public static void propertiesDemo() throws Exception {
  15.             Properties prop = new Properties();

  17.              //集合中的数据来自于一个文件。
  18.              //注意：必须要保证该文件中的数据是键值对。
  19.              //需要使用到读取流
  20.             FileInputStream fis = new FileInputStream("info.txt" );

  22.              //使用load方法
  23.             prop.load(fis);
  24.             prop.list(System.out);

  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" );

  41.              //创建集合存储配置信息
  42.             Properties prop = new Properties();

  44.              //将流中信息存储到集合中
  45.             prop.load(fr);

  47.             prop.setProperty( "wangwu","26" );

  49.             FileWriter fw = new FileWriter(file);

  51.             prop.store(fw, "");

  53.             fr.close();
  54.       }

  56.        //模拟一下load方法
  57.        public static void myLoad() throws Exception {
  58.             Properties prop = new Properties();

  60.             BufferedReader bufr = new BufferedReader(new FileReader("info.txt" ));
  61.       
  62.             String line = null;

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

  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;

  7. public class PropertiesTest{
  8.        public static void main(String[] args) throws IOException{
  9.             getAppCount();
  10.       }

  12.        public static void getAppCount() throws IOException {
  13.              //将配置文件封装成File对象
  14.             File confile = new File("count.properties" );

  16.              if(!confile.exists()){
  17.                   confile.createNewFile();
  18.             }

  20.             FileInputStream fis = new FileInputStream(confile);
  21.       
  22.             Properties prop = new Properties();

  24.             prop.load(fis);

  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++;

  39.              //将改变后的次数重新存储到集合中。
  40.             prop.setProperty( "time",count + "" );

  42.             FileOutputStream fos = new FileOutputStream(confile);

  44.             prop.store(fos, "");

  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;

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

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

  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;

  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

  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;

  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);

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

  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;

  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);

  14.             String line = null;
  15.              while((line = bufr.readLine()) != null){
  16.                    if("over" .equals(line))
  17.                          break;
  18.                   out.println(line.toUpperCase());
  19.             }

  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;

  7. public class SequenceInputStreamDemo{
  8.        public static void main(String[] args) throws Exception {
  9.             Vector<FileInputStream> v = new Vector<FileInputStream>();

  11.             v.add( new FileInputStream("1.txt" ));
  12.             v.add( new FileInputStream("2.txt" ));
  13.             v.add( new FileInputStream("3.txt" ));      

  15.             Enumeration<FileInputStream> en = v.elements();

  17.             SequenceInputStream sis = new SequenceInputStream(en);

  19.             FileOutputStream fos = new FileOutputStream("4.txt" );

  21.              byte[] buf = new byte[1024];
  22.             
  23.              int len = 0;

  25.              while((len = sis.read(buf)) != -1){
  26.                   fos.write(buf,0,len);   
  27.             }

  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;

  9. public class SequenceInputStreamDemo{
  10.        public static void main(String[] args) throws Exception {

  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);

  21.              /*
  22.             //Collections工具类的enumeration方法核心代码：
  23.             Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){
  24.                   public boolean hasMoreElements(){
  25.                         return it.hasMoreElements();
  26.                   }

  28.                   public FileInputStream nextElement(){
  29.                         return it.next();
  30.                   }
  31.             };*/

  33.             SequenceInputStream sis = new SequenceInputStream(en);

  35.             FileOutputStream fos = new FileOutputStream("4.txt" );

  37.              byte[] buf = new byte[1024];
  38.             
  39.              int len = 0;

  41.              while((len = sis.read(buf)) != -1){
  42.                   fos.write(buf,0,len);   
  43.             }

  45.             fos.close();
  46.             sis.close();
  47.       }
  48. }
复制代码

~END~




作者: 人在旅途~东营    时间: 2015-6-7 22:03
阳哥笔记好全面啊.必须转走
作者: 探索者    时间: 2015-6-7 22:52
更新速度挺快的，赞一个
作者: 灵界    时间: 2015-6-7 23:08
阳哥，神速，根本停不下啦
作者: cyd1058    时间: 2015-6-8 21:19
阳哥，很好！很强大！
作者: 流水0215    时间: 2015-6-9 09:19
阳哥真的好厉害哈，继续加油了哈
作者: 熊乾坤    时间: 2015-6-9 22:16
赞！赞！赞！赞！赞！赞！
作者: New_PS    时间: 2015-6-11 23:04
学习ing学习ing
作者: 魏海洲    时间: 2015-6-15 23:43

阳哥，神速，根本停不下啦
作者: 凌云xs    时间: 2015-6-17 20:41
赞一个。。。
作者: Foundmoon    时间: 2015-6-17 20:53
正在学IO，刚好来看看
作者: 魏海洲    时间: 2015-6-25 18:59
更新速度挺快的，赞一个
作者: Overheat    时间: 2015-7-6 19:03
分享快乐 赞一个
作者: xiongfangyuan    时间: 2015-7-6 22:11
阳哥笔记超赞哦 ！！
作者: 星痕-凌    时间: 2015-7-11 22:52
又来顶帖子了！赞一个!！！！！！！！！！！！！！！！！！！！！！！！！！
作者: 星痕-凌    时间: 2015-7-13 22:21
不错   顶！！！！！！！！！！！！！！！！！！！！！！！！！！！
作者: 无与伦比的禽兽    时间: 2015-7-14 22:24
不错呀！真心不过呀！
作者: 星痕-凌    时间: 2015-7-17 21:25
不错 、顶！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
作者: 老中医    时间: 2015-7-17 22:13
我能和阳哥交个朋友吗？
作者: yangshibai    时间: 2015-9-21 23:25
最近正在学，好赞。。
作者: 宋美涛    时间: 2015-9-21 23:28
不错不错不错不错不错
作者: xuxu5112    时间: 2015-9-21 23:43
正好学到IO 学习下
作者: 1975532882    时间: 2015-10-27 08:59
好。。。。。。。。。。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2