澳门新萄京:22_IO_第22天(File、递归)_讲义
分类:www.澳门新萄京赌场

今天内容介绍
1、File
2、递归

IO(File 递归),iofile递归

File概述
java.io.File类:文件和目录路线名的肤浅意味方式。
用来说述Computer粤语件,文件夹,以及路线类

常用的1个和File有关的单词:
file:文件
directory:文件夹(目录)
path:路径
File是一个与系统无关的类

File类的一个重载的构造方法
路径:
window系统的目录分隔符是三个
java中的目录分隔符是:\或者/
路子的归类:
相对路线:以盘符开首的门路
例如:D:\ase\20170514\day10
D:\Work_EE_266\day10\src
相对路径:周旋于当下项目来讲,路径编写的时候能够简轻便单盘符到花色里面包车型客车门路
D:\Work_EE_266\day10-->src

瞩目:路劲不区分轻重缓急写的
File(File parent, String child)
传递路径,传递 File 类型父路线,字符串类型子路线
收益:父路径是 File 类型,父路径能够平素调用 File 类的法子
File(String parent, String child)
传递路线,传递字符串类型父路线,字符串类型的子路径
收益:单独操作父路线和子路线,使用起来相比灵活,能够把渠道单独作为参数字传送递过来
File(String pathname)
传送路线名:能够写文件夹,也能够写到2个文书
c:\abc c:\abc\Demo.java
路径存不设有都能够创立,路线不区分轻重缓急写

 1 public static void main(String[] args) {
 2         /*
 3          * static String pathSeparator 与系统有关的路径分隔符,为了方便,它被表示为一个字符串。 
 4          * static char pathSeparatorChar  与系统有关的路径分隔符。 
 5          * static String separator  与系统有关的默认名称分隔符,为了方便,它被表示为一个字符串。 
 6          * static char separatorChar  与系统有关的默认名称分隔符。 
 7          */
 8         String pathSeparator = File.pathSeparator;
 9         System.out.println(pathSeparator);//路径分隔符 windows 分号; linux 冒号:
10         
11         String separator = File.separator;
12         System.out.println(separator);//目录名称分隔符windows 反斜杠  linux 正斜杠/
13         
14         /*
15          * System类中的方法
16          * static String getProperty(String key) 获取指定键指示的系统属性。 
17          * file.separator 文件分隔符(在 UNIX 系统中是“/”) 
18          * path.separator 路径分隔符(在 UNIX 系统中是“:”) 
19          * line.separator 行分隔符(在 UNIX 系统中是“/n”) 
20          */
21         System.out.println(System.getProperty("file.separator"));
22         System.out.println(System.getProperty("line.separator"));
23         System.out.println(System.getProperty("path.separator"));
24     }

File类的创制和删除作用
File 类的删减功能
boolean delete()
除去文件或许文件夹,在 File 构造方法中提交
去除成功重返 true,删除战败重临 false(不存在,文件夹中有内容)
删除方法不走回收站,直接从硬盘删除
除去有高危害,运营需谨慎

File 创立文件夹效用
boolean mkdir() 只可以创制单层文件夹
boolean mkdirs() 既能创建单层文件夹,又能创立多层文件夹
创建的门路也在 File 构造方法中付出
假如文件夹已经存在,不在创造

File 创立文件的效劳
boolean createNewFile()
创立的文本路线和文件名,在 File 构造方法中付出
假诺文件已经存在,不在创造再次回到 false
只可以成立文件,不可能创造文件夹(看类型,不要看后缀)
创造文件夹的门路,必须存在

File类的论断成效
boolean isDirectory()
看清 File 构造方法中封装的渠道是还是不是文件夹
一旦是文件夹就回去 true,若是还是不是文本夹就回去 false
boolean isFile()
判断 File 构造方法中封装的门路是还是不是文件
boolean exists()
推断 File 构造方法中封装路径是或不是留存
留存就重回 true,不设有就再次来到 false

File类的获取成效
String getParent() 返回 String 对象
File getParentFile() 返回 File 对象
收获父路线,重临的是文件末尾的父路径

long length()
回来路线中象征的文本的字节数,文件夹未有轻重

String get帕特h() 将此抽象路线名转变为3个渠道名字符串。
和 toString 一样

String getName()
回去路线中意味着的文书或然文件夹名
收获路线中最终有的的名字

File getAbsoluteFile() 重回此抽象路线名的相对路线名格局。
String getAbsolutePath() 重临此抽象路线名的相对路线名字符串。
获得相对路线

遍历目录的格局list和listFiles
注意事项:
一.被遍历的路径只能是叁个索引
二.被遍历的目录必须存在
再不就能抛空指针非常

static File[] listRoots()
得到系统中享有根目录

File[] listFiles()
获取到 File 构造方法中封装的门径中的文件和文书夹名(遍历多少个索引)
回来的是目录或然文件的全路线

String[] list()
获取到 File 构造方法中封装的路线中的文件和文书夹名(遍历八个索引)
回去的只著名字

递归
递归:方法自个儿调用自身
分类:
递归分为三种,直接递归和间接递归。
直接递归称为方法本人调用本人。直接递归能够A方法调用B方法,B方法调用C方法,C方法调用A方法。

注意:
一.递归自然要有规则限制,保险递归能够甘休下来,否则会发出栈内存溢出。
贰.在递归中纵然有限制规范,可是递归次数不可能太多。不然也会产生栈内部存储器溢出。
叁.构造措施,禁止递归

 1 使用递归计算1-n之间的和
 2       n   (n-1)  (n-2) (n-3) ... 1
 3       5  (5-1) (4-1) (3-1) (2-1)
 4       结束条件:n=1的时候结束
 5       方法自己调用自己目的:获取n-1,获取到n=1的时候结束
 6     public static int DGSum(int n){
 7         //添加结束条件
 8         if(n==1){
 9             return 1;
10         }
11         return n DGSum(n-1);
12     } 
13 
14 使用递归计算阶乘
15      private static long DGJC(int n) {
16         //递归的结束条件 n==1
17         if(n==1){
18             return 1;
19         }
20         return n*DGJC(n-1);
21     }
22 
23 使用递归计算斐波那契数列    
24     private static int fbnq(int month) {
25         //结束条件如果month是1,2直接返回1
26         if(month==1 || month==2){
27             return 1;
28         }
29         //3月以上:兔子数量是前两个月之和
30         return fbnq(month-1) fbnq(month-2);
31     } 

文本过滤器
文件的过滤器:
需求:遍历hello文件夹,只获得文件夹中的.java结尾的文本
c:\hello
c:\hello\demo.txt
c:\hello\Hello.java

