[JAVA] Ich habe etwas versucht, das als rekursive Suche bezeichnet wird

ich habe es gemacht

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)) {
			//Rekursive Suche, wenn der Eingabewert OK ist
			search(path, word);
		}
		
		System.out.println("Ende");
	}
	
	/**
	 *Durchsuchen Sie das Verzeichnis nach Zeichenfolgen.
	 * <p>
	 *Während der Ausgabe des absoluten Pfads der Datei und des Verzeichnisses mit dem Namen einschließlich der Suchzeichenfolge
	 *Rekursiv suchen.
	 * 
	 * @param dir Suchzielverzeichnis
	 * @Parameterwort Suchzeichenfolge
	 * @löst IOException aus Wenn sich etwas nicht öffnet
	 */
	private static void search(String dir, String word) {
		
		//Holen Sie sich die Liste in das Verzeichnis
		File[] directory = new File(dir).listFiles();
		
		//Wenn das Objekt nicht existiert,Verarbeitung beenden
		if (directory == null) {
			return;
		}
		
		//Gibt den absoluten Pfad für diejenigen aus, die Suchwörter enthalten
		Arrays.stream(directory).map(File::getName).filter(file -> isMatch(file, word))
				.forEach(file -> System.out.println(dir + "\\" + file));
		
		//Rekursive Suche in Verzeichnissen
		Arrays.stream(directory).filter(File::isDirectory).map(File::getPath)
				.forEach(nextPath -> search(nextPath, word));
	}
	
	/**
	 *Wortsuche.
	 * <p>
	 *Trennen Sie die zu durchsuchenden Zeichen durch ein Leerzeichen,ODER suchen.
	 * <p>
	 *Wenn der Dateiname eines der Wörter enthält{@code ture}
	 * 
	 * @Param-Datei Dateiname
	 * @param word Das zu suchende Wort
	 * @Wenn Sie die Rückgabe einschließen{@code true}
	 */
	private static boolean isMatch(String file, String word) {
		
		List<String> stock = new LinkedList<>();
		
		//Durch Leerzeichen getrennt
		for (String e : word.split(" ")) {
			// \\Getrennt durch
			for (String e2 : e.split("\\\\")) {
				stock.add(e2);
			}
		}
		
		//True, wenn es eine Zeichenfolge enthält
		return stock.stream().map(String::trim).anyMatch(spell -> file.contains(spell));
	}

	/**
	 *Überprüfen Sie, ob keine Leerzeichen vorhanden sind.
	 * <ul>
	 *Überprüfen Sie den Inhalt
	 * <li>Das Argument ist{@code null}Für ein Array von{@code false}
	 * <li>Wenn für alle Elemente des Arguments Folgendes erfüllt ist{@code true}
	 * <ul>
	 * <li>{@code null}Nicht
	 * <li>{@code String}Beim Konvertieren nicht leer
	 * <li>{@code String}Bei der Konvertierung kein leeres Zeichen
	 * </ul>
	 *Wenn auch nur einer erwischt wird{@code false}
	 * </ul>
	 * 
	 * @param obj {@code null}Objektarray, das erlaubt
	 * @Verfügbarkeit prüfen
	 */
	private static boolean validate(Object...obj) {
		return obj == null ? false
				: Arrays.stream(obj)
						.filter(Objects::nonNull)
						.map(Object::toString)
						.filter(nonEmpty)
						.filter(nonBlank)
						//Richtig, wenn alles in Ordnung ist
						.count() == obj.length ? true : false;
	}
	
	/**Richtig, wenn nicht leer*/
	private static final Predicate<String> nonEmpty = str -> !str.equals("");
	
	/**Richtig, wenn nicht nur leer*/
	private static final Predicate<String> nonBlank = v -> v != null && !v.equals("")
			&& Arrays.stream(v.split("")).anyMatch(x -> !x.equals(" ") && !x.equals("　"));
}

Es ist billig, dass die Ausgabe eine Konsole ist ODER suchen Sie nach mehreren Wörtern, die durch Leerzeichen getrennt sind Nun, der Suchvorgang ist auch ein wenig angemessen, also tauchen Sie bitte nicht in die isMatch-Methode ein. .. Es war in Ordnung, nur "String.contains" zu verwenden, aber ich frage mich, ob es notwendig ist, verschiedene Dinge wie Websysteme zu entwickeln.

Der "Validierungs" -Teil ist ebenfalls an diesen Prozess angepasst, sodass er möglicherweise nicht als vielseitig bezeichnet wird.

Also das Hauptthema

search.java

	/**
	 *Durchsuchen Sie das Verzeichnis nach Zeichenfolgen.
	 * <p>
	 *Während der Ausgabe des absoluten Pfads der Datei und des Verzeichnisses mit dem Namen einschließlich der Suchzeichenfolge
	 *Rekursiv suchen.
	 * 
	 * @param dir Suchzielverzeichnis
	 * @Parameterwort Suchzeichenfolge
	 */
	private static void search(String dir, String word) {
		
		//Holen Sie sich die Liste in das Verzeichnis
		File[] directory = new File(dir).listFiles();
		
		//Wenn das Objekt nicht existiert,Verarbeitung beenden
		if (directory == null) {
			return;
		}
		
		//Gibt den absoluten Pfad für diejenigen aus, die Suchwörter enthalten
		Arrays.stream(directory).map(File::getName).filter(file -> isMatch(file, word))
				.forEach(file -> System.out.println(dir + "\\" + file));
		
		//Rekursive Suche in Verzeichnissen
		Arrays.stream(directory).filter(File::isDirectory).map(File::getPath)
				.forEach(nextPath -> search(nextPath, word));
	}

Dies ist interessant für die rekursive Suche

Suchen Sie die im Verzeichnis aus der Liste Holen Sie sich den Weg Machen Sie dasselbe noch einmal als Argument

Wenn sich in der Mitte keine return-Anweisung befindet, handelt es sich um eine Endlosschleife. Ist es eine while-Anweisung, die while nicht verwendet?

Sich selbst anzurufen ist wirklich interessant!