文件搜索与关键字匹配-优快云博客

本文链接：https://blog.youkuaiyun.com/handawei_5/article/details/83733297

本文介绍两种基于多线程的文件搜索与关键字匹配方案。第一种利用阻塞队列实现文件列表分配，多个线程并发读取并检查文件是否包含指定关键字。第二种采用递归方式，将文件树结构分解为子任务进行并行处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

首先2个思维：

第一个是：借助阻塞列表,有一个线程把一个文件夹下的所有文件放入列表。

然后是100个线程，循环不断的从列表中取出文件，检查这个文件是否有关键字，有就计数加一，直到列表为空，返回这个线程的计数。整体来说就读取就一百个线程，不断检查。

第二个是：用到递归，一个callable线程，传入一个文件，如果这个文件是个目录，则把它目录下的每个文件传入这个定义的callable线程，如果是个文件则搜索关键字，最后返回这个线程的计数（目录则返回目录下的所有计数和，文件就返回这个文件的计数），感觉是树形的结构。

贴代码：

第一个：

package v1ch14.FutureTest;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * @version 2010-10-18 上午09:34:18
 * @author DaWei han
 * @EMAIL  handawei_1@126.com
 */
public class MyFutureTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		System.out.print("Enter the directory eg. D:\\Java\\jdk1.6\\src:");
	    String directory=in.nextLine();
	    System.out.println("Enter the key word eg. volatile:");
	    String keyword=in.nextLine();
	    System.out.println("finished the input.");
	    final int NUMBER_QUEUE_SIZE=10;
	    final int NUMBER_SEARCH=100;
	    
	    
	    
	    BlockingQueue<File> queue=new ArrayBlockingQueue<File>(NUMBER_QUEUE_SIZE);
	    new Thread(new FileEnumerationTask(queue,new File(directory))).start();
	    List<FutureTask<Integer>> rsList=new ArrayList<FutureTask<Integer>>();
	    
	    for(int i=0;i<NUMBER_SEARCH;i++)
	    {
	      	FutureTask<Integer> task=new FutureTask<Integer>(new SerachTack(queue,keyword));
	    	rsList.add(task);
	      	new Thread(task).start();
	      
	    }
	    int num=0;
	    for(FutureTask<Integer> taskTwo:rsList)
	    {
	    	try {
	    		System.out.println("the num is:"+num);
				num+=taskTwo.get();
				System.out.println("the num is:"+num);
				System.out.println("========================================>");
			} catch (Exception e) {
				e.printStackTrace();
			} 
	    }
	    System.out.println("the total num is :"+num);
	}
}

class SerachTack implements Callable<Integer>
{
	public SerachTack(BlockingQueue<File> queue,String keyword)
	{
		this.queue=queue;
		this.keyword=keyword;
	}
	public Integer call() throws Exception {
		rsNum=0;
        
        boolean done=false;
        
        while(!done)
        {
        	File file=queue.take();
        	if(file==FileEnumerationTask.DUMM)
        	{
        		done =true;
        		queue.put(file);
        	}else{
        		rsNum+=searchKey(file,keyword);
        	}
        }
		return rsNum;
	}
	private int searchKey(File file,String keyword)
	{
		//此为每行要是有关键字，就加1
//		int num=0;
//		try {
//			Scanner in=new Scanner(new FileInputStream(file));
//			while(in.hasNextLine())
//			{
//				if(in.nextLine().contentEquals(keyword)){
//					num++;
//				};
//			}
//		}catch (FileNotFoundException e) {
//			e.printStackTrace();
//		}
//	  return num;
	//=======>此为一个文件要是有关键字 就返回1 @1
		try {
			Scanner in=new Scanner(new FileInputStream(file));
			while(in.hasNextLine())
			{
				if(in.nextLine().contains(keyword)){
					System.out.println("matched in the file:"+file.getPath());
					return 1;
				};
			}
		}catch(FileNotFoundException e) {
			e.printStackTrace();
		}
		return 0; 
  //<====================
	}

	private Integer rsNum;
	private BlockingQueue<File> queue;
	private String keyword;
}

