Exercices de base JAVA-récursivité, obtenir tous les fichiers du dossier, supprimer un fichier, copie de fichier, impression hiérarchique, séquence de Fibonacci, bague Joseph

Récursion

1. Concept: Invoquez-vous
Cas: Exigences: Comptez 5!
Méthode 1: Utilisez la boucle for

int result=1;
		for (int i = 1; i <=5; i++) {
    
    
			result=result*i;
		}
		System.out.println(result);
	}

Deuxième méthode: utiliser la récursivité

public static int fun(int num) {
    
    
		if (num ==1) {
    
    
			return 1;
		}else {
    
    
			return num*fun(num-1);
		}
	}

Désavantages: La récursivité ne peut pas être appelée trop de fois, sinon la mémoire de la pile débordera.
avantage: Pas besoin de connaître le nombre de cycles
problème: Le
constructeur ne peut pas utiliser d'appels récursifs. Un appel récursif peut avoir une valeur de retour ou aucune valeur de retour.

Exercices récursifs (1)

Conditions requises: saisissez un chemin de dossier à partir du clavier et imprimez tous les noms de fichier .java du dossier.Analyse
:
1. Obtenez tous les fichiers et dossiers sous le chemin du dossier et stockez-les dans le tableau de fichiers
2. Parcourez le tableau et jugez chaque fichier ou dossier.
3. S'il s'agit d'un fichier et que le suffixe est .java, imprimez-le
4. S'il s'agit d'un dossier, appelez-le récursivement

public class Demo1_Test {
    
    

	public static void main(String[] args) {
    
    
		File dir =getDir();
		printJavaFile(dir);
	}
	public static File getDir() {
    
    
		Scanner scanner =new Scanner(System.in);
		System.out.println("请输入一个文件夹路径：");
		while (true) {
    
    
			String line =scanner.nextLine();
			File dir =new File(line);
			if (!dir.exists()) {
    
    
				System.out.println("您录入的文件夹路径不存在，请重新录入");
			}else if (dir.isFile()) {
    
    
				System.out.println("您录入的是文件夹路径，请重新录入文件路径");
			}else {
    
    
				return dir;
			}
		}
	}
	
	//获取文件夹路径下的所有.java文件
	//返回值类型void
	//参数列表File dir
	public static void printJavaFile(File dir) {
    
    
		//获取到该文件路径下的所有的文件和文件夹，存储在File数组中
		File[] subFiles =dir.listFiles();
		//遍历数组，对每一个文件或文件夹做判断
		for (File subFile :subFiles) {
    
    
			//如果是文件，并且后缀名是.java的就打印
			if (subFile.isFile()&&subFile.getName().endsWith(".java")) {
    
    
				System.out.println(subFile);
			//如果是文件夹，就递归调用
			}else if (subFile.isDirectory()) {
    
    
				printJavaFile(subFile);
			}
				
			
		}
	}
}

L'effet est le suivant:

Exercices récursifs (2)

Condition: recevoir un chemin de dossier à partir du clavier et compter la taille du dossier.
Analyse:
recevoir un chemin de dossier à partir du clavier

1. Créer des objets d'entrée au clavier
2. Définir une boucle sans fil
3. Stockez et encapsulez les résultats de la saisie au clavier dans des objets File
4. Juger l'objet File
5. Objet de chemin de dossier de retour

Comptez la taille du dossier

1. Définir une variable de somme
2. Obtenez tous les fichiers et dossiers dans le dossier ListFiles ();
3. Traversez le tableau
4. S'il s'agit d'un fichier, calculez la taille et additionnez-la
5. Jugez que c'est un dossier, appelez récursivement

public class Demo2_Test {
    
    

	public static void main(String[] args) {
    
    
		//File dir =new File("d:\\day15");
		//System.out.println(dir.length());//直接获取文件夹的结果是0
		File dir =getFile();
		System.out.println(getFileLength(dir));
	}
	
