递归:
直接递归和间接递归
递归一定要有条件限定,能够保证停下来,否则会发生栈内存溢出
递归的次数不能太多,否则也会发生栈内存溢出
构造方法禁止递归,编译报错,构造方法是创建对象时使用,一直递归,导致内存中对象太多,所以直接报错
当调用方法的时候,方法的主体不变,每次调用方法的参数不同,可以使用递归
=============
public class DiGui {
public static void main(String[] args) {
// a();
b(1);
}
private static void a(){
System.out.println("a方法");
a();//会发生栈内存溢出。
}
private static void b(int i){
System.out.println(i);
if(i==20000){
return;//结束方法,次数太多也会报错,次数少一点不会
}
b(++i);
}
}
import java.util.Scanner;
/*
* 使用递归计算阶乘
*
*/
public class DiGuiTes02 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int n = sc.nextInt();
int s = jc(n);
System.out.println(s);
}
public static int jc(int n){
if(n==1){
return 1;
}
//下一个数字,通过递归来获取下一个数字。
return n * jc(n-1);
}
}
-------------------------
import java.util.Scanner;
/*
* 练习:
* 使用递归计算1-n之间的和
* 方法先入栈,等到==1时。1返回给调用它的方法,依次返回,反向递加结果。
* main方法调用sum方法,内存中有多个sum方法频繁的调用方法,销毁方法,效率低下。
*
*/
public class DiGuiTest01 {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
System.out.println("请输入一个整数");
int n = sc.nextInt();
int s = sum(n);
System.out.println(s);
}
public static int sum(int n){
if(n==1){
return 1;
}
//获取下一个被加的数字
return n + sum(n-1);
}
}
------------------------------
import java.io.File;
/*
* 使用递归打印多级目录:
* 遍历一个文件夹
* 遍历的结果并不完整,没有子文件夹里面的东西
* 对f进行判断,是否是文件夹,如果是文件夹,继续遍历
* 如果是文件直接打印。
*/
public class DiGuiTest03 {
public static void main(String[] args) {
File file = new File("C:\\MyDrivers");
getAll(file);
}
//参数file类型的目录
public static void getAll(File dir){
//打印被遍历的名称
System.out.println(dir);
File[] files = dir.listFiles();
for (File f : files) {
if(f.isDirectory()){
//递归调用
getAll(f);
}else{
System.out.println(f);
}
}
}
}
-----------------------------
import java.io.File;
/*
* 遍历目录只要以什么结尾的文件.
*
*/
public class DiGuiTest04 {
public static void main(String[] args) {
File file = new File("D:\\1907testjava\\day01");
getAll(file);
}
//参数file类型的目录
public static void getAll(File dir){
//打印被便利的名稱
// System.out.println(dir);
File[] files = dir.listFiles();
for (File f : files) {
if(f.isDirectory()){
//递归调用
getAll(f);
}else{
/*
* String类中endwith
* 把file对象f转换为字符串对象
* f.get
*
*/
// String name = f.getName();//获取文件名称
// String path = f.getPath();
String s = f.toString();
//把字符串转换为小写
s = s.toLowerCase();
boolean b = s.endsWith(".java");
// 如果是.java结尾则输出
if(b){
System.out.println(f);
}
//链式编程
if(f.getName().toLowerCase().endsWith(".java")){
System.out.println(f);
}
}
}
}
}
File
java.io.File类
文件和目录路径名的抽象表达式
java把电脑中的文件和文件夹(目录)封装成为了一个File类,我们可以使用File类
对文件和文件夹进行操作。
创建,删除,获取,判断是否存在,遍历,获取文件的大小
File类是一个与系统无关的类,任何的操作系统都可以使用这个类中的方法
file文件 directory 文件夹 目录 path路径
===============
public class FileCls {
public static void main(String[] args) {
/*
* File类的静态成员变量
* static String pathSeparator:与系统有关的路径分隔符,他被表示为一个字符串
* static char pathSeparatorChar:与系统有关的路径分隔符
*
* static String separator:与系统有关的默认名称分隔符,他被表示为一个字符串
* static char separatorChar:与系统有关的默认名称分隔符
*
* 工作中操作路径不能写死,需要这样写
* C:\develop\a\a.txt
* "C:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"
*
*/
String pathSeparator = File.pathSeparator;
System.out.println(pathSeparator);//;
String path01 = File.separator;
System.out.println(path01);// \
char path02 = File.pathSeparatorChar;
System.out.println(path02);//;
char path03 = File.separatorChar;
System.out.println(path03);// \
}
}
----------------------
import java.io.File;
/*
* File类的判断功能的方法:
* public boolean exists():判断文件或者目录是否存在
* public boolean isDirectory():
* 由此File表示的目录是否存在
* public boolean isFile():表示是否为文件
*
*/
public class FileBoolean {
public static void main(String[] args) {
// show01();
show02();
}
/*
* public boolean exists():判断文件或者目录是否存在
* 用于判断构造方法中的路径是否存在
* 存在:true 不存在L:false
*/
public static void show01(){
File f1 = new File("D:\\Hello java\\javaPro");
boolean y = f1.exists();
System.out.println(y);//存在为true
File f2 = new File("D:\\Hello java\\javaPro\\dd");
System.out.println(f2.exists());//不存在为false
File f3 = new File("javaPro");
System.out.println(f3.exists());//不存在为false
}
/*
* public boolean isDirectory():由此File表示的目录是否存在
* 判断给定的路径是否以文件夹结尾,是true 否false
* public boolean isFile():表示是否为文件
* 判断给定的路径是否以文件结尾,是true 否false
* 电脑中的文件要么是文件,要么是文件夹
* 这两个方法的使用前提,路径必须是存在的,否则都返回false
* 所以使用之前进行判断
*/
public static void show02(){
File f1 = new File("D:\\Hello java\\javaPro");
if(f1.exists()){
System.out.println(f1.isDirectory());
System.out.println(f1.isFile());
}
//不存在就不获取了
File f2 = new File("D:\\Hello java\\javaPro\\dd");
if(f2.exists()){
System.out.println(f2.isDirectory());
System.out.println(f2.isFile());
}
}
}
-----------------------------
import java.io.File;
import java.io.IOException;
/*
* File类创建和删除功能的方法
* public boolean createNewFile():当且仅当具有该名称的文件时,创建一个新的文件夹
* public boolean delete():删除此file表示的文件或目录
* public boolean mkdir():创建此file表示的目录
* public boolean mkdirs():创建此file表示的目录,包括任何必须但不存在的目录
*
*
*/
public class FileCreateDel {
public static void main(String[] args) throws IOException {
// show01();
// show02();
show03();
}
/*
* public boolean createNewFile():当且仅当具有该名称的文件不存在时,创建一个新的文件
* 创建文件的路径和名称在构造方法中给出(构造方法的参数)
* 返回值:布尔值
* true:文件不存在,创建返回值true
* false:文件存在,返回false
* 此方法只能创建文件,不能创建文件夹
* 创建文件的路径必须存在,否则会抛出异常
*
*/
private static void show01() throws IOException{
File f1 = new File("E:\\p2\\bb.txt");
boolean b1 = f1.createNewFile();
System.out.println(b1);
File f2 = new File("All Users\\b.txt");
boolean b2 = f1.createNewFile();
System.out.println(b2);
}
/*
* public boolean mkdir():创建单级文件夹
* public boolean mkdir():既可以创建单级也可以创建多级
* 文件夹不存在创建返回true
* 文件夹存在:返回false
* 此方法只能创建文件夹,不能创建文件。
*/
private static void show02(){
File f1 = new File("E:\\p2\\bb");
boolean b1 = f1.mkdir();
System.out.println(b1);
//只能创建单级文件夹
File f2 = new File("E:\\p2\\cc\\dd\\ee");
boolean b2 = f2.mkdir();
System.out.println(b2);
File f3 = new File("E:\\p2\\cc\\dd\\ee");
boolean b3 = f3.mkdirs();
System.out.println(b3);
}
/*
* public boolean delete():删除此file表示的文件或目录
* 此方法,可以删除构造方法中给出的文件/文件夹
* 返回值:布尔值
* true:文件/文件夹删除成功,返回true
* false:文件夹中有东西,不会删除返回false,构造方法中的路径不存在yefanhuifalse
* 这个方法删除步骤回收站,直接删除硬盘文件
*
*/
private static void show03(){
File f1 = new File("E:\\p2\\bb");
boolean b1 = f1.delete();
System.out.println(b1);
File f2 = new File("E:\\p2\\bb.txt");
boolean b2 = f2.delete();
System.out.println(b2);
}
}
------------------------------
import java.io.File;
/*
* File类遍历:
* public String[] List() :返回一个String数组,表示File目录中所有的子文件或目录
* public File[] ListFiles():返回一个File数组,表示File目录中的所有子文件或目录
* 遍历构造方法中给出的参数
* 如果给出的路径不存在抛出空指针异常
* 给出的路径不是目录,也会抛出空指针异常
*
*/
public class FileForeach {
public static void main(String[] args) {
// show01();
show02();
}
/*
* public String[] List() :返回一个String数组,表示File目录中所有的子文件或目录
* 获取目录中所有文件/文件夹的名称,获取到多个名称存储到String类型的数组之中
* 打印子目录
*/
private static void show01(){
File f1 = new File("C:\\MyDrivers");
String[] list = f1.list();
for (String string : list) {
System.out.println(string);
}
}
/*
* public File[] ListFiles():返回一个File数组,表示File目录中的所有子文件或目录
* 构造方法中给出的目录,会获取目录中的所有的文件/文件夹,把文件/文件夹封装为File对象
* 多个File对象存储到File数组中
* 打印绝对路径
*/
private static void show02(){
File f1 = new File("C:\\MyDrivers");
File[] files = f1.listFiles();
for (File file : files) {
System.out.println(file);
}
}
}
----------------------------
import java.io.File;
/*
* 绝对路径和相对路径:
* 绝对路径:完整的路径,以盘符开始的 C,D
* 相对路径:一个简化的路径,相对指的是相对于当前项目的根目录,可以省略项目的根路径
*
* 路径是不区分大小写的
* 路径中的文件名称分隔符windows中使用反斜杠,反斜杠为转义字符,两个反斜杠代表一个普通的反斜杠
*
* File类的构造方法:
* 构造方法可以创建对象
*
*
*
*/
public class FileLuJing {
public static void main(String[] args) {
/*
* File类的构造方法
*/
// show01();
// show02("c:\\","a.txt");
show03();
}
/*
* File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建一个File实例
* 参数:
* String pathname : 字符串的路径名称
* 路径可以是以文件结尾,也可以是文件夹
* 可以是相对路径,也可以是绝对
* 路径可以存在,也可以不存在
* 创建File对象,只是把字符串路径封装为File对象,不考虑路径的真假情况
*/
public static void show01(){
File f1 = new File("D:\\Hello java");
System.out.println(f1);
}
/*
* File(String parent,String child)
* 根据parent 路径名字符串和child路径名字符串创建一个新的File实例
* 把路径分成两部分:
* String parent
* String child
* 父路径和子路径,可以单独书写,使用起来非常灵活,父路径和子路径可以变化
*/
public static void show02(String parent,String child){
File file = new File(parent,child);
System.out.println(file);
}
/*
* File(File parent,String child) 根据parent抽象路径名和child路径名字创建一个
* 新的File
* 参数:
* File parent:File类型的父路径,可以使用File类的方法对路径进行一些操作
* String child
*
*/
public static void show03(){
File parent = new File("c:\\");
File file = new File(parent,"hello.java");
System.out.println(file);
}
}
------------------------------
import java.io.File;
/*
* File类获取功能的方法
* public String getAbsolutePath():返回此file的绝对路径名字字符串
* public String getPath():将此file转换为路径名字字符串
* public String getName():返回此file表示的文件或目录的名称
* public Long Length():返回此File表示的文件的长度
*
*
*/
public class FileMethod {
public static void main(String[] args) {
// show01();
// show02();
// show03();
show04();
}
/*
* public String getAbsolutePath():返回此file的绝对路径名字字符串
* 获取的构造方法中传递的路径
* 无论是绝对的还是相对的,getAbsolutePath方法返回的都是绝对路径
*/
private static void show01(){
File f1 = new File("C:\\MyDrivers\\backup");
String absolutePath = f1.getAbsolutePath();
System.out.println(absolutePath);
File f2 = new File("backup");
String absolutePath2 = f2.getAbsolutePath();
System.out.println(absolutePath2);//D:\jxb.eeeee\day_08_file\backup
}
/*
* public String getPath():将此file转换为路径名字字符串
* 获取构造方法中传递的路径,无论是绝对的还是相对的
* toString方法调用的就是getPath方法
*
*/
public static void show02(){
File f1 = new File("C:\\MyDrivers\\backup");
String path = f1.getPath();
System.out.println(path);
File f2 = new File("backup");
String path2 = f2.getPath();
System.out.println(path2);
}
/*
* public String getName():返回此file表示的文件或目录的名称
* 获取的就是构造方法传递路径的结尾部分(文件/文件夹)
*
*/
public static void show03(){
File f1 = new File("C:\\MyDrivers\\backup\\a.txt");
String name1 = f1.getName();
System.out.println(name1);//a.txt
File f2 =new File("C:\\MyDrivers\\backup");
String name2 = f2.getName();
System.out.println(name2);//backup
}
/*
* public Long Length():返回此File表示的文件的长度
* 获取构造方法指向文件的大小,以字节为单位,
* 文件夹是没有大小概念的,不能获取文件夹,如果构造方法给出的路径不存在
* 那么length方法返回0
*
*/
public static void show04(){
File f1 = new File("D:\\a.jpeg");
long l = f1.length();
System.out.println(l);
File f2 = new File("D:\\b.jpeg");//没有这张图片,路径不存在
Long l2 = f2.length();
System.out.println(l2);//返回为0
File f3 = new File("D:\\Hello java");//文件夹没有大小概念的
Long l3 = f3.length();
System.out.println(l3);
}
}
过滤器
我们可以使用过滤器来实现
在File类中有两个ListFiles重载的方法,方法参数传递的就是过滤器。
File[] ListFiles(FileFilter filter)
java.io.FileFilter接口:用于抽象路径名(File对象)的过滤器,
用来过滤文件
boolean accept(File pathname) 测定抽象路径名是否包含在某个路径名列表中
pathname使用ListFiles方法遍历目录得到的每一个文件对象
File[] ListFiles(FilenameFilter filter)
java.io.FilenameFilter接口,过滤文件名称
boolean accept(File dir,String name) 测试指定文件是否应该包含在某一列表中
File dir:构造方法中传递的被便利的目录
String name:使用ListFiles方法遍历目录,获取每一个文件/文件夹的名称
注意:
两个过滤器接口是没有实现类的,需要我们自己写实现类,重写过滤的方法accept
在方法中自己定义过滤的规则。
==================
public class FilterTest {
public static void main(String[] args) {
File file = new File("D:\\1907testjava\\day01");
getAll(file);
}
//参数file类型的目录
public static void getAll(File dir){
File[] files = dir.listFiles(new FileFilterImpl());//传递过滤器
for (File f : files) {
if(f.isDirectory()){
//递归调用
getAll(f);
}else{
System.out.println(f);
}
}
}
}
--------------------------------
import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
/*
* 我们可以使用过滤器来实现
* 在File类中有两个ListFiles重载的方法,方法参数传递的就是过滤器。
* File[] ListFiles(FileFilter filter)
* java.io.FileFilter接口:用于抽象路径名(File对象)的过滤器,
* 用来过滤文件
* boolean accept(File pathname) 测定抽象路径名是否包含在某个路径名列表中
* pathname使用ListFiles方法遍历目录得到的每一个文件对象
* File[] ListFiles(FilenameFilter filter)
* java.io.FilenameFilter接口,过滤文件名称
* boolean accept(File dir,String name) 测试指定文件是否应该包含在某一列表中
* File dir:构造方法中传递的被便利的目录
* String name:使用ListFiles方法遍历目录,获取每一个文件/文件夹的名称
*
* 注意:
* 两个过滤器接口是没有实现类的,需要我们自己写实现类,重写过滤的方法accept
* 在方法中自己定义过滤的规则。
*
*/
public class FilterTest02 {
public static void main(String[] args) {
File file = new File("D:\\1907testjava\\day01");
getAll(file);
}
//参数file类型的目录
public static void getAll(File dir){
//传递过滤对象,使用匿名内部类
/*File[] files = dir.listFiles(new FileFilter() {
//不用实现类,使用匿名对象
@Override
public boolean accept(File pathanme) {
// 过滤规则
return pathanme.isDirectory() ||pathanme.getName().toLowerCase().endsWith(".java");
}
});*/
/*File[] filex = dir.listFiles((File pathname)->{
return pathname.isDirectory() ||pathname.getName().toLowerCase().endsWith(".java");
});*/
File[] filex = dir.listFiles(pathname->pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java"));
//地热种方法匿名内部类过滤
/*File[] files = dir.listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
// TODO Auto-generated method stub
return new File(dir,name).isDirectory() ||name.toLowerCase().endsWith(".java");
}
});*/
//使用Lambda表达式优化匿名内部类(接口中只有一个抽象方法才能使用Lambda表达式)
File[] files = dir.listFiles((File d,String name)->{
return new File(d,name).isDirectory() ||name.toLowerCase().endsWith(".java");
});
//继续简化
// File[] filess = dir.listFiles(( d, name)->new File(d,name).isDirectory() ||name.toLowerCase().endsWith(".java"));
//传递过滤器
for (File f : files) {
if(f.isDirectory()){
//递归调用
getAll(f);
}else{
System.out.println(f);
}
}
}
}
----------------------------
import java.io.File;
import java.io.FileFilter;
/*
* 创建过滤器FileFilter的实现类,重写过滤方法
* 定义过滤规则
*
*
*/
public class FileFilterImpl implements FileFilter{
@Override
public boolean accept(File pathname) {
// 返回的结果存储到File数组之中
//在accept方法中是否以.java结尾,是返回true,不是返回falses
if(pathname.isDirectory()){
//把文件夹也放在数组之中继续遍历。
return true;
}
return pathname.getName().toLowerCase().endsWith(".java");
}
}