it-swarm.com.de

Java - Suche nach Dateien in einem Verzeichnis

Das soll einfach sein, aber ich kann es nicht verstehen - "Schreiben Sie ein Programm, das in einem bestimmten Verzeichnis nach einem bestimmten Dateinamen sucht." Ich habe ein paar Beispiele für einen hartcodierten Dateinamen und ein Verzeichnis gefunden, aber ich muss sowohl das Verzeichnis als auch den Dateinamen so eingeben, wie er vom Benutzer eingegeben wurde.

public static void main(String[] args) {
    String fileName = args[0]; // For the filename declaration
    String directory;     
    boolean found;

    File dir = new File(directory);

    File[] matchingFiles = dir.listFiles(new FilenameFilter() {
        public boolean accept(File dir, String fileName) {
            return true;
        }
    });

}
10
A C

sie können so etwas versuchen:

import Java.io.*;
import Java.util.*;
class FindFile 
{
    public void findFile(String name,File file)
    {
        File[] list = file.listFiles();
        if(list!=null)
        for (File fil : list)
        {
            if (fil.isDirectory())
            {
                findFile(name,fil);
            }
            else if (name.equalsIgnoreCase(fil.getName()))
            {
                System.out.println(fil.getParentFile());
            }
        }
    }
    public static void main(String[] args) 
    {
        FindFile ff = new FindFile();
        Scanner scan = new Scanner(System.in);
        System.out.println("Enter the file to be searched.. " );
        String name = scan.next();
        System.out.println("Enter the directory where to search ");
        String directory = scan.next();
        ff.findFile(name,new File(directory));
    }
}

Hier ist die Ausgabe:

J:\Java\misc\load>Java FindFile
Enter the file to be searched..
FindFile.Java
Enter the directory where to search
j:\Java\
FindFile.Java Found in->j:\Java\misc\load
25
Vishal K

Mit ** Java 8 * gibt es eine Alternative, die Streams und Lambdas verwendet:

public static void recursiveFind(Path path, Consumer<Path> c) {
  try (DirectoryStream<Path> newDirectoryStream = Files.newDirectoryStream(path)) {
    StreamSupport.stream(newDirectoryStream.spliterator(), false)
                 .peek(p -> {
                   c.accept(p);
                   if (p.toFile()
                        .isDirectory()) {
                     recursiveFind(p, c);
                   }
                 })
                 .collect(Collectors.toList());
  } catch (IOException e) {
    e.printStackTrace();
  }
}

So werden alle Dateien rekursiv gedruckt:

recursiveFind(Paths.get("."), System.out::println);

Und dies wird nach einer Datei suchen:

recursiveFind(Paths.get("."), p -> { 
  if (p.toFile().getName().toString().equals("src")) {
    System.out.println(p);
  }
});
1
freedev

Das sieht nach einer Hausaufgabenfrage aus, also gebe ich Ihnen nur ein paar Hinweise:

Versuchen Sie, gute eindeutige Variablennamen anzugeben. Hier haben Sie zuerst "fileName" für das Verzeichnis und dann für die Datei verwendet. Das ist verwirrend und wird Ihnen nicht helfen, das Problem zu lösen. Verwenden Sie unterschiedliche Namen für verschiedene Dinge.

Sie verwenden keinen Scanner für irgendetwas, und er wird hier nicht benötigt. Beseitigen Sie ihn.

Darüber hinaus sollte die Accept-Methode einen booleschen Wert zurückgeben. Sie versuchen gerade, einen String zurückzugeben. Boolean bedeutet, dass entweder true oder false zurückgegeben werden soll. Zum Beispiel kann return a > 0; je nach dem Wert von a wahr oder falsch zurückgeben. return fileName; gibt jedoch nur den Wert von fileName zurück, der ein String ist.

1
amarillion

Wenn Sie einen dynamischen Dateinamenfilter verwenden möchten, können Sie FilenameFilter implementieren und im Konstruktor den dynamischen Namen übergeben.

Natürlich bedeutet dies, dass Sie jedes Mal die Klasse instanziieren müssen (Overhead), aber es funktioniert

Beispiel: 

public class DynamicFileNameFilter implements FilenameFilter {

    private String comparingname;

    public DynamicFileNameFilter(String comparingName){
        this.comparingname = comparingName;
    }