	public static File getFile() {
    
    
		Scanner scanner =new Scanner(System.in);
		System.out.println("请输入一个文件夹路径");
		while (true) {
    
    
			String line =scanner.nextLine();
			File dir = new File(line);
			//对File对象进行判断
			if (!dir.exists()) {
    
    
				System.out.println("文件路径不存在！");
			}else if(dir.isFile()) {
    
    
				System.out.println("这是文件夹路径，请输入文件路径");
			}
			else {
    
    
				//将文件夹路径对象返回
				return dir;
			}
		}	
	}
	//统计文件大小。返回值类型long，参数列表File dir
	public static long getFileLength(File dir) {
    
    
		//定义一个求和变量
		long len =0;
		//获取该文件夹下所有的文件和文件夹ListFiles
		File [] subFiles =dir.listFiles();
		//遍历数组
		for (File subFile : subFiles) {
    
    
			//判断如果是文件就计算大小并累加
			if (subFile.isFile()) {
    
    
				len +=subFile.length();
			}else {
    
    
				//如果是文件夹的话就在继续递归调用
				len+=getFileLength(subFile);
			}
			
		}
		return len;
	}
	
}

L'effet est le suivant:

Exercices récursifs (3)

Conditions requises: entrez le chemin d'accès depuis la console et supprimez le dossier

public class Demo3_Test {
    
    

	public static void main(String[] args) {
    
    
		File file =getFile();
		deleteFile(file);
	}
	
	//删除文件夹
	public static void deleteFile(File dir) {
    
    
		File[]subFiles=dir.listFiles();
		//遍历数组
		for (File subFile : subFiles) {
    
    
			if (subFile.isFile()) {
    
    
				//如果是文件夹就直接删除
				subFile.delete();
			}else {
    
    
				deleteFile(subFile);
			}
			
		}
		//循环结束后，把空文件夹删掉
		dir.delete();
	}
	
	public static File getFile() {
    
    
		Scanner scanner =new Scanner(System.in);
		System.out.println("请输入一个文件路径名称");
		while (true) {
    
    
			String line =scanner.nextLine();
			File dir =new File(line);
			if (!dir.exists()) {
    
    
				System.out.println("文件路径不存在或输入有误");
			}else if(dir.isFile()){
    
    
				System.out.println("这是文件夹路径，请输入文件路径");
			}else {
    
    
				return dir;
			}
		}
	}
}

Exercices récursifs (4)

Condition: recevez deux chemins de dossier à partir du clavier et copiez l'un des dossiers (contenant le contenu) dans un autre dossier.
Analyse:

1. Créez le dossier d'origine dans le dossier cible
2. Obtenez tous les fichiers et dossiers dans le dossier d'origine et stockez-les dans le tableau de fichiers
3. Traversez le tableau
4. S'il s'agit d'un fichier, utilisez io stream pour lire et écrire
5. S'il s'agit d'un dossier, appelez-le récursivement

public class Demo4_Test {
    
    

	public static void main(String[] args) throws IOException {
    
    
		File src =getFile();
		File desc =getFile();
		if (src.equals(desc)) {
    
    
			System.out.println("目标文件夹是原文件夹的子文件夹");
		}else {
    
    
			copy(src,desc);
		}
		
 
	}
	//把其中一个文件夹中（包含内容）拷贝到另一个文件夹中
	//返回值类型void
	//参数列表File src，File desc
	public  static void copy(File src, File desc) throws IOException {
    
    
	//在目标文件夹中创建原文件夹
		File newDir =new File(desc,src.getName());
		newDir.mkdir();
		//获取原文件夹中所有的文件和文件夹，存储在File数组中
		File[] subFiles =src.listFiles();
		for (File subFile : subFiles) {
    
    
			//如果是文件用io读写
			if (subFile.isFile()) {
    
    
				BufferedInputStream bis =new BufferedInputStream(new FileInputStream(subFile));
				BufferedOutputStream bos =
						new BufferedOutputStream(new FileOutputStream(new File(newDir,subFile.getName())));
				int b;
				while ((b=bis.read())!=-1) {
    
    
					bos.write(b);
				}
				bis.close();
				bos.close();
			}else {
    
    
				copy(subFile, newDir);
			}
			
		}
	}
	public static File getFile() {
    
    
		Scanner scanner =new Scanner(System.in);
		System.out.println("请输入一个文件路径");
		while (true) {
    
    
			String line =scanner.nextLine();
			File dir =new File(line);
			if (!dir.exists()) {
    
    
				System.out.println("文件路径不存在");
			}
			else if (dir.isFile()) {
    
    
				System.out.println("这是文件夹路径，请输入文件路径");
			}else {
    
    
				return dir;
			}
		}
	}
}