在File类中listFiles()方法是遍历文件夹的章程
有三个和 listFiles重载的不二等秘书籍,参数字传送递的便是过滤器
File[] listFiles(FileFilter filter)
File[] listFiles(FilenameFilter filter)
回去抽象路线名数组,这么些门路名代表此抽象路径名表示的目录中级知识分子足钦命过滤器的文件和目录。
发现方法的参数FileFilter和FilenameFilter是接口
装有我们须要本身定义接口的贯彻类,重写接口中的方法accept,达成过滤效果

 1 public class FileFilterImpl implements FileFilter{
 2     /*
 3      * 实现过滤的方法:
 4         1.把传递过来的路径pathname,变成字符串
 5             Stirng s  = pathname.toString(); "c:\hello\demo.txt"
 6             String s  = pathname.getPaht(); "c:\hello\demo.txt"
 7             String s = pathname.getName(); "demo.txt"
 8         2.使用String类中的方法endsWith判断字符串是否以指定的字符串结尾
 9             boolean b = s.endsWith(".java");
10             return b;
11      */
12     @Override
13     public boolean accept(File pathname) {
14         /*String s = pathname.getName();
15         boolean b = s.endsWith(".java");
16         return b;*/
17         return pathname.getName().toLowerCase().endsWith(".java");
18     }
19 }
20 public class FilenameFilterImpl implements FilenameFilter{
21 
22     @Override
23     public boolean accept(File dir, String name) {
24         return name.toUpperCase().endsWith(".JAVA");
25     }
26 
27 }

断点调节和测试
debug断点调节和测试
f6:逐行实行
f5:进入到艺术中
f七:截止方法
f捌:跳到下2个断点
watch:捕获

递归),iofile递归 File概述 java.io.File类:文件和目录路线名的肤浅意味方式。 用来叙述Computer中文件,文件夹,以及路线类 常用的2个和Fil...

File概述
java.io.File类:文件和目录路径名的悬空意味情势。
用来说述计算机汉语件,文件夹,以及路线类

一.A:IO才干概述

第1章 File

澳门新萄京 1

常用的一个和File有关的单词:
file:文件
directory:文件夹(目录)
path:路径
File是三个与系统非亲非故的类

        * a: Output 把内部存款和储蓄器中的数量存款和储蓄到长久化设备上这些动作称为输出(写)Output操作

1.1 IO概述

回顾从前写过的次第,数据都以在内部存储器中,壹旦程序运转截至,那一个数据都尚未了,等下一次再想利用那几个数量,可是已经远非了。那怎么办呢?能或不可能把运算完的多寡都保留下来,后一次先后启动的时候,再把这一个数量读出来继续选拔啊?其实要把多少持久化存款和储蓄,就须要把内部存款和储蓄器中的数目存款和储蓄到内部存款和储蓄器以外的别样悠久化设备(硬盘、光盘、U盘等)上。

当须要把内部存款和储蓄器中的数量存款和储蓄到悠久化设备上那几个动作称为输出Output操作。

当把细水长流设备上的多少读取到内存中的那些动作称为输入Input操作。

故而大家把这种输入和输出动作称为IO操作。

简单领会IO是怎么三次事之后,接下去将在越发做系统摸底。

在我们操作系统中,数据都保留在文件中,而文件存放相应的文件夹中。那么Java中是何许描述这么些的吧?

xmind:下载地址:

File类的一个重载的构造方法
路径:
window系统的目录分隔符是三个
java中的目录分隔符是:\或者/
路径的分类:
绝对路线:以盘符初叶的路子
例如:D:\ase\20170514\day10
D:\Work_EE_266\day10\src
相对路线:绝对于近期项目以来,路线编写的时候能够简单盘符到花色里面包车型客车渠道
D:\Work_EE_266\day10-->src

        * b: Input 把持之以恒设备上的多少读取到内部存款和储蓄器中的那一个动作称为输入(读)Input操作

一.2File类的面世

开垦API,寻觅File类。阅读其讲述:File文件和目录路线名的画饼充饥意味方式。即,Java中把公文大概目录都封装成File对象。也正是说假若我们要去操作硬盘上的文本,可能文件夹只要找到File这一个类就能够。那么大家将在切磋钻探File这一个类中都有那四个功效能够操作文件大概文件夹呢?

链接: 密码:845a

留神:路劲不区分轻重缓急写的
File(File parent, String child)
传送路线,传递 File 类型父路线,字符串类型子路线
利润:父路径是 File 类型,父路径能够直接调用 File 类的法门
File(String parent, String child)
传送路径,传递字符串类型父路线,字符串类型的子路线
利润:单独操作父路线和子路线,使用起来比较灵敏,能够把渠道单独作为参数字传送递过来
File(String pathname)
传递路线名:可以写文件夹,也能够写到三个文件
c:\abc c:\abc\Demo.java
路线存不设有都能够创立,路径不区分轻重缓急写

        * c: IO操作  把地点的这种输入和输出动作称为IO操作

一.三File类的构造函数

l 通过构造方法成立File对象,大家进行出现说法:

public class FileDemo {

publicstaticvoidmain(String[] args) {

//File构造函数演示

StringpathName = "e:\java_code\day22e\hello.java";

Filef1 = newFile;//将Test2贰文件封装成File对象。注意;有能够打包不设有文件恐怕文件夹,产生对象。

System.out.println;

Filef2 = newFile("e:\java_code\day22e","hello.java");

System.out.println;

//将parent封装成file对象。

Filedir = newFile("e:\java_code\day22e");

Filef3 = newFile(dir,"hello.java");

System.out.println;

}

}

0壹IO技能概述

* A:IO技术概述
    * a: Output
        * 把内存中的数据存储到持久化设备上这个动作称为输出(写)Output操作
    * b: Input
        * 把持久设备上的数据读取到内存中的这个动作称为输入(读)Input操作
    * c: IO操作
        * 把上面的这种输入和输出动作称为IO操作
 1 public static void main(String[] args) {
 2         /*
 3          * static String pathSeparator 与系统有关的路径分隔符,为了方便,它被表示为一个字符串。 
 4          * static char pathSeparatorChar  与系统有关的路径分隔符。 
 5          * static String separator  与系统有关的默认名称分隔符,为了方便,它被表示为一个字符串。 
 6          * static char separatorChar  与系统有关的默认名称分隔符。 
 7          */
 8         String pathSeparator = File.pathSeparator;
 9         System.out.println(pathSeparator);//路径分隔符 windows 分号; linux 冒号:
10         
11         String separator = File.separator;
12         System.out.println(separator);//目录名称分隔符windows 反斜杠  linux 正斜杠/
13         
14         /*
15          * System类中的方法
16          * static String getProperty(String key) 获取指定键指示的系统属性。 
17          * file.separator 文件分隔符(在 UNIX 系统中是“/”) 
18          * path.separator 路径分隔符(在 UNIX 系统中是“:”) 
19          * line.separator 行分隔符(在 UNIX 系统中是“/n”) 
20          */
21         System.out.println(System.getProperty("file.separator"));
22         System.out.println(System.getProperty("line.separator"));
23         System.out.println(System.getProperty("path.separator"));
24     }
  1. A:File类静态的成员变量

