[JAVA] J'ai essayé quelque chose qui s'appelle la recherche récursive

je l'ai fait

Search.java

package search;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;

public class Search {
	
	public static void main(String[] args) {
		
		String path = "C:\\Users\\";
		String word = "\\pool\\plugins\\";

		if (validate(path, word)) {
			//Recherche récursive lorsque la valeur d'entrée est OK
			search(path, word);
		}
		
		System.out.println("fin");
	}
	
	/**
	 *Rechercher le répertoire par chaîne de caractères.
	 * <p>
	 *Lors de la sortie du chemin absolu du fichier et du répertoire avec le nom comprenant la chaîne de recherche
	 *Rechercher récursivement.
	 * 
	 * @param dir Rechercher le répertoire cible
	 * @mot de paramètre Chaîne de recherche
	 * @jette IOException quand quelque chose ne s'ouvre pas
	 */
	private static void search(String dir, String word) {
		
		//Récupérez la liste dans l'annuaire
		File[] directory = new File(dir).listFiles();
		
		//Si l'objet n'existe pas,Terminer le traitement
		if (directory == null) {
			return;
		}
		
		//Affiche le chemin absolu pour ceux contenant des mots de recherche
		Arrays.stream(directory).map(File::getName).filter(file -> isMatch(file, word))
				.forEach(file -> System.out.println(dir + "\\" + file));
		
		//Recherche récursive d'annuaires
		Arrays.stream(directory).filter(File::isDirectory).map(File::getPath)
				.forEach(nextPath -> search(nextPath, word));
	}
	
	/**
	 *Recherche de mot.
	 * <p>
	 *Séparez les caractères à rechercher par un espace,OU rechercher.
	 * <p>
	 *Si le nom du fichier contient l'un des mots{@code ture}
	 * 
	 * @nom de fichier de fichier param
	 * @param word Le mot à rechercher
	 * @Si vous incluez le retour{@code true}
	 */
	private static boolean isMatch(String file, String word) {
		
		List<String> stock = new LinkedList<>();
		
		//Séparé par des caractères vides
		for (String e : word.split(" ")) {
			// \\Séparé par
			for (String e2 : e.split("\\\\")) {
				stock.add(e2);
			}
		}
		
		//Vrai s'il contient une chaîne
		return stock.stream().map(String::trim).anyMatch(spell -> file.contains(spell));
	}

	/**
	 *Vérifier les espaces vides.
	 * <ul>
	 *Vérifier le contenu
	 * <li>L'argument est{@code null}Pour un éventail de{@code false}
	 * <li>Si ce qui suit est satisfait pour tous les éléments de l'argument{@code true}
	 * <ul>
	 * <li>{@code null}ne pas
	 * <li>{@code String}Pas vide lors de la conversion
	 * <li>{@code String}Pas un caractère vide lors de la conversion
	 * </ul>
	 *Si même un se fait prendre{@code false}
	 * </ul>
	 * 
	 * @param obj {@code null}Tableau d'objets qui permet
	 * @retour vérifier la disponibilité
	 */
	private static boolean validate(Object...obj) {
		return obj == null ? false
				: Arrays.stream(obj)
						.filter(Objects::nonNull)
						.map(Object::toString)
						.filter(nonEmpty)
						.filter(nonBlank)
						//Vrai si tout va bien
						.count() == obj.length ? true : false;
	}
	
	/**Vrai sinon vide*/
	private static final Predicate<String> nonEmpty = str -> !str.equals("");
	
	/**Vrai si non seulement vide*/
	private static final Predicate<String> nonBlank = v -> v != null && !v.equals("")
			&& Arrays.stream(v.split("")).anyMatch(x -> !x.equals(" ") && !x.equals("　"));
}

C'est pas cher que la sortie soit une console OU recherchez plusieurs mots séparés par des blancs Eh bien, le processus de recherche est également un peu approprié, alors veuillez ne pas creuser dans la méthode ʻisMatch. .. C'était bien d'utiliser simplement String.contains`, mais je me demande s'il est nécessaire de concevoir diverses choses telles que des systèmes Web.

La partie «valider» est également adaptée à ce processus, on ne peut donc pas dire qu'elle est polyvalente.

Donc le sujet principal

search.java

	/**
	 *Rechercher le répertoire par chaîne de caractères.
	 * <p>
	 *Lors de la sortie du chemin absolu du fichier et du répertoire avec le nom comprenant la chaîne de recherche
	 *Rechercher récursivement.
	 * 
	 * @param dir Rechercher le répertoire cible
	 * @mot de paramètre Chaîne de recherche
	 */
	private static void search(String dir, String word) {
		
		//Récupérez la liste dans l'annuaire
		File[] directory = new File(dir).listFiles();
		
		//Si l'objet n'existe pas,Terminer le traitement
		if (directory == null) {
			return;
		}
		
		//Affiche le chemin absolu pour ceux contenant des mots de recherche
		Arrays.stream(directory).map(File::getName).filter(file -> isMatch(file, word))
				.forEach(file -> System.out.println(dir + "\\" + file));
		
		//Recherche récursive d'annuaires
		Arrays.stream(directory).filter(File::isDirectory).map(File::getPath)
				.forEach(nextPath -> search(nextPath, word));
	}

Ceci est intéressant pour la recherche récursive

Trouvez celui dans le répertoire dans la liste Obtenez le chemin Faites la même chose avec lui comme argument

S'il n'y a pas d'instruction return au milieu, ce sera une boucle infinie. Est-ce une déclaration while qui n'utilise pas while?

S'appeler est vraiment intéressant!