    @Override
    public boolean accept(File dir, String name) {
        File file = new File(name);

        if (name.equals(comparingname) && !file.isDirectory())
            return false;

        else
            return true;
    }

}

dann benutzt du wo du brauchst:

FilenameFilter fileNameFilter = new DynamicFileNameFilter("thedynamicNameorpatternYouAreSearchinfor");
File[] matchingFiles = dir.listFiles(fileNameFilter);
1
Juan

Der folgende Code hilft bei der Suche nach einer Datei im Verzeichnis und beim Öffnen des Verzeichnisses

import Java.io.*;
import Java.util.*;
import Java.awt.Desktop;
public class Filesearch2 {


    public static void main(String[] args)throws IOException {        
        Filesearch2 fs = new Filesearch2();
        Scanner scan = new Scanner(System.in);
        System.out.println("Enter the file to be searched.. " );
        String name = scan.next();
        System.out.println("Enter the directory where to search ");
        String directory = scan.next();
        fs.findFile(name,new File(directory));
    }
    public void findFile(String name,File file1)throws IOException
    {      
        File[] list = file1.listFiles();       
        if(list!=null)  
     {                          
        for(File file2 : list)
        {            
            if (file2.isDirectory())
            {
                findFile(name,file2);             
            }
            else if (name.equalsIgnoreCase(file2.getName()))
            {                                                              
                System.out.println("Found");                
                System.out.println("File found at : "+file2.getParentFile());
                System.out.println("Path diectory: "+file2.getAbsolutePath());
                String p1 = ""+file2.getParentFile();
                File f2 = new File(p1);
                Desktop.getDesktop().open(f2);                               
            }                      
        }        
      }
    }        
}
0
Mr. J

Ich habe einen anderen Ansatz verwendet, um mit Hilfe von stack nach einer Datei zu suchen. Dabei ist zu berücksichtigen, dass sich Ordner in einem Ordner befinden können. Es ist zwar nicht schneller als die Windows-Suche (und ich hatte das nicht erwartet), aber es gibt definitiv ein korrektes Ergebnis. Bitte ändern Sie den Code wie gewünscht. Dieser Code wurde ursprünglich erstellt, um den Dateipfad einer bestimmten Dateierweiterung zu extrahieren :). Fühlen Sie sich frei zu optimieren.

import Java.io.File;
import Java.io.IOException;
import Java.util.ArrayList;
import Java.util.List;

/**
 * @author Deepankar Sinha
 */
public class GetList {
    public List<String> stack;
    static List<String> lnkFile;
    static List<String> progName;

    int index=-1;
    public static void main(String args[]) throws IOException
    {

        //var-- progFile:Location of the file to be search. 
        String progFile="C:\\";
        GetList obj=new GetList();
        String temp=progFile;
        int i;
        while(!"&%@#".equals(temp))
        {
            File dir=new File(temp);
            String[] directory=dir.list();
            if(directory!=null){
            for(String name: directory)
            {
                if(new File(temp+name).isDirectory())
                    obj.Push(temp+name+"\\");
                else
                    if(new File(temp+name).isFile())
                    {
                        try{
                            //".exe can be replaced with file name to be searched. Just exclude name.substring()... you know what to do.:)
                        if(".exe".equals(name.substring(name.lastIndexOf('.'), name.length())))
                        {
                            //obj.addFile(temp+name,name);
                            System.out.println(temp+name);
                        }
                        }catch(StringIndexOutOfBoundsException e)
                        {
                            //debug purpose
                            System.out.println("ERROR******"+temp+name);
                        }

                    }
            }}
            temp=obj.pop();
        }
        obj.display();

//        for(int i=0;i<directory.length;i++)
//        System.out.println(directory[i]);
    }

    public GetList() {
        this.stack = new ArrayList<>();
        this.lnkFile=new ArrayList<>();
        this.progName=new ArrayList<>();
    }
    public void Push(String dir)
    {
        index++;
        //System.out.println("Push : "+dir+" "+index);
        this.stack.add(index,dir);

    }
    public String pop()
    {
        String dir="";
        if(index==-1)
            return "&%@#";
        else
        {
            dir=this.stack.get(index);
            //System.out.println("POP : "+dir+" "+index);
            index--;

        }
        return dir;
    }

