Java-在目录中搜索文件
这应该很简单，但我无法理解——“编写一个程序，搜索给定目录中的特定文件名。”我找到了一些硬编码文件名和目录的示例，但我需要用户输入的目录和文件名Java-在目录中搜索文件,java,file,search,directory,Java,File,Search,Directory,这应该很简单，但我无法理解——“编写一个程序，搜索给定目录中的特定文件名。”我找到了一些硬编码文件名和目录的示例，但我需要用户输入的目录和文件名 public static void main(String[] args) { String fileName = args[0]; // For the filename declaration String directory; boolean found; File dir = new File(di
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;
}
});
}
这看起来像是一个家庭作业问题，所以我只给你一些建议： 尽量给出好的、有区别的变量名。在这里，您首先对目录使用“fileName”，然后对文件使用“fileName”。这是令人困惑的，并不能帮助您解决问题。对不同的事物使用不同的名称 你没有用扫描仪做任何事情，这里也不需要，把它扔掉
此外，accept方法应该返回一个布尔值。现在，您正在尝试返回一个字符串。布尔值意味着它应该返回true或false。例如
返回a>0返回文件名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));
}
}
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
如果要使用动态文件名筛选器，可以实现FilenameFilter并将动态名称传递给构造函数 当然，这意味着每次创建类时都必须实例化（开销），但它是有效的 例如：
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;
}
}
FilenameFilter fileNameFilter = new DynamicFileNameFilter("thedynamicNameorpatternYouAreSearchinfor");
File[] matchingFiles = dir.listFiles(fileNameFilter);
我使用了另一种方法来使用堆栈搜索文件。。请记住，文件夹中可能有文件夹。虽然它并不比windows search快（我也没料到），但它确实给出了正确的结果。请根据需要修改代码。此代码最初用于提取特定文件扩展名的文件路径：）。请随意优化
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);
});
}
}
导入java.io.File；
导入java.io.IOException；
导入java.util.ArrayList；
导入java.util.List；
/**
*@作者Deepankar Sinha
*/
公共类GetList{
公共列表栈；
静态列表文件；
静态列表名称；
int指数=-1；
公共静态void main（字符串args[]）引发IOException
{
//var--progFile：要搜索的文件的位置。
String progFile=“C:\\”；
GetList obj=新建GetList（）；
字符串temp=progFile；
int i；
而（！”&%@#“.等于（临时））
{
文件目录=新文件（临时文件）；
String[]directory=dir.list（）；
if（目录！=null）{
for（字符串名称：目录）
{
if（新文件（temp+name）.isDirectory（））
对象推送（临时+名称+“\\”）；
其他的
if（新文件（temp+name）.isFile（））
{
试一试{
//“.exe可以替换为要搜索的文件名。只需排除name.substring（）…您知道该怎么做。：）
如果（“.exe”.equals（name.substring（name.lastIndexOf（“.”），name.length（）））
{
//obj.addFile（临时+名称，名称）；
系统输出打印项次（临时+名称）；
}
}捕捉（StringIndexOutOfBoundsException e）
{
//调试目的
System.out.println（“错误*******”+临时+名称）；
}
}
}}
temp=obj.pop（）；
}
obj.display（）；
//对于（int i=0；i{
系统输出打印LN（lnkFile1）；
});
}
}
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);
}
}
}
}
}
对于**Java 8*有一种使用流和lambda的替代方案：
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();
}
}
recursiveFind(Paths.get("."), p -> {
if (p.toFile().getName().toString().equals("src")) {
System.out.println(p);
}
});
此方法将从根目录开始递归搜索每个目录，直到找到文件名，或者所有剩余结果返回空
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;
}
使用Java 8+功能，我们可以用几行代码编写代码：
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());
}
}
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);
}
publicstaticvoidmain（字符串[]args）引发IOException{
字符串searchDirectory=args[0]；
字符串文件名=args[1]；
PathMatcher matcher=FileSystems.getDefault（）.getPathMatcher（“regex:.*”+文件名）；
Collection find=find（searchDirectory，matcher）；
System.out.println（find）；
}
公共类搜索文件
{
静态字符串路径；//在main外部定义（而不是初始化）这些变量
静态字符串filename；//以便递归函数可以访问它们
static int counter=0；//添加static以便可以通过静态方法访问
publicstaticvoidmain（String[]args）//main方法开始
{
扫描仪sc=新的扫描仪（System.in）；
System.out.println（“输入路径：”）；
path=sc.nextLine（）；//将路径存储在path变量中
System.out.println（“输入文件名：”）；
filename=sc.nextLine（）；//将文件名存储在filename变量中
searchfile（path）；//调用递归函数并将路径作为参数传递
System.out.println（“在：“+计数器”处找到的文件位置数）；//打印次数
}
公共静态字符串searchfile（字符串路径）//声明具有返回的递归函数
//类型和参数都是字符串
{
File File=新文件（路径）；//表示路径
File[]filelist=File.listFiles（）；//存储数组中的所有文件和目录
for（int i=0；iprotected 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());
}
}
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);
}
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.
}
}
public static void main( String args[]){
final String dir2 = System.getProperty("user.name"); \\get user name
String path = "C:\\Users\\" + dir2;
digFile(new File(path)); \\ path is file start to dig
for (int i = 0; i < StringFile.size(); i++) {
System.out.println(StringFile.get(i));
}
}
private void digFile(File dir) {
FilenameFilter filter = new FilenameFilter() {
public boolean accept(File dir, String name) {
return name.endsWith(".mp4");
}
};
String[] children = dir.list(filter);
if (children == null) {
return;
} else {
for (int i = 0; i < children.length; i++) {
StringFile.add(dir+"\\"+children[i]);
}
}
File[] directories;
directories = dir.listFiles(new FileFilter() {
@Override
public boolean accept(File file) {
return file.isDirectory();
}
public boolean accept(File dir, String name) {
return !name.endsWith(".mp4");
}
});
if(directories!=null)
{
for (File directory : directories) {
digFile(directory);
}
}
}