class FileEnumerationTask implements Runnable
{
	public FileEnumerationTask(BlockingQueue<File> queue,File directory)
	{
		this.queue=queue;
		this.directory=directory;
	}
	public void run() {
		try {
		    searchFile(this.directory);
			queue.put(DUMM);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	public void searchFile(File directory)
	{
		try {
		File[] files=directory.listFiles();
		for(File file:files)
		{
			if(file.isDirectory())searchFile(file);
			else
			queue.put(file);
		}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	public static File DUMM=new File("");
	private File directory;
	private BlockingQueue<File> queue;
}

第二个：

package v1ch14.FutureTest;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * @version 2010-10-18 下午02:36:52
 * @author DaWei han
 * @EMAIL  handawei_1@126.com
 */
public class MyFutureTest2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		System.out.print("Enter the directory eg. D:\\Java\\jdk1.6\\src:");
	    String directory=in.nextLine();
	    System.out.println("Enter the key word eg. volatile:");
	    String keyword=in.nextLine();
	    System.out.println("finished the input.");
	    FutureTask<Integer> task=new FutureTask<Integer>(new MyMatchCounter(new File(directory), keyword));
	    new Thread(task).start();
	    try {
			System.out.println("the Toatl num is:"+task.get());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
class MyMatchCounter implements Callable<Integer>
{	
   public MyMatchCounter(File directory,String keyword)
   {
	   this.directory=directory;
	   this.keyword=keyword;
   }
   
	public Integer call() throws Exception {
       int num=0;
		List<FutureTask<Integer>> rsList=new ArrayList<FutureTask<Integer>>();
		if(directory.isDirectory())
        {
			File[] files=directory.listFiles();
			for(File file:files)
			{
				MyMatchCounter counter=new MyMatchCounter(file,this.keyword);
				FutureTask<Integer> task=new FutureTask<Integer>(counter);
				rsList.add(task);
			   new Thread(task).start();	
			}
        	
        }else{
         num=search(directory);	
        }
		for(FutureTask<Integer> taskTwo:rsList)
		{
			num+=taskTwo.get();
		}
		return num;
	}
	
  public Integer search(File file)
  {
	  try {
		Scanner in=new Scanner(new FileInputStream(file));
        while(in.hasNextLine())
        {
        	if(in.nextLine().contains(this.keyword))
        	{
        		System.out.println(" Match the keyword in file:"+file.getPath());
                return 1;        		
        	}
        }
	  } catch (FileNotFoundException e) {
		e.printStackTrace();
	}
	return 0;  
  }
private File directory;
private String keyword;
}

下面是用线程池改写第二个：

package v1ch14.ThreadPoolTest;

import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @version 2010-10-18 下午04:04:31
 * @author DaWei han
 * @EMAIL  handawei_1@126.com
 */
public class MyThreadPoolTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		System.out.print("Enter the directory eg. D:\\Java\\jdk1.6\\src:");
	    String directory=in.nextLine();
	    System.out.print("Enter the key word eg. volatile:");
	    String keyword=in.nextLine();
	    System.out.print("finished the input.");

		ExecutorService pool=Executors.newCachedThreadPool();
		MyMatchCounter counter=new MyMatchCounter(new File(directory),keyword,pool);
        Future<Integer> result= pool.submit(counter);	
		
        try {
			System.out.println("the total number is :"+result.get());
		}catch (Exception e) {
			e.printStackTrace();
		} 
		pool.shutdown();
	}
	

}
class MyMatchCounter implements Callable<Integer>
{
	public MyMatchCounter(File direcotry,String keyword,ExecutorService pool)
	{
		this.directory=direcotry;
		this.keyword=keyword;
		this.pool=pool;
	}
	public Integer call() throws Exception {
         int num=0;
         ArrayList<Future<Integer>> results = new ArrayList<Future<Integer>>();
		File[] files=directory.listFiles();
		for(File file:files)
		{
			if(file.isDirectory())
			{
				results.add(pool.submit(new MyMatchCounter(file, keyword, pool)));
			}else
			{
			   num+=searchFile(file);	
			}
		}
		for(Future<Integer> rs:results)
		{
			num+=rs.get();
		}
		return num;
	}
private Integer searchFile(File file)
{
	
	Scanner in=null;
      try {
    	  in= new Scanner(new FileInputStream(file));
		while(in.hasNextLine())
		{
			if(in.nextLine().contains(this.keyword))
				return 1;
		}
	} catch (Exception e) {
		e.printStackTrace();
	}finally{
		in.close();
	}
	return 0;
}
 private File directory;
 private String keyword;
 private ExecutorService pool;
}

搜索文件中的关键字