    public void addFile(String name,String name2)
    {
        lnkFile.add(name);
        progName.add(name2);
    }

    public void display()
    {
        GetList.lnkFile.stream().forEach((lnkFile1) -> {
            System.out.println(lnkFile1);
        });
    }

}
0
Deepankar Sinha
public class searchingFile 
{
     static String path;//defining(not initializing) these variables outside main 
     static String filename;//so that recursive function can access them
     static int counter=0;//adding static so that can be accessed by static methods 

    public static void main(String[] args) //main methods begins
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the path : ");
        path=sc.nextLine(); //storing path in path variable
        System.out.println("Enter file name : ");
        filename=sc.nextLine(); //storing filename in filename variable
        searchfile(path);//calling our recursive function and passing path as argument
        System.out.println("Number of locations file found at : "+counter);//Printing occurences

    }

    public static String searchfile(String path)//declaring recursive function having return 
                                                //type and argument both strings

    {
        File file=new File(path);//denoting the path
        File[] filelist=file.listFiles();//storing all the files and directories in array

    for (int i = 0; i < filelist.length; i++) //for loop for accessing all resources
    {
        if(filelist[i].getName().equals(filename))//if loop is true if resource name=filename
        {
            System.out.println("File is present at : "+filelist[i].getAbsolutePath());
            //if loop is true,this will print it's location
            counter++;//counter increments if file found
        }
        if(filelist[i].isDirectory())// if resource is a directory,we want to inside that folder
        {
            path=filelist[i].getAbsolutePath();//this is the path of the subfolder
            searchfile(path);//this path is again passed into the searchfile function 
                             //and this countinues untill we reach a file which has
                             //no sub directories

        }
    }
    return path;// returning path variable as it is the return type and also 
                // because function needs path as argument.

    }   
}
0
Shruti Mohan

Mithilfe von Java 8+ -Funktionen können Sie den Code in wenigen Zeilen schreiben:

protected static Collection<Path> find(String fileName, String searchDirectory) throws IOException {
    try (Stream<Path> files = Files.walk(Paths.get(searchDirectory))) {
        return files
                .filter(f -> f.getFileName().toString().equals(fileName))
                .collect(Collectors.toList());

    }
}

Files.walk gibt einen Stream<Path> zurück, der die angegebene searchDirectory "durch den Dateibaum verwurzelt" ist. Um die gewünschten Dateien auszuwählen, wird nur ein Filter auf die Streamfiles angewendet. Es vergleicht den Dateinamen einer Path mit der angegebenen fileName.

Beachten Sie, dass die documentation von Files.walk erforderlich ist

Diese Methode muss in einer try-with-resources-Anweisung oder .__ verwendet werden. eine ähnliche Kontrollstruktur, um sicherzustellen, dass die offenen Verzeichnisse des Streams werden unmittelbar nach Abschluss der Stream-Vorgänge geschlossen.

Ich verwende die try-resource-Anweisung .


Für erweiterte Suchvorgänge können Sie alternativ eine PathMatcher verwenden:

protected static Collection<Path> find(String searchDirectory, PathMatcher matcher) throws IOException {
    try (Stream<Path> files = Files.walk(Paths.get(searchDirectory))) {
        return files
                .filter(matcher::matches)
                .collect(Collectors.toList());

    }
}

Ein Beispiel, wie man eine bestimmte Datei findet:

public static void main(String[] args) throws IOException {
    String searchDirectory = args[0];
    String fileName = args[1];
    PathMatcher matcher = FileSystems.getDefault().getPathMatcher("regex:.*" + fileName);
    Collection<Path> find = find(searchDirectory, matcher);
    System.out.println(find);
}

Mehr dazu: Oracle Tutorial für das Finden von Dateien

0
LuCio

Diese Methode durchsucht rekursiv durch jedes Verzeichnis, beginnend am Stamm, bis der Dateiname gefunden wird oder alle verbleibenden Ergebnisse auf Null zurückkehren.

public static String searchDirForFile(String dir, String fileName) {
    File[] files = new File(dir).listFiles();
    for(File f:files) {
        if(f.isDirectory()) {
            String loc = searchDirForFile(f.getPath(), fileName);
            if(loc != null)
                return loc;
        }
        if(f.getName().equals(fileName))
            return f.getPath();
    }
    return null;
}
0
Kushroom