1.四File类的获得

创设完了File对象之后,那么File类中都有如下常用方法,能够取得文件有关音讯

l 方法言传身教如下:

public class FileMethodDemo {

publicstaticvoidmain(String[] args) {

//创立文件对象

Filefile = newFile("Test22.java");

//获取文件的相对路线,即全路径

StringabsPath = file.getAbsolutePath();

//File中封装的路线是怎样收获到的就是哪些。

Stringpath = file.getPath();

//获取文件名称

Stringfilename = file.getName();

//获取文件大小

longsize = file.length();

System.out.println("absPath=" absPath);

System.out.println("path=" path);

System.out.println("filename=" filename);

System.out.println("size=" size);

}

}

0贰File类的概述和功用

* A:File类的概述和作用
    * a: File的概念
        * File类是文件和目录路径名的抽象表示形式
        * Java中把文件或者目录(文件夹)都封装成File对象
        * 我们要去操作硬盘上的文件,或者文件夹只要找到File这个类即可

File类的成立和删除功用
File 类的删减作用
boolean delete()
剔除文件大概文件夹,在 File 构造方法中提交
删去成功再次来到 true,删除退步重临 false(不存在,文件夹中有内容)
除去方法不走回收站,直接从硬盘删除
剔除有高危害,运转需谨慎

        * a: pathSeparator 与系统有关的门径分隔符,为了有利于,它被代表为三个字符串

一.伍文书和文件夹的创导删除等

不经常上边介绍,我们领会能够经过File获取到文件名称,文件路线等新闻。

接下去演示使用File类创建、删除文件等操作。

l 大家开始展览格局的演示