Exercices récursifs (5)

Condition: imprimer par niveau, recevoir un chemin de dossier depuis le clavier, imprimer tous les fichiers du dossier et le nom du dossier par niveau, par exemple:
aaa est un dossier, il y a bbb.txt, ccc.txt, ddd.txt dedans Ces fichiers, il y a des dossiers comme eee, fff.txt et ggg.txt dans eee, imprimez la hiérarchie

Analyse:
1. Obtenez tous les fichiers et dossiers, ainsi que le tableau de fichiers renvoyé
2. Traversez la matrice
3. Qu'il s'agisse d'un fichier ou d'un dossier, il doit être imprimé directement
4. S'il s'agit d'un dossier, appelez récursivement

public class Demo5_Test {
    
    

	public static void main(String[] args) {
    
    
		File dir =getFile();
		printLev(dir,0);

	} 
	public static void printLev(File dir ,int level) {
    
    
		//把文件夹中的文件和文件夹放入File数组中
		File[] subFiles =dir.listFiles();
		for (File subFile : subFiles) {
    
    
			for (int i = 0; i <=level; i++) {
    
    
				System.out.print("\t");
			}
			//不论是文件还是文件夹，都需要直接打印
			System.out.println(subFile);
			//如果是文件夹，递归调用
			if (subFile.isDirectory()) {
    
    
				printLev(subFile,level+1);
				//改变level++或者++level结果均不同
			}
		}
		
	}
	public static File getFile(){
    
    
		Scanner scanner =new Scanner(System.in);
		System.out.println("请输入一个文件路径");
		while (true) {
    
    
			String line =scanner.nextLine();
			File dir =new File(line);
			if (!dir.exists()) {
    
    
				System.out.println("输入的文件路径不存在");
			}else if (dir.isFile()) {
    
    
				System.out.println("请输入一个文件路径");
			}else {
    
    
				return dir;
			}
		}
	}
}

Lorsque vous envisagez ce type de problème, vous devez tenir compte du problème d'empilement

Exercices récursifs (6)

Condition: séquence de Fibonacci
La signification de la séquence de nombres est que la somme des deux éléments précédents est égale à l'élément courant. an = an + 1 + an-2

public static int fun(int num) {
    
    
		if (num ==1 || num==2) {
    
    
			return 1;
		}else {
    
    
			return fun(num-2)+fun(num-1);
		}
	}
}

Bague Joseph

Demande: recherche de numéros porte-bonheur

public class Demo8_Test {
    
    
public static void main(String[] args) {
    
    
	System.out.println(getLucklyNum(8));
}
public static int getLucklyNum(int num) {
    
    
	ArrayList<Integer> list =new ArrayList<Integer>();		//创建集合存储1到num的对象
	for (int i = 0; i < num; i++) {
    
    
		list.add(i);
	}
	int count =1;		//用于数数，只要是3的倍数就循环
	for (int i = 0;list.size()!=1; i++) {
    
    	//只要集合中人数超过1，就不断地删除
		if (i == list.size()) {
    
    
			i=0;							//重新归零
		}
		if (count%3==0) {
    
    					//如果是3的倍数就删除
			list.remove(i--);
		}
		count++;
	}
	return list.get(0);
}

}