Java学习者论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

手机号码,快捷登录

恭喜Java学习者论坛(https://www.javaxxz.com)已经为数万Java学习者服务超过8年了!积累会员资料超过10000G+
成为本站VIP会员,下载本站10000G+会员资源,购买链接:点击进入购买VIP会员
JAVA高级面试进阶视频教程Java架构师系统进阶VIP课程

分布式高可用全栈开发微服务教程

Go语言视频零基础入门到精通

Java架构师3期(课件+源码)

Java开发全终端实战租房项目视频教程

SpringBoot2.X入门到高级使用教程

大数据培训第六期全套视频教程

深度学习(CNN RNN GAN)算法原理

Java亿级流量电商系统视频教程

互联网架构师视频教程

年薪50万Spark2.0从入门到精通

年薪50万!人工智能学习路线教程

年薪50万!大数据从入门到精通学习路线年薪50万!机器学习入门到精通视频教程
仿小米商城类app和小程序视频教程深度学习数据分析基础到实战最新黑马javaEE2.1就业课程从 0到JVM实战高手教程 MySQL入门到精通教程
查看: 291|回复: 0

[JavaIO学习]遍历打印目录结构

[复制链接]
  • TA的每日心情
    开心
    2021-3-12 23:18
  • 签到天数: 2 天

    [LV.1]初来乍到

    发表于 2014-10-29 23:57:35 | 显示全部楼层 |阅读模式
    给定一个目录,打印出该目录包含的目录或者文件的结构来,文件和其父目录之间通过缩进来表示父子关系。
    比如:
       
        0 Test$
       
       
        --1 src$
       
       
        ----2 TravelDir.java
       
       
        ----2 pms$
        0 Test$ --1 src$ ----2 TravelDir.java ----2 pms$ --1 bin$ 表示Test目录下有两个目录:src和bin,src目录里有一个文件TravelDir.java和一个目录pms。(目录名字后面带$,文件不带)  
      
       
       
         
       

         
       
      


    其实遍历打印目录结构,就是对目录这个”树结构“进行遍历,按照上述结构的话,应该是采用深度优先遍历。
    为了完成对特定文件名字的筛选,首先定义一个文件名字过滤接口:(策略模式?O(∩_∩)O)
      FileNameFilter  
      
       
      
    1. [/code]
    2.    
    3.    
    4.     1
    5.     interface
    6.      FileNameFilter{
    7.     2
    8.      
    9.     boolean
    10.      accept(String filename);
    11.     3
    12.     }
    13.      
    14.    
    15.   
    16. 1)采用递归实现
    17.   [img]http://www.java3z.com/cwbwebhome/article/article2/http://www.java3z.com/cwbwebhome/article/article2/http://www.java3z.com/cwbwebhome/article/article2/【JAVA】遍历打印目录结构[/img]
    18.   代码
    19.    
    20.    
    21.      
    22.      1
    23.     /*
    24.    
    25.      2
    26.          * 参数:root:要遍历的文件,
    27.      3
    28.              *spanToLeft:距离左边的空白或者分隔符数目,
    29.      4
    30.              *spanChar:空白字符,
    31.      5
    32.              *filter:根据条件选择文件
    33.      6
    34.          *
    35.      7
    36.          
    37.     */
    38.    
    39.      8
    40.         
    41.     private
    42.      
    43.     void
    44.      travel(File root,
    45.     int
    46.      spanToLeft,
    47.     char
    48.      spanChar,
    49.      9
    50.                 FileNameFilter filter) {
    51.     10
    52.             spanToLeft
    53.     +=
    54.      
    55.     4
    56.     ;
    57.     11
    58.             
    59.     if
    60.      (root.isFile()) {
    61.     12
    62.                 String name
    63.     =
    64.      root.getName();
    65.     13
    66.                
    67.     if
    68.      (filter.accept(name)) {
    69.     14
    70.                     
    71.     for
    72.      (
    73.     int
    74.      k
    75.     =
    76.      
    77.     0
    78.     ; k
    79.     <
    80.      spanToLeft; k
    81.     ++
    82.     ) {
    83.     15
    84.                         strDir.append(spanChar);
    85.     16
    86.                     }
    87.     17
    88.                     strDir.append(root.getName()
    89.     +
    90.      
    91.     "
    92.    
    93.     "
    94.     );
    95.     18
    96.                     fileCount
    97.     ++
    98.     ;
    99.     19
    100.                 }
    101.     20
    102.             }
    103.     else
    104.      
    105.     if
    106.      (root.isDirectory()) {
    107.     21
    108.                
    109.     for
    110.      (
    111.     int
    112.      k
    113.     =
    114.      
    115.     0
    116.     ; k
    117.     <
    118.      spanToLeft; k
    119.     ++
    120.     ) {
    121.     22
    122.                     strDir.append(spanChar);
    123.     23
    124.                 }
    125.     24
    126.                 strDir.append(root.getName()
    127.     +
    128.      
    129.     "
    130.     $
    131.     "
    132.     );
    133.     25
    134.                 dirCount
    135.     ++
    136.     ;
    137.     26
    138.                 File[] children
    139.     =
    140.      root.listFiles();
    141.     27
    142.                
    143.     if
    144.      (children
    145.     ==
    146.      
    147.     null
    148.     )
    149.     28
    150.                     
    151.     return
    152.     ;
    153.     29
    154.                
    155.     for
    156.      (
    157.     int
    158.      i
    159.     =
    160.      
    161.     0
    162.     ; i
    163.     <
    164.      children.length; i
    165.     ++
    166.     ) {
    167.     30
    168.                     travel(children[i], spanToLeft, spanChar, filter);
    169.     31
    170.                 }
    171.     32
    172.             }
    173.     33
    174.         }
    175.     34
    176.         
    177.     35
    178.         
    179.     public
    180.      
    181.     void
    182.      travelDir(File root,
    183.     int
    184.      spanToLeft,
    185.     char
    186.      spanChar,
    187.     36
    188.                 FileNameFilter filter){
    189.     37
    190.             
    191.     if
    192.      (root
    193.     ==
    194.      
    195.     null
    196.     )
    197.     38
    198.                
    199.     return
    200.     ;
    201.     39
    202.             
    203.     if
    204.      (
    205.     !
    206.     root.exists()) {
    207.     40
    208.                 System.err.println(
    209.     "
    210.     file
    211.     "
    212.      
    213.     +
    214.      root.getName()
    215.     +
    216.      
    217.     "
    218.      does not exist!
    219.     "
    220.     );
    221.     41
    222.                
    223.     return
    224.     ;
    225.     42
    226.             }
    227.     43
    228.             travel(root, spanToLeft, spanChar, filter);
    229.     44
    230.             
    231.    
    232.    
    233.   
    234. 45     }  
    235. 2)采用非递归实现(用堆栈)
    236.   为了保存每个文件的层次信息,定义一个类,保存文件名和层次信息
    237.   
    238.   [img]http://www.java3z.com/cwbwebhome/article/article2/http://www.java3z.com/cwbwebhome/article/article2/http://www.java3z.com/cwbwebhome/article/article2/【JAVA】遍历打印目录结构[/img]
    239.   FileDesc  
    240.    
    241.    
    242.      
    243.     1
    244.     class
    245.      FileDesc {
    246.     2
    247.         
    248.     public
    249.      String filename;
    250.     3
    251.         
    252.     public
    253.      
    254.     int
    255.      fileindex;
    256.     4
    257.    
    258.     5
    259.         
    260.     public
    261.      FileDesc(String name,
    262.     int
    263.      index) {
    264.     6
    265.             filename
    266.     =
    267.      name;
    268.     7
    269.             fileindex
    270.     =
    271.      index;
    272.     8
    273.         }
    274.    
    275.    
    276.   
    277. 9 }  
    278. 非递归代码:
    279.   [img]http://www.java3z.com/cwbwebhome/article/article2/http://www.java3z.com/cwbwebhome/article/article2/http://www.java3z.com/cwbwebhome/article/article2/【JAVA】遍历打印目录结构[/img]
    280.   非递归代码
    281.    
    282.    
    283.      
    284.      1
    285.     public
    286.      ArrayList
    287.     <
    288.     FileDesc
    289.     >
    290.      travelWithStack(File root, FileNameFilter filter) {
    291.      2
    292.             ArrayList
    293.     <
    294.     FileDesc
    295.     >
    296.      res
    297.     =
    298.      
    299.     new
    300.      ArrayList
    301.     <
    302.     FileDesc
    303.     >
    304.     ();
    305.      3
    306.             
    307.     if
    308.      (root
    309.     ==
    310.      
    311.     null
    312.     )
    313.      4
    314.                
    315.     return
    316.      res;
    317.      5
    318.             Stack
    319.     <
    320.     File
    321.     >
    322.      stack
    323.     =
    324.      
    325.     new
    326.      Stack
    327.     <
    328.     File
    329.     >
    330.     ();
    331.      6
    332.             Stack
    333.     <
    334.     Integer
    335.     >
    336.      stack1
    337.     =
    338.      
    339.     new
    340.      Stack
    341.     <
    342.     Integer
    343.     >
    344.     ();
    345.      7
    346.             stack.push(root);
    347.      8
    348.             stack1.add(
    349.     0
    350.     );
    351.      9
    352.             
    353.     while
    354.      (
    355.     !
    356.     stack.empty()) {
    357.     10
    358.                 File file
    359.     =
    360.      stack.pop();
    361.     11
    362.                
    363.     int
    364.      iii
    365.     =
    366.      stack1.pop();
    367.     12
    368.                
    369.     if
    370.      (file.isDirectory()) {
    371.     13
    372.                     FileDesc desc
    373.     =
    374.      
    375.     new
    376.      FileDesc(file.getName()
    377.     +
    378.      
    379.     "
    380.     $
    381.     "
    382.     , iii);
    383.     14
    384.                     res.add(desc);
    385.     15
    386.                     dirCount
    387.     ++
    388.     ;
    389.     16
    390.                     File[] children
    391.     =
    392.      file.listFiles();
    393.     17
    394.                     
    395.     if
    396.      (children
    397.     ==
    398.      
    399.     null
    400.     )
    401.     18
    402.                         
    403.     continue
    404.     ;
    405.     19
    406.                     
    407.     for
    408.      (
    409.     int
    410.      i
    411.     =
    412.      
    413.     0
    414.     ; i
    415.     <
    416.      children.length; i
    417.     ++
    418.     ) {
    419.     20
    420.                         stack.push(children[i]);
    421.     21
    422.                         stack1.push(iii
    423.     +
    424.      
    425.     1
    426.     );
    427.     22
    428.                     }
    429.     23
    430.                 }
    431.     else
    432.      
    433.     if
    434.      (file.isFile()) {
    435.     24
    436.                     String filename
    437.     =
    438.      file.getName();
    439.     25
    440.                     
    441.     if
    442.      (filter.accept(filename)) {
    443.     26
    444.                         FileDesc desc
    445.     =
    446.      
    447.     new
    448.      FileDesc(filename, iii);
    449.     27
    450.                         res.add(desc);
    451.     28
    452.                         fileCount
    453.     ++
    454.     ;
    455.     29
    456.                     }
    457.     30
    458.                 }
    459.     31
    460.             }
    461.     32
    462.             
    463.     return
    464.      res;
    465.    
    466.    
    467.   
    468. 33     }  
    469. 当初学数据结构的时候,学到树遍历那一章,感觉用递归实现遍历,无论是深度优先还是广度优先(注:转成非递归,深度优先用堆栈,广度优先用队列),代码都比较简单而且容易理解。那时候听说非递归实现很难实现,因此连敢看都没敢看,其实那本书也提供了伪代码。但当时感觉还是不怎么明白,也没怎么仔细看。所以一直以来觉得递归转非递归很难,而且也没怎么实际写过代码。前段时间去参加一个单位的笔试题,里面就有一道题要求用非递归实现二叉树的先序遍历,呵呵,说实话,以前还真没怎么写过,都是用递归。于是在考场时试着写了一下,没想到仔细理了一下思路,很快就写出来了,其实没想象中那么难。最近也在研究了一下算法,感觉还是很有意思的,以前总觉得算法很深奥,其实现在想想,没那么高深,关键不能只是在想,要亲自去试试。
    470.   ps:也许很多事情没我们想象的那么复杂,亲自去尝试一下,你不去尝试怎么知道自己不行呢。。。
    471.   
    472.   
    473.   
    474. 其实写这个程序主要有一个目的,就是想统计一下我电脑里的音乐文件夹下面的音乐文件。
    475.   
    476.   
    477.    以下是我用程序输出的结果(直接输出到文件里):
    478.    
    479.   
    480.    [url=http://files.cnblogs.com/gaojing/travelDir-output.rar]点击下载[/url]
    481.    
    482.   
    483.   
    484.   
    485.   
    486.   
    487.    
    488.    
    489.      
    490.    
    491.      
    492.    
    493.   
    494. [code]
    复制代码
    回复

    使用道具 举报

    您需要登录后才可以回帖 登录 | 立即注册

    本版积分规则

    QQ|手机版|Java学习者论坛 ( 声明:本站资料整理自互联网,用于Java学习者交流学习使用,对资料版权不负任何法律责任,若有侵权请及时联系客服屏蔽删除 )

    GMT+8, 2024-5-19 09:32 , Processed in 0.416652 second(s), 46 queries .

    Powered by Discuz! X3.4

    © 2001-2017 Comsenz Inc.

    快速回复 返回顶部 返回列表