public class FileMethodDemo2 {

publicstaticvoidmain(String[] args) throws IOException {

// 对文本也许文件加举办操作。

Filefile = newFile("e:\file.txt");

// 成立文件,若是文件不设有,创立 true 假如文件存在,则不创建 false。 假诺路线错误,IOException。

booleanb1 = file.createNewFile();

System.out.println("b1=" b1);

//-----------删除文件操作-------注意:不去回收站。慎用------

boolean b2 = file.delete();

System.out.println;

//-----------必要决断文件是不是存在------------

boolean b3 = file.exists();

System.out.println;

//-----------对目录操作 创设,删除,决断------------

Filedir = newFile("e:\abc");

//mkdir()创造单个目录。//dir.mkdirs();成立多级目录

booleanb4 = dir.mkdir();

System.out.println;

//删除目录时,借使目录中有内容,不能够直接删除。

booleanb5 = dir.delete();

//唯有将引得中的内容都剔除后,保证该目录为空。那时这几个目录才得以去除。

System.out.println("b5=" b5);

//-----------判定文件,目录------------

File f= newFile("e:\javahaha");// 要咬定是还是不是是文件大概目录,必须先判定存在。

// f.mkdir();//f.createNewFile();

System.out.println(f.isFile;

System.out.println(f.isDirectory;

}

}

0三File类静态的成员变量

* A:File类静态的成员变量
    * a: pathSeparator
        * 与系统有关的路径分隔符,为了方便,它被表示为一个字符串
    * b: separator
        * 与系统有关的默认名称分隔符,为了方便,它被表示为一个字符串

    * c: 案例代码

        /*
         *  java.io.File
         *    将操作系统中的,文件,目录(文件夹),路径,封装成File对象
         *    提供方法,操作系统中的内容
         *    File与系统无关的类
         *    文件 file
         *    目录 directory
         *    路径 path
         */
        public class FileDemo {
            public static void main(String[] args) {
                //File类静态成员变量
                //与系统有关的路径分隔符
                String separator = File.pathSeparator;
                System.out.println(separator);// 是一个分号,目录的分割
                (window中环境变量配置各个路径用分号分割,表示一个完整的路径结束)  Linux中是冒号 :

                //与系统有关的默认名称分隔符
                separator = File.separator;
                System.out.println(separator);// 向右   目录名称分割  Linux / 
            }
        }

File 创制文件夹效能
boolean mkdir() 只可以创建单层文件夹
boolean mkdirs() 既能成立单层文件夹,又能创立多层文件夹
制造的门路也在 File 构造方法中付出
设若文件夹已经存在,不在成立

        * b: separator*与系统有关的默许名称分隔符,为了方便,它被代表为多个字符串

一.陆listFiles()方法介绍

澳门新萄京:22_IO_第22天(File、递归)_讲义。文件都存放在目录中,那么如何赢得二个索引中的全数文件或然目录中的文件夹呢?那么我们先研究,1个索引中大概有四个文件只怕文件夹,那么壹旦File中有机能获得到一个索引中的全体文件和文件夹,那么功能博得的结果恐怕是数组,要么是汇集。大家开首查看API。

l 方法言传身教如下:

public class FileMethodDemo3 {

publicstaticvoidmain(String[] args) {

Filedir = 澳门新萄京:22_IO_第22天(File、递归)_讲义。newFile("e:\java_code");

//获取的是目录下的脚下的文本以及文件夹的称谓。

String[]names = dir.list();

for(Stringname : names){

System.out.println;

}

//获取目录下当前文件以及文件对象,只要得到了文件对象,那么就足以博得个中想要的音信

File[]files = dir.listFiles();

for(Filefile : files){

System.out.println;

}

}

}

专注:在获得钦赐目录下的公文或许文件夹时必须满足上面多个尺码

一,钦定的目录必须是存在的,

贰,钦赐的总得是目录。不然轻松引发再次回到数组为null,出现NullPointerException

04File类构造方法_1

* A: File类构造方法_1
    * a: File(String pathname)
        * 通过将给定路径名字符串转换为一个File对象,之后可以使用File中的方法
        * windows中的路径或文件名不区分大小写
    * d: 案例代码
        public class FileDemo1 {
            public static void main(String[] args) {
                function();
            }
            /*
             *  File(String pathname)
             *  传递路径名: 可以写到文件夹,可以写到一个文件
             *  c:\abc   c:\abc\Demo.java
             *  将路径封装File类型对象
             */
            public static void function(){
                File file = new File("d:\eclipse");
                System.out.println(file);
            }
        }

File 创设文件的成效
boolean createNewFile()
开创的文件路线和文件名,在 File 构造方法中付出
借使文件已经存在,不在创制重回 false
只可以创设文件,不可能成立文件夹(看类型,不要看后缀)
成立文件夹的路径,必须存在

3.* A: 相对路线和绝对路径

1.七文件过滤器

经过listFiles()方法,我们得以获取到三个目录下的全部文件和文书夹,但能否对其展开过滤呢?譬喻大家只想要2个目录下的内定扩张名的文书,或然隐含某个首要字的文本夹呢?

我们是能够先把1个索引下的兼具文件和文书夹到手到,并遍历当前获得到具备内容,遍历进程中在拓展筛选,不过那些动作有一点点麻烦,Java给大家提供相应的功用来消除这一个主题素材。

查阅File类的API,在查看时意识File类中重载的listFiles方法,并且接受钦点的过滤器。

l 测试类

public class FileDemo2 {

publicstaticvoidmain(String[] args) {

//获取扩大名字为.java全数文件

//创建File对象

Filefile = newFile("E:\code\day11_code");

//获取钦命扩大名的文本,由于要对富有文件进行扩大名筛选,由此调用方法必要传递过滤器

File[]files = file.listFiles(new MyFileFilter;

//遍历获取到的持有符合条件的文件

for(File f : files) {

System.out.println;

}

}

}

l 自定类承接FilenameFilter过滤器接口

//定义类落成文件名称FilenameFilter过滤器

class MyFileFilter implementsFilenameFilter{

publicbooleanaccept(File dir, String name) {

returnname.endsWith;

}

}

在翻看API时,大家开掘,在listFiles(FileFilterfilter) 也得以接受八个FileFilter过滤器,它和我们讲的FilenameFilter有甚分裂吧?

FilenameFilter过滤器中的accept方法接受三个参数,七个脚下文件或文件夹所在的门径,1个是眼下文件或文件夹对象的称谓。

FileFilter 过滤器中的accept方法接受3个参数,这些参数就现阶段文件或文件夹对象

当大家须要过滤文件名称时就足以选择FilenameFilter这么些过滤器,当大家想对当前文件或文件夹举办过滤,就足以行使FileFilter ,比方需求当前目录下的装有文件夹,就足以选取FileFilter 过滤器。

l 测试类

public class FileDemo2 {

publicstaticvoidmain(String[] args) {

//获取扩大名字为.java所有文件

//创建File对象

Filefile = newFile("E:\code\day11_code");

//获取钦赐目录下的文书夹

File[]files = file.listFiles(new FileFileterByDir;

//遍历获取到的持有符合条件的公文

for(File f : files) {

System.out.println;

}

}

}

l 自定义类承继FileFilter过滤器接口

//文件过滤器

class FileFileterByDir implementsFileFilter{

publicbooleanaccept(File pathname) {

returnpathname.isDirectory();

}

}

05相对路线和相对路线

* A: 相对路径和绝对路径
    * a: 绝对路径
        * 绝对路径是一个固定的路径,从盘符开始
    * b: 相对路径
        * 相对路径相对于某个位置,在eclipse下是指当前项目下  
    * c: 路径
            绝对路径
                在系统中具有唯一性
                c:\windows\system32
            相对路径
                表示路径之间的关系
                D:\develop\Java\jdk1.7.0_72\bin
                D:\develop\Java\jre7
                路径之间关系
                    Java 父目录是D:\develop
                    Java 子目录是:jdk1.7.0_72
                父路径是 唯一性
                子目录是可以多个

File类的论断效用
boolean isDirectory()
判定 File 构造方法中封装的路线是或不是文本夹
如若是文本夹就回来 true,要是或不是文件夹就回来 false
boolean isFile()
看清 File 构造方法中封装的不贰秘技是否文本
boolean exists()
判别 File 构造方法中封装路线是还是不是存在
存在就回到 true,不设有就重回 false

        * a: 相对路径 相对路线是叁个永世的渠道,从盘符开端

第2章递归

0陆File类的构造方法_2

* A: File类的构造方法_2
    * a:File(String parent, String child) 
        * 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 对象

    * b: File(File parent, String child)

    * c: 案例代码
    public class FileDemo1 {
        public static void main(String[] args) {
            function_2();
        }
        /*
         *  File(File parent,String child)
         *  传递路径,传递File类型父路径,字符串子路径
         *  好处: 父路径是File类型,父路径可以直接调用File类方法
         */
        public static void function_2(){
            File parent = new File("d:");
            File file = new File(parent,"eclipse");
            System.out.println(file);
        }

        /*
         *  File(String parent,String child)
         *  传递路径,传递字符串父路径,字符串子路径
         *  好处: 单独操作父路径和子路径
         */
        public static void function_1(){
            File file = new File("d:","eclipse");
            System.out.println(file);
        }
    }

File类的拿走功效
String getParent() 返回 String 对象
File getParentFile() 返回 File 对象
获得父路径,重临的是文件末尾的父路线

        * b: 相对路线 相对路线绝对于有个别地方,在eclipse下是指当前项目下   

二.一递归的概述

递归,指在此时此刻艺术内调用本人的这种场所

public void method(){

System.out.println;

//在眼下形式内调用自身

method();

}

递归分为二种,直接递归和直接递归。

直接递归称为方法本人调用本人。间接递归能够A方法调用B方法,B方法调用C方法,C方法调用A方法。

l 递归的代码演示,总括1-n里面包车型地铁和,使用递归实现

public class DiGuiDemo {

publicstaticvoidmain(String[] args) {

//计算1~num的和,使用递归完毕

intn = 5;

intsum = getSum;

System.out.println;

}

publicstaticintgetSum(intn) {

if{

return1;

}

returnn getSum;

}

}

l 代码推行流程图解

留意:递归一定要有规范限制,保险递归能够结束下来,不然会生出栈内部存款和储蓄器溢出。

在递归中即使有限量条件,可是递归次数无法太多。不然也会生出栈内部存款和储蓄器溢出。

0柒File类制造文件效用

* A: File类创建文件功能
    * a: public boolean createNewFile()
        * 创建文件 如果存在这样的文件,就不创建了

    * b: 案例代码
        public class FileDemo2 {
            public static void main(String[] args)throws IOException {
                function();
            }                       
            /*
             *  File创建文件的功能
             *  boolean createNewFile()
             *  创建的文件路径和文件名,在File构造方法中给出
             *  文件已经存在了,不在创建
             */
            public static void function()throws IOException{
                File file = new File("c:\a.txt");
                boolean b = file.createNewFile();
                System.out.println(b);
            }
        }

long length()
回来路线中象征的文书的字节数,文件夹没有大小

        * c: 路径

二.贰递归打字与印刷全数子目录中的文件路线

编写制定贰个艺术用来打字与印刷内定目录中的文件路线,并拓展格局的调用

务求:若钦赐的目录有子目录,那么把子目录中的文件路线也打字与印刷出来

步骤:

  1. 钦命要打字与印刷的目录File对象

  2. 调用getFileAll()方法

2.1 获取钦点目录中的全数File对象

2.2 遍历得到每二个File对象

2.三 判定当前File 对象是或不是是目录

看清结果为true,表达为目录,通过递归,再度调用步骤二的getFileAll()方法

看清结果为false,表达是文本,打字与印刷文件的门路

l 代码演示

public class FileDemo2 {

publicstaticvoidmain(String[] args) {

Filefile = newFile("d:\test");

getFileAll;

}

//获取钦定目录以及子目录中的全数的文件

publicstaticvoidgetFileAll(File file) {

File[]files = file.listFiles();

//遍历当前目录下的全数文件和文书夹

for(File f : files) {

//剖断当前遍历到的是不是为目录

if(f.isDirectory{

//是目录,继续获得这几个目录下的有着文件和文书夹

getFileAll;

}else{

//不是目录,表明当前f正是文件,那么就打字与印刷出来

System.out.println;

}

}

}

}

0捌File类创制目录功用

* A: File类创建目录功能
    * a: 创建目录
        * public boolean mkdir():创建文件夹 如果存在这样的文件夹,就不创建了
        * public boolean mkdirs():创建文件夹,如果父文件夹不存在,会帮你创建出来
    * b: 案例代码
        public class FileDemo2 {
            public static void main(String[] args)throws IOException {
                function_1();
            }
            /*
             *  File创建文件夹功能
             *  boolean mkdirs() 创建多层文件夹
             *  创建的路径也在File构造方法中给出
             *  文件夹已经存在了,不在创建
             */
            public static void function_1(){
                File file = new File("c:\abc");
                boolean b = file.mkdirs();
                System.out.println(b);
            }               
        }

String getPath() 将此抽象路线名转变为3个门路名字符串。
和 toString 一样

                相对路线

二.三追寻钦定目录中的.java文件

须要:打字与印刷钦点目录即全部子目录中的.java文件的文书路线

渴求:编写3个艺术用来打字与印刷钦点目录中的.java文件路径,并开始展览格局的调用

若钦命的目录有子目录,那么把子目录中的.java文件路线也打字与印刷出来

步骤:

  1. 钦命要打字与印刷的目录File对象

  2. 调用getFileAll()方法,传入要打字与印刷的目录File对象

二.一 通过FilenameFilter过滤器获取钦点目录中的全体.java类型的File对象

2.贰 遍历获得每叁个File对象

二.3 决断当前File 对象是还是不是是目录

判定结果为true,表明为目录,通过递归,再一次调用步骤2的getFileAll()方法

决断结果为false,表达是文件,打字与印刷文件的路线

0九File类删除功用

* A: File类删除功能
    * a: 删除功能
        * public boolean delete():删除文件或者文件夹
* B: 案例代码
    public class FileDemo2 {
        public static void main(String[] args)throws IOException {
            function_2();
        }
        /*
         *  File类的删除功能
         *  boolean delete()
         *  删除的文件或者是文件夹,在File构造方法中给出
         *  删除成功返回true,删除失败返回false
         *  删除方法,不走回收站,直接从硬盘中删除
         *  删除有风险,运行需谨慎
         */
        public static void function_2(){
            File file = new File("c:\a.txt");
            boolean b = file.delete();
            System.out.println(b);
        }           
    }

String getName()
重回路径中表示的文书或许文件夹名
收获路线中最后有的的名字

                    在系统中颇具唯一性

二.四兑今世码步骤

l 测试类

public class FileDemo4 {

publicstaticvoidmain(String[] args) {

Filefile = newFile("d:\test");

getFileAll;

}

//获取内定目录以及子目录中的全部的公文

publicstaticvoidgetFileAll(File file) {

File[]files = file.listFiles(MyFileFilter;

//遍历当前目录下的装有文件和文件夹

for(File f : files) {

//推断当前遍历到的是或不是为目录

if(f.isDirectory{

//是目录,继续猎取那一个目录下的享有文件和文件夹

getFileAll;

}else{

//不是目录,表明当前f就是文本,那么就打印出来

System.out.println;

}

}

}

}

l 自定类承接FilenameFilter过滤器接口

//定义类完结文件名称FilenameFilter过滤器

class MyFileFilter implementsFilenameFilter{

publicbooleanaccept(File dir, String name) {

returnname.endsWith;

}

}

10File类得到功用

* A:File类获取功能
    * a: 方法介绍
        * String getName(): 返回路径中表示的文件或者文件夹名
            * 获取路径中的最后部分的名字
        * long length(): 返回路径中表示的文件的字节数
        * String getAbsolutePath(): 获取绝对路径,返回String对象
        * File   getAbsoluteFile() : 获取绝对路径,返回File对象
            * eclipse环境中,写一个相对路径,绝对位置工程根目录
        * String getParent(): 获取父路径,返回String对象
        * File getParentFile(): 获取父路径,返回File对象

    * b: 案例代码

        public class FileDemo3 {
            public static void main(String[] args) {
                function_3();
            }
            /*
             * File类的获取功能
             * String getParent() 返回String对象
             * File getParentFile()返回File对象
             * 获取父路径
             */
            public static void function_3(){
                File file = new File("d:\eclipse\eclipse.exe");
                File parent = file.getParentFile();
                System.out.println(parent);
            }

            /*
             * File类获取功能
             * String getAbsolutePath() 返回String对象
             * File   getAbsoluteFile() 返回File对象
             * 获取绝对路径
             * eclipse环境中,写的是一个相对路径,绝对位置工程根目录
             */
            public static void function_2(){
                File file = new File("src");
                File absolute = file.getAbsoluteFile();
                System.out.println(absolute);
            }

            /*
             * File类获取功能
             * long length()
             * 返回路径中表示的文件的字节数
             */
            public static void function_1(){
                File file = new File("d:\eclipse\eclipse.exe");
                long length = file.length();
                System.out.println(length);
            }

            /*
             *  File类的获取功能
             *  String getName()
             *  返回路径中表示的文件或者文件夹名
             *  获取路径中的最后部分的名字
             */
            public static void function(){
                File file = new File("d:\eclipse\eclipse.exe");
                String name = file.getName();
                System.out.println(name);

                /*String path = file.getPath();
                System.out.println(path);*/
        //      System.out.println(file);
            }
        }

File getAbsoluteFile() 重回此抽象路线名的相对路线名格局。
String getAbsolutePath() 重临此抽象路线名的相对路线名字符串。
赢得相对路线

                    c:\windows\system32

第3章总结

1一File类决断成效

* A: File类判断功能
    * a: 方法介绍
        * boolean exists(): 判断File构造方法中封装路径是否存在
            * 存在返回true,不存在返回false
        * boolean isDirectory(): 判断File构造方法中封装的路径是不是文件夹
            * 如果是文件夹,返回true,不是文件返回false
        * boolean isFile(): 判断File构造方法中封装的路径是不是文件
            * 如果是文件,返回true,不是文件返回false

    * b: 案例代码
        public class FileDemo4 {
            public static void main(String[] args) {
                function_1();
            }
            /*
             *  File判断功能
             *  boolean isDirectory()
             *  判断File构造方法中封装的路径是不是文件夹
             *  如果是文件夹,返回true,不是文件返回false
             *  
             *  boolean isFile()
             *  判断File构造方法中封装的路径是不是文件
             */
            public static void function_1(){
                File file = new File("d:\eclipse\eclipse.exe");
                if(file.exists()){
                    boolean b = file.isDirectory();
                    System.out.println(b);
                }
            }

            /*
             *  File判断功能
             *  boolean exists()
             *  判断File构造方法中封装路径是否存在
             *  存在返回true,不存在返回false
             */
            public static void function(){
                File file = new File("src");
                boolean b = file.exists();
                System.out.println(b);
            }
        }

遍历目录的法子list和listFiles
注意事项:
一.被遍历的渠道只可以是一个目录
二.被遍历的目录必须存在
不然就能抛空指针非常

                相对路线

叁.一知识点总括

l 递归:方法定义中调用方法本人的景观

n直接递归

publicvoid methodA(){

methodA();

}

n间接递归

publicvoid metohdB(){

methodC();

}

publicvoid methodC(){

methodB();

}

n递归注意完成

u要有出口,不然正是死递归

u次数不可能太多,不然就内部存款和储蓄器溢出

l File: 文件和目录路线名的悬空意味方式

n构造方法:

public File(String pathname) 通过给定的公文或文件夹的门道,来成立对应的File对象

public File(String parent, String child) 通过给定的父文件夹路线,与给定的文件名称或目录名称来创设对应的File对象

public File(File parent,String child)通过给定的File对象的目录路线,与给定的文书夹名称或文件名称来创设对应的File对象

n路线的分类:

u相对路线, 带盘盘符

E:Workspaceday20_Fileabc.txt

u相对路线, 不带盘符

day20_Fileabc.txt

u注意: 当钦命3个文本路线的时候,倘使选择的是相对路线,暗中认可的目录为 项指标根目录

n方法

public boolean createNewFile()创造文件

u再次来到值为true, 表达成立文件成功

u再次回到值为false,表明文件已存在,创造文件战败

public boolean mkdir() 创设单层文件夹

u成立文件夹成功,重回 true

u创造文件夹战败,重返 false

public boolean mkdirs() 创设多层文件夹

public boolean delete()

u删除此抽象路线名表示的文件或目录。

u假设此路线名代表二个索引,则该目录必须为空工夫去除

public boolean isDirectory() 剖断是或不是为文件夹

public boolean isFile() 判定是或不是为文件

public boolean exists() 推断File对象对应的公文或文件夹是不是留存

public String getAbsolutePath() 获取当前File的相对路线

public String getName() 获取当前File对象的文件或文件夹名称

public long length() 获取当前File对象的文件或文件夹的高低

public File[] listFiles() 获取File所代表目录中具备文件或文件夹的绝对路线

1二File类list获取功用

* A: File类list获取功能
    * a: 方法介绍
        * String[] list():获取到File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
            * 返回只有名字
        * File[] listFiles():获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
            * 返回的是目录或者文件的全路径
        * static File[] listRoots(): 列出可用的文件系统根 

    * b: 案例代码
        public class FileDemo {
            public static void main(String[] args) {
                function_2();
            }
            public static void function_2(){
                //获取系统中的所有根目录
                File[] fileArr = File.listRoots();
                for(File f : fileArr){
                    System.out.println(f);
                }
            }

            /*
             *  File类的获取功能
             *  File[] listFiles()
             *  获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
             *  返回的是目录或者文件的全路径
             */
            public static void function_1(){
                File file = new File("d:\eclipse");
                File[] fileArr = file.listFiles();
                for(File f : fileArr){
                    System.out.println(f);
                }
            }

            /*
             *  File类的获取功能
             *  String[] list()
             *  获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
             *  返回只有名字
             */
            public static void function(){
                File file = new File("c:");
                String[] strArr = file.list();
                System.out.println(strArr.length);
                for(String str : strArr){
                    System.out.println(str);
                }
            }
        }

static File[] listRoots()
得到系统中持有根目录

                    表示路线之间的关系

一三文件过滤器

* A: 文件过滤器
    * a: 作用
        * 过滤一个目录下的指定扩展名的文件,或者包含某些关键字的文件夹

    * b: 方法介绍
        * public String[] list(FilenameFilter filter)
        * public File[] listFiles(FileFilter filter)

    * C: 案例代码   
        /*
         *  自定义过滤器
         *  实现FileFilter接口,重写抽象方法
         */
        public class MyFilter implements FileFilter{
            public boolean accept(File pathname)  {
                /*
                 * pathname 接受到的也是文件的全路径
                 * c:\demo\1.txt
                 * 对路径进行判断,如果是java文件,返回true,不是java文件,返回false
                 * 文件的后缀结尾是.java
                 */
                //String name = pathname.getName();
                return pathname.getName().endsWith(".java");

            }
        }

        /*
         *  File类的获取,文件获取过滤器
         *  遍历目录的时候,可以根据需要,只获取满足条件的文件
         *  遍历目录方法 listFiles()重载形式
         *  listFiles(FileFilter filter)接口类型
         *  传递FileFilter接口的实现类
         *  自定义FileFilter接口实现类,重写抽象方法,
         *  接口实现类对象传递到遍历方法listFiles
         */
        public class FileDemo1 {
            public static void main(String[] args) {
                File file = new File("c:\demo");
                File[] fileArr = file.listFiles(new MyFilter());
                for(File f : fileArr){
                    System.out.println(f);
                }
            }
        }

File[] listFiles()
获得到 File 构造方法中封装的门径中的文件和文书夹名(遍历贰个索引)
回去的是目录大概文件的全路径

                    D:\develop\Java\jdk1.7.0_72\bin

1四文本过滤器_原理剖判

澳门新萄京 2

* A:文件过滤器_原理分析
    * listFiles()遍历目录的同时,获取到了文件名全路径,调用过滤器的方法accept,
    * 将获取到的路径传递给accept方法的参数pathname
    * accept方法接收了参数pathname,参数是listFiles传递来的
    * 在accept方法中,进行判断,如果这个路径是Java文件,返回true,走着返回false
    * 一旦方法返回了true
    * listFiles将路径保存到File数组中

String[] list()
收获到 File 构造方法中封装的门道中的文件和文件夹名(遍历二个索引)
回去的只盛名字

                    D:\develop\Java\jre7

一五递归遍历全目录

澳门新萄京 3

* A: 递归遍历全目录
    * a: 案例代码
        /*
         *  对一个目录的下的所有内容,进行完全的遍历
         *  编程技巧,方法的递归调用,自己调用自己
         */
        public class FileDemo {
            public static void main(String[] args) {
                File dir = new File("d:\eclipse");
                getAllDir(dir);
            }
            /*
             *  定义方法,实现目录的全遍历
             */
            public static void getAllDir(File dir){
                System.out.println(dir);
                //调用方法listFiles()对目录,dir进行遍历
                File[] fileArr = dir.listFiles();
                for(File f : fileArr){
                    //判断变量f表示的路径是不是文件夹
                    if(f.isDirectory()){
                        //是一个目录,就要去遍历这个目录
                        //本方法,getAllDir,就是给个目录去遍历
                        //继续调用getAllDir,传递他目录
                        getAllDir(f);
                    }else{
                        System.out.println(f);
                    }
                }
            }
        }

递归
递归:方法本人调用本人
分类:
递归分为三种,直接递归和直接递归。
直接递归称为方法本人调用本人。直接递归能够A方法调用B方法,B方法调用C方法,C方法调用A方法。

                    路线之间关系

1陆递归概念和注意事项

* A:递归概念和注意事项
    * a: 递归概念
        * 递归,指在当前方法内调用自己的这种现象
        * 递归分为两种,直接递归和间接递归
        * 直接递归称为方法自身调用自己。间接递归可以A方法调用B方法,B方法调用C方法,C方法调用A方法
    * b: 注意事项
        * 递归一定要有出口, 必须可以让程序停下
        * 递归次数不能过多
        * 构造方法,禁止递归

注意:
一.递归自然要有标准限制,有限支撑递归能够甘休下来,不然会生出栈内部存款和储蓄器溢出。
二.在递归中就算有限定标准,可是递归次数不可能太多。不然也会发出栈内部存款和储蓄器溢出。
三.构造格局,禁止递归

                        Java 父目录是D:\develop

1柒递归求和计量

澳门新萄京 4

* A: 递归求和计算
    * a: 题目分析
        * 1 2 3 ... (n-1) n:求1到n的和
        * 总结规律:1到n的和等于1到(n-1)的和再加n
        * getSum(n-1)  n
        * 递归出口:getSum(1) return 1;

    * b: 案例代码   
        /*
         *  方法的递归调用
         *    方法自己调用自己
         *  适合于,方法中运算的主体不变,但是运行的时候,参与运行的方法参数会变化
         *  注意:
         *     递归一定要有出口, 必须可以让程序停下
         *     递归次数不能过多
         *     构造方法,禁止递归
         */
        public class DiGuiDemo {
            public static void main(String[] args) {
                int sum = getSum(3);
                System.out.println(sum);
            }


            /*
             *  计算 1 2 3 100和 = 5050
             *  计算规律:
             *    n (n-1) (n-2)
             *    100 (100-1) (99-1) ...1
             */
            public static int getSum(int n){
                if( n == 1)
                    return 1;
                return n   getSum(n-1);
            }

        }
 1 使用递归计算1-n之间的和
 2       n   (n-1)  (n-2) (n-3) ... 1
 3       5  (5-1) (4-1) (3-1) (2-1)
 4       结束条件:n=1的时候结束
 5       方法自己调用自己目的:获取n-1,获取到n=1的时候结束
 6     public static int DGSum(int n){
 7         //添加结束条件
 8         if(n==1){
 9             return 1;
10         }
11         return n DGSum(n-1);
12     } 
13 
14 使用递归计算阶乘
15      private static long DGJC(int n) {
16         //递归的结束条件 n==1
17         if(n==1){
18             return 1;
19         }
20         return n*DGJC(n-1);
21     }
22 
23 使用递归计算斐波那契数列    
24     private static int fbnq(int month) {
25         //结束条件如果month是1,2直接返回1
26         if(month==1 || month==2){
27             return 1;
28         }
29         //3月以上:兔子数量是前两个月之和
30         return fbnq(month-1) fbnq(month-2);
31     } 

                        Java 子目录是:jdk一.⑦.0_72

1八递归求阶乘

* A: 递归求和计算
    * a: 题目分析
        * 5!=5*4*3*2*1
        *   =5*4!
        * 4!=4*3!
        * 3!=3*2!
        * 2!=2*1!
        * 1!=1
        * n!=n*(n-1)!
        * 递归出口:n*getJieCheng(n-1):  getJieCheng(1) return 1;
    * b: 案例代码
        /*
         *  方法的递归调用
         *    方法自己调用自己
         *  适合于,方法中运算的主体不变,但是运行的时候,参与运行的方法参数会变化
         *  注意:
         *     递归一定要有出口, 必须可以让程序停下
         *     递归次数不能过多
         *     构造方法,禁止递归
         */
        public class DiGuiDemo {
            public static void main(String[] args) {                    
                System.out.println(getJieCheng(5));

            }

            /* 
             *  计算阶乘 5!
             *   5*4*3*2*1
             */
            public static int getJieCheng(int n){
                if ( n == 1)
                    return 1;
                return n * getJieCheng(n-1);
            }                               
        }

文件过滤器
文件的过滤器:
要求:遍历hello文件夹,只获得文件夹中的.java结尾的文书
c:\hello
c:\hello\demo.txt
c:\hello\Hello.java

                    父路线是 唯一性

1玖递归计算斐波那契数列

澳门新萄京 5

* A: 递归计算斐波那契数列
    * a:题目分析
        * 1 1 2 3 5 8 13 21
        * 从第三项开始,后面的每一项都等于前面两项的和,第一项和第二项的值为1,作为程序的出口
    * b: 案例代码
        /*
         *  方法的递归调用
         *    方法自己调用自己
         *  适合于,方法中运算的主体不变,但是运行的时候,参与运行的方法参数会变化
         *  注意:
         *     递归一定要有出口, 必须可以让程序停下
         *     递归次数不能过多
         *     构造方法,禁止递归
         */
        public class DiGuiDemo {
            public static void main(String[] args) {                    
                System.out.println(getFBNQ(12));
            }
            /*
             *  方法递归,计算斐波那契数列
             *  
             */
            public static int getFBNQ(int month){
                if( month == 1)
                    return 1;
                if( month == 2)
                    return 1;
                return getFBNQ(month-1) getFBNQ(month-2);
            }
        }

在File类中listFiles()方法是遍历文件夹的艺术
有多个和 listFiles重载的情势,参数字传送递的正是过滤器
File[] listFiles(FileFilter filter)
File[] listFiles(FilenameFilter filter)
回去抽象路线名数组,那么些渠道名代表此抽象路线名表示的目录中级知识分子足钦定过滤器的文件和目录。
意识方法的参数FileFilter和FilenameFilter是接口
享有我们供给和煦定义接口的贯彻类,重写接口中的方法accept,落成过滤效果

                    子目录是能够多个

23回历目录下的具有java文件

* A: 遍历目录下的所有java文件
    * a: 案例代码
        public class MyJavaFilter implements FileFilter {
            public boolean accept(File pathname) {
                //判断获取的是目录,直接返回true
                if(pathname.isDirectory())
                    return true;
                return pathname.getName().toLowerCase().endsWith(".java");
            }

        }
        /*
         *  遍历目录,获取目录下的所有.java文件
         *  遍历多级目录,方法递归实现
         *  遍历的过程中,使用过滤器
         */
        public class FileDemo1 {
            public static void main(String[] args) {
                getAllJava(new File("c:\demo"));
        //      new File("c:\demo").delete();
            }
            /*
             * 定义方法,实现遍历指定目录
             * 获取目录中所有的.java文件
             */
            public static void getAllJava(File dir){
                //调用File对象方法listFiles()获取,加入过滤器
                File[] fileArr = dir.listFiles(new MyJavaFilter());
                for(File f : fileArr){
                    //对f路径,判断是不是文件夹
                    if(f.isDirectory()){
                        //递归进入文件夹遍历
                        getAllJava(f);
                    }else{
                        System.out.println(f);
                    }
                }
            }
 1 public class FileFilterImpl implements FileFilter{
 2     /*
 3      * 实现过滤的方法:
 4         1.把传递过来的路径pathname,变成字符串
 5             Stirng s  = pathname.toString(); "c:\hello\demo.txt"
 6             String s  = pathname.getPaht(); "c:\hello\demo.txt"
 7             String s = pathname.getName(); "demo.txt"
 8         2.使用String类中的方法endsWith判断字符串是否以指定的字符串结尾
 9             boolean b = s.endsWith(".java");
10             return b;
11      */
12     @Override
13     public boolean accept(File pathname) {
14         /*String s = pathname.getName();
15         boolean b = s.endsWith(".java");
16         return b;*/
17         return pathname.getName().toLowerCase().endsWith(".java");
18     }
19 }
20 public class FilenameFilterImpl implements FilenameFilter{
21 
22     @Override
23     public boolean accept(File dir, String name) {
24         return name.toUpperCase().endsWith(".JAVA");
25     }
26 
27 }
  1. A: File类的构造方法_2

学业测试

1.选用文件名称过滤器筛选将点名文件夹下的小于200K的小文件获取并打印。

二.从键盘接收七个文书夹路线,总计该公文夹大小。

三.从键盘接收七个文本夹路线,删除该公文夹。

4.从键盘接收贰个文件夹路线,把公文夹中的全部文件以及文件夹的名字按层级打印

例如:
aaa是文件夹,里面有bbb.txt,ccc.txt,ddd.txt这些文件,有eee这样的文件夹,eee中有fff.txt和ggg.txt,打印出层级来
aaa
    bbb.txt
    ccc.txt
    ddd.txt 
    eee
        fff.txt
        ggg.txt

5.键盘录入二个文件夹路线,计算该文件夹(包罗子文件夹)中每种类型的文书及个数,注意:用文件类型(后缀名,不包蕴.(点),如:"java","txt")作为key,

用个数作为value,放入到map集合中,并用两种方式遍历map集合
例如:
doc 的类型的文件有  3 个
java 的类型的文件有  5 个
txt 的类型的文件有  7 个

假如想进一步的交换,可以投入我们的QQ群,里面有最新的求学资料,能够学学。

澳门新萄京 6

断点调节和测试
debug断点调节和测试
f陆:逐行推行
f5:进入到形式中
f7:甘休方法
f8:跳到下贰个断点
watch:捕获

        * a:File(String parent, String child) 

            * 依照 parent 路线名字符串和 child 路线名字符串创建2个新 File 对象

                           

        * b: File(File parent, String child)

  1. A: File类创造文件成效

        * a: public boolean createNewFile()

            * 创设文件 假设存在这么的文件,就不创建了

* A: File类创建目录功用

        * a: 创造目录

            * public boolean mkdir():创立文件夹 假诺存在这么的公文夹,就不创立了

            * public boolean mkdirs():成立文件夹,若是父文件夹不设有,会帮您创建出来

* A: File类删除效用

        * a: 删除功效

            * public boolean delete():删除文件恐怕文件夹

* A:File类获取效率

        * a: 方法介绍

            * String getName(): 再次回到路线中代表的文件或许文件夹名

                * 获取路径中的最终有的的名字

            * long length(): 重返路线中意味着的文本的字节数

            * String getAbsolute帕特h(): 获取绝对路线,重回String对象

            * File  getAbsoluteFile() : 获取相对路线,再次回到File对象

                * eclipse景况中,写2个绝对路线,相对地点工程根目录

            * String getParent(): 获取父路线,重临String对象

            * File getParentFile(): 获取父路线,再次回到File对象。

* A: File类决断功能

        * a: 方法介绍

            * boolean exists(): 判定File构造方法中封装路线是不是存在

                * 存在再次回到true,不设有重返false

            * boolean isDirectory(): 决断File构造方法中封装的渠道是或不是文件夹

                * 借使是文件夹,重回true,不是文本重返false

            * boolean isFile(): 判别File构造方法中封装的门路是否文件

                * 假若是文本,再次回到true,不是文本重临false

* A: File类list获取效率

        * a: 方法介绍

            * String[] list():获取到File构造方法中封装的渠道中的文件和文书夹名 (遍历三个索引)

                * 重回只盛名字

            * File[] listFiles():获取到,File构造方法中封装的路子中的文件和文书夹名 (遍历1个索引)

                * 重返的是目录只怕文件的全路线

            * static File[] listRoots(): 列出可用的文件系统根 

* 6.A: 文件过滤器

        * a: 作用

            * 过滤贰个索引下的钦命扩展名的文本,恐怕隐含某个关键字的公文夹

           

        * b: 方法介绍

            * public String[] list(FilenameFilter filter)

            * public File[] listFiles(FileFilter filter)

* A:文件过滤器_规律解析

        * listFiles()遍历目录的还要,获取到了文本名全路径,调用过滤器的方法accept,将得到到的路径传递给accept方法的参数pathname

        * accept方法接收了参数pathname,参数是listFiles传递来的

        * 在accept方法中,举办判别,假若那个路子是Java文件,再次回到true,走着回去false

        * 1旦方法再次回到了true

        * listFiles将路线保存到File数组中

7.* A:递归概念和注意事项

        * a: 递归概念

            * 递归,指在现阶段格局内调用自个儿的这种现象

            * 递归分为二种,直接递归和直接递归

            * 间接递归称为方法自己调用本人。直接递归能够A方法调用B方法,B方法调用C方法,C方法调用A方法

        * b: 注意事项

            * 递归自然要有出口, 必须能够让程序停下

            * 递归次数不可能过多

            * 构造方法,禁止递归

* A: 递归求和计算

        * a: 标题深入分析

            * 1 2 3 ... (n-1) n:求1到n的和

            * 计算规律:1到n的和至极一到(n-一)的和再加n

            * getSum(n-一) n                                       递归出口:getSum(一) return 壹;

本文由澳门新萄京发布于www.澳门新萄京赌场,转载请注明出处:澳门新萄京:22_IO_第22天(File、递归)_讲义

上一篇:澳门新萄京:学习快速排序,二分查找的学习和 下一篇:没有了
猜你喜欢
热门排行
精彩图文