View difference between Paste ID: LYPm9At9 and df2GrPwA

 package task;
 
 import java.io.File;
 
 public interface Checker {
 	boolean check(File file);
 }
 ------------
 import java.io.BufferedReader;
 import java.io.File;
-import java.nio.file.Paths;
+
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.PrintStream;
 import java.nio.file.FileSystems;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
-import net.sf.jmimemagic.Magic;
+
-import net.sf.jmimemagic.MagicException;
+
-import net.sf.jmimemagic.MagicMatch;
+
-import net.sf.jmimemagic.MagicMatchNotFoundException;
+
-import net.sf.jmimemagic.MagicParseException;
+
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingQueue;
 
 import com.ibm.icu.text.CharsetDetector;
 
 public class FileScan implements Runnable {
 	private String whatFind;
 	private BlockingQueue<File> queue;
 	private CountDownLatch latch;
 	private File endOfWorkFile;
 
 	public FileScan(String whatFind, BlockingQueue<File> queue,
 			CountDownLatch latch, File endOfWorkFile) {
 		this.whatFind = whatFind;
 		this.queue = queue;
 		this.latch = latch;
 		this.endOfWorkFile = endOfWorkFile;
 	}
 
 	public FileScan() {
 	}
 
 	@Override
 	public void run() {
 
 		while (true) {
 			try {
 				File file;
 				file = queue.take();
 
 				if (file == endOfWorkFile) {
 					break;
 				}
 
 				scan(file);
 			} catch (InterruptedException e) {
 				e.printStackTrace();
 			}
 		}
 
 		latch.countDown();
 	}
 
 	private void scan(File file) {
 		Scanner scanner = null;
 		int matches = 0;
 
 		try {
 			scanner = new Scanner(file);
 		} catch (FileNotFoundException e) {
 			System.out.println("File Not Found.");
 			e.printStackTrace();
 		}
 
 		while (scanner.hasNext())
 			if (scanner.next().equals(whatFind)) {
 				matches++;
 			}
-			System.out.println(myStr);
+
 		if (matches > 0) {
 			String myStr = String.format(
 					"File: %s - and the number of matches " + "is: %d",
-	public void askUserPathAndWord() {
+
 			PrintStream ps = new PrintStream(System.out, true);
 			ps.println(myStr);
 		}
 	}
 
 	private void askUserPathAndWord() {
 		try {
 			tryToAskUserPathAndWord();
 		} catch (IOException | RuntimeException e) {
 			System.out.println("Wrong input!");
 			e.printStackTrace();
 		} catch (InterruptedException e) {
 			System.out.println("Interrupted.");
 			e.printStackTrace();
 		}
 	}
 
 	private void tryToAskUserPathAndWord() throws IOException,
 			InterruptedException {
 		PathAndWord pathAndWord = readPathAndWord();
 
 		if (pathAndWord.isProperlyInitialized()) {
 			performScan(pathAndWord, "GameOver.tmp");
 			System.out.println("Thank you!");
 		} else {
 			System.out.println("You did not enter anything");
 		}
 	}
 
 	private PathAndWord readPathAndWord() throws IOException {
 		System.out
 				.println("Please, enter a Path and Word (which you want to find):");
 
 		BufferedReader bufferedReader = new BufferedReader(
 				new InputStreamReader(System.in));
 
 		String path = readPath(bufferedReader);
 		String whatFind = readWord(bufferedReader);
 		return new PathAndWord(path, whatFind);
 	}
 
 	private String readPath(BufferedReader bufferedReader) throws IOException {
 		boolean ok = false;
 		File pathInput;
 
 		do {
 			System.out.println("Please enter a Path:");
 			pathInput = new File(bufferedReader.readLine());
 			if (pathInput.exists() && pathInput.isDirectory()) {
 				ok = true;
 			} else {
 				System.out.println("Doesn't exist or isn't folder!");
 			}
 		} while (!ok);
 
 		return pathInput.getAbsolutePath();
 	}
 
 	private String readWord(BufferedReader bufferedReader) throws IOException {
 		System.out.println("Please enter a Word:");
 		return bufferedReader.readLine();
 	}
 
 	private void performScan(PathAndWord pathAndWord, String endOfWorkFileName)
 			throws InterruptedException {
 		BlockingQueue<File> queue = new LinkedBlockingQueue<File>();
 
 		File endOfWorkFile = new File(endOfWorkFileName);
 		CountDownLatch latch = new CountDownLatch(2);
 
 		FolderScan folderScan = new FolderScan(pathAndWord.path, queue, latch,
 				endOfWorkFile);
 		FileScan fileScan = new FileScan(pathAndWord.whatFind, queue, latch,
 				endOfWorkFile);
 
 		Executor executor = Executors.newCachedThreadPool();
 		executor.execute(folderScan);
 		executor.execute(fileScan);
 
 		latch.await();
 	}
 
 	/**
 	 * @param args
 	 */
 
 	public static void main(String[] args) {
 		long startTime = System.currentTimeMillis();
 
 		new FileScan().askUserPathAndWord();
 
 		long stopTime = System.currentTimeMillis();
 		long elapsedTime = stopTime - startTime;
 		System.out.println("\nRuntime time " + elapsedTime + " milliseconds.");
 	}
 }
 
 class FolderScan implements Runnable {
 
 	FolderScan(String path, BlockingQueue<File> queue, CountDownLatch latch,
 			File endOfWorkFile) {
-		 new ExtentionCheckers(), /*new ProbeContentTypeCheker(),*/
+
-		new EncodingsCheck() ));
+
 		this.latch = latch;
 		this.endOfWorkFile = endOfWorkFile;
-	public FolderScan() {
+
 		checkers = new ArrayList<Checker>(Arrays.asList(
 				new ExtentionChecking(), new ProbeContentTypeCheking(),
 				new EncodingChecking()));
 
-		findFiles(path);
+		List<UncriticalChecker> checkers = Collections
-		queue.add(endOfWorkFile);
+				.singletonList(new UncriticalChecker());
 		FolderScan folderScan = new FolderScan(path, queue, latch,
 				endOfWorkFile, checkers);
 	}
 
 	public FolderScan(String path2, BlockingQueue<File> queue2,
 			CountDownLatch latch2, File endOfWorkFile2,
 			List<UncriticalChecker> checkers2) {
 	}
 
-				boolean checksFailed = true;
+
 	public void run() {
 		try {
 			findFiles(path);
-//					 if (currentFile.getAbsolutePath().equals(
+			queue.put(endOfWorkFile);
-//					 "E:\\Document\\!Nazar\\BOOKS\\)\\PDF\\readme.txt")) {
+			latch.countDown();
-//					 System.out.println();
+
-//					 }
+
 		}
 	}
-							checksFailed = false;
+
 	private void findFiles(String path) {
 
 		try {
 			File root = new File(path);
-					if (checksFailed) {
+
 			for (File currentFile : list) {
 				boolean checksPassed = true;
 				if (currentFile.isDirectory()) {
 					findFiles(currentFile.getAbsolutePath());
 				} else {
 					for (Checker currentChecker : checkers) {
 						if (!currentChecker.check(currentFile)) {
 							checksPassed = false;
 							break;
 						}
 					}
 
 					if (checksPassed) {
 						queue.put(currentFile);
 					}
 				}
 			}
 		} catch (InterruptedException e) {
 			e.printStackTrace();
 		}
 
 	}
 
 	private String path;
 	private BlockingQueue<File> queue;
 	private CountDownLatch latch;
 	private File endOfWorkFile;
 	private List<Checker> checkers;
 	private List<UncriticalChecker> checkList;
 }
 
-class ExtentionCheckers implements Checker {
+class UncriticalChecker implements Checker {
 	@Override
 	public boolean check(File currentFile) {
 		return true;
 	}
 }
 
 class PathAndWord {
-				".djv", ".rar", ".rtf"));
+
 	final String whatFind;
 
 	PathAndWord(String path, String whatFind) {
 		this.path = path;
 		this.whatFind = whatFind;
 	}
 
 	boolean isProperlyInitialized() {
 		return path != null && whatFind != null;
-class EncodingsCheck implements Checker {
+
 }
 
 class ExtentionChecking implements Checker {
-		return isUTF8(currentFile);
+
 	@Override
 	public boolean check(File currentFile) {
-	public static boolean isUTF8(File file) {
+
 		Set<String> extensions = new HashSet<String>(Arrays.asList(".txt",
 				".pdf", ".doc", ".docx", ".html", ".htm", ".xml", ".djvu",
 				".djv", ".rar", ".rtf", ".tmp"));
 
 		if (extensions.contains(fileName.substring(fileName.lastIndexOf(".")))) {
 			return true;
 		}
 
 		return false;
 	}
 
 	private String fileName;
 }
 
 class EncodingChecking implements Checker {
 
 	@Override
 	public boolean check(File currentFile) {
-		if (0 == (buffer[0] & 0x80)) {
+		return detectEncoding(currentFile);
-			return true; // ASCII subset character, fast path
+
-		} else if (0xF0 == (buffer[0] & 0xF8)) { // start of 4-byte sequence
+
-			if (buffer[3] >= buffer.length) {
+	public static boolean detectEncoding(File file) {
-				return false;
+		detector = new CharsetDetector();
 
-			if ((0x80 == (buffer[1] & 0xC0)) && (0x80 == (buffer[2] & 0xC0))
+
-					&& (0x80 == (buffer[3] & 0xC0)))
+
 			throw new IllegalArgumentException("input file can't be null");
-		} else if (0xE0 == (buffer[0] & 0xF0)) { // start of 3-byte sequence
+
-			if (buffer[2] >= buffer.length) {
+
-				return false;
+
 					"input file refers to a directory");
-			if ((0x80 == (buffer[1] & 0xC0)) && (0x80 == (buffer[2] & 0xC0))) {
+
 
 		// read input file
-		} else if (0xC0 == (buffer[0] & 0xE0)) { // start of 2-byte sequence
+
-			if (buffer[1] >= buffer.length) {
+
-				return false;
+
 		} catch (IOException e) {
-			if (0x80 == (buffer[1] & 0xC0)) {
+
 					"Can't read input file, error = " + e.getLocalizedMessage());
 		}
 
 		if (detector.setText(buffer) != null) {
 			return true;
 		}
 
 		return false;
 	}
 
-	    try{
+
-	        byte firstBytes[] = new byte[4];
+
-	        int count = fileInputStream.read(firstBytes);
+
-	        if(count < 4){
+
-	            throw new IOException("Empty file");
+			byte firstBytes[] = new byte[50];
-	        }
+			int count = fileInputStream.read(firstBytes);
-	        return firstBytes;
+			if (count < 5) {
-	    } finally {
+				throw new IOException("Poor file!");
-	        fileInputStream.close();
+
-	    }
+			return firstBytes;
 		} finally {
 			fileInputStream.close();
 		}
-class ProbeContentTypeCheker implements Checker {
+
 
 	private static CharsetDetector detector;
 }
-		String mimeType = null;
+
 class ProbeContentTypeCheking implements Checker {
-			Path path = Paths.get(currentFile.getAbsolutePath());
+
-			byte[] data = Files.readAllBytes(path);
+
-			MagicMatch match = Magic.getMagicMatch(data);
+
-			mimeType = match.getMimeType();
+
-		} catch (MagicParseException | MagicMatchNotFoundException
+			Path filePath = FileSystems.getDefault().getPath(
-				| MagicException | IOException e) {
+					currentFile.getAbsolutePath());
 			if ((null != Files.probeContentType(filePath))) {
 				return true;
 			}
-		if (null != mimeType) {
+
 			e.printStackTrace();
 		}
 
 		return false;
 	}
 }