Comprobar que se va a utilizar X archivo y no el archivo Z [Java]

import java.io.Archivo;
import java.io.FileNotFoundException;
import java.util.regex.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class MorphSearchDemo extends ChatReader{
	
	//variables
	String suffix;
	List<String> tokenS = new ArrayList<String>(); //Contendrá las palabras que terminen con la terminacion indicada
	
	String Archivo;
	String Terminacion;
	
	public MorphSearchDemo(String Archivoname, String suffix) {
		super(Archivoname);
		this.suffix=suffix;
	}

	public String searchS() throws FileNotFoundException{

        Scanner scan = new Scanner(System.in);
        System.out.print("introduce el nombre del archivo: "+ "\n");
        this.Archivo = scan.next();
        if(!this.Archivo.contains(".")){ // para asegurarme de que el user pone la extension! Pero quiero limitar las opciones del user y que
        	System.out.print("el archivo existe, vueleve a intentarlo"); // solo pueda escribir el nombre de los archivos que hay en src
        }
        //System.out.println( "input = " + input );
        /*if (!(input != Archivo)){
        	for (String rs : getMessages()){
    			
    			String[] splitString = rs.split(" ");
    			
    			for (int i=0; i<splitString.length; i++){ 
    				
    				Pattern patternS = Pattern.compile(suffix);
    				Matcher matcherS = patternS.matcher(splitString[i]);
    				
    				if (matcherS.find()){ //if we found a token matching endS
    					splitString[i]=splitString[i].replaceAll("[^A-Za-z ]", ""); //quito todos los caracteres especiales y numeros
    					tokenS.add(splitString[i]);
    				}
    			}
    		}
        	System.out.println(tokenS.toString());
        }*/
        System.out.print("Terminacion : ");
        this.Terminacion = scan.next();
        if (this.Terminacion.contains("end") || this.Archivo.contains("end")){     // si el usuario escribe end tiene que terminar de correr 	
        	System.out.print("el proceso ha terminado");
        	System.exit(0);
            }
        
        
        
        //Archivo Archivo = new Archivo(dat.nextLine());
        //dat = new Scanner(Archivo);
        
		
		//look for the pattern in each token of each line
		
		//System.out.println(tokenS.toString());
		return " ";
	}
	
}

package org.underc0de.util;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class CharsFinder {
	public boolean checkExt(String fileName) {
		if (fileName.endsWith(".txt")) {
			return true;
		}
		return false;
	}

	public boolean exists(String fileName) {
		try {
			InputStream is = CharsFinder.class.getClassLoader()
					.getResourceAsStream(fileName);
			is.available();
			return true;
		} catch (IOException | NullPointerException e) {
			return false;
		}
	}

	public List<String> checkMatches(String fileName, String suffix)
			throws IOException {
		List<String> matches = new ArrayList<>();

		InputStream is = CharsFinder.class.getClassLoader()
				.getResourceAsStream(fileName);
		BufferedReader bf = new BufferedReader(new InputStreamReader(is));
		String line = "";
		while ((line = bf.readLine()) != null) {
			if (line.endsWith(suffix)) {
				matches.add(line);
			}
		}

		return matches;
	}

	public static void main(String[] args) throws IOException {
		CharsFinder cf = new CharsFinder();
		final Scanner reader;
		List<String> matches = new ArrayList<>();
		String fileName;
		reader = new Scanner(System.in);
		do {
			System.out.println("Ingrese el fichero a buscar");
			fileName = reader.next();
			if (cf.checkExt(fileName)) {
				System.out.println("Ingrese la terminación que desea buscar");
				String suffix = reader.next();
				matches = cf.checkMatches(fileName, suffix);
			} else {
				System.out.println("El fichero debe tener extensión .txt");
			}
		} while (!fileName.endsWith(".txt"));
		reader.close();

		if (!matches.isEmpty()) {
			for (String coincidence : matches) {
				System.out.println(coincidence);
			}
		} else {
			System.out.println("No se encontraron coincidencias");
		}
	}
}

import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
  

public class ChatReader {
  

    private String fileName;
  
    public ChatReader(String fileName) {
        this.setFileName(fileName);
    }
     
    public String[] getMessages() {
        try {
            // path to the chat log file
            Path p = Paths.get(this.getFileName());
            // read all lines and store them in a list
            List<String> lines = Files.readAllLines(p, Charset.forName("UTF-8")); 
            String[] messages = 
                    lines.toArray(new String[lines.size()]);
            return messages;
        } catch (IOException e) {
            System.err.println("Couldn't read " + this.getFileName() + "\n Did you give me the correct path?");
        }
        return new String[]{};
    }
  
  
    public String getFileName() {
        return fileName;
    }
  
  
    public void setFileName(String fileName) {
        this.fileName = fileName;
    }
  
}

//frequency count :
		for (String type:tokenS){ //for each word our list of tokens
			Double oldCounter = typeFreq.get(type); //oldCounter's value is the value of the key 'type'
			if (oldCounter == null){ //check if there is no value in the map
				oldCounter = 0.; //reset : oldCounter has the value 0 (dot because it is a double)	
			}
			typeFreq.put(type, ++oldCounter); //add the current word and its counter +1 
			//if the counter was 0, we have oldCounter=1
			//and if the counter for that type already had a value>0 : +1.
			
			//as we cannot have duplicate keys in a map, it will always go to the already existing entry
			//if the current word already appeared before.
		}
		
		System.out.println(typeFreq.toString()); //problem : does not print special characters : ü,ö,ä,... (->replace?)
		
		double temp=0; //current value
		double max=0; //biggest current value
		for(String key:typeFreq.keySet()){ //for each key (token)
			temp=typeFreq.get(key); //hold its value (frequency)
			if(temp>=max){ //if value bigger than max
				max=temp; //value is the new max
				//System.out.println(key); //print corresponding key
				//that way we print the key with the smallest value first
				toBeReversed.add(key);
				continue;
			}
		}
		Collections.reverse(toBeReversed);
		System.out.println(toBeReversed.toString());
		return " ";
	}
	
}

CharsFinder cf = new CharsFinder();
final Scanner reader;
List<String> matches = new ArrayList<>();
String fileName;
reader = new Scanner(System.in);
do {
	System.out.println("Ingrese el fichero a buscar");
	fileName = reader.next();
	// si la extensión es correcta
	if (cf.checkExt(fileName)) {
		// si el archivo existe
		if(cf.exists(fileName)) {
			System.out.println("Ingrese la terminación que desea buscar");
			String suffix = reader.next();
			matches = cf.checkMatches(fileName, suffix);
		}
		// caso contrario salimos del programa
		else {
			System.out.println("El archivo no existe");
			System.exit(-1);
		}
	}
	// la extension no es .txt
	else {
		System.out.println("El fichero debe tener extensión .txt");
	}
} while (!fileName.endsWith(".txt"));
reader.close();

if (!matches.isEmpty()) {
	for (String coincidence : matches) {
		System.out.println(coincidence);
	}
} else {
	System.out.println("No se encontraron coincidencias");
}

String[] words = line.split(" ");
for(String word : words) {
    if(word.endsWith(".txt")) { matches.add(word); }
}