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 " ";
	}
	
}

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 " ";
	}
	
}

public class Replace {

        public static String replace(String str, String search, String replace) {
                return str.replaceAll(search, replace);
        }

        public static void main(String[] args) {

                String sURL = "http://www.google.com";
                String new_URL = replace(sURL,"http://","[");
                System.out.println(new_URL+ "]");

        }

}

    String Link = "(https?)://(www\\d?|[a-zA-Z0-9]+)?.[a-zA-Z0-9-]+(\\:|.)([a-zA-Z0-9.]+|(\\d+)?)([/?:].*)?";
        
       Pattern patternLink = Pattern.compile(Link);
       Matcher matcherLink = patternLink.matcher(s);
        
       if (matcherLink.find()){
    	   LinkSearch=matcherLink.group();
           String LinkSearch_replace= replace(LinkSearch,"http://","[");
    	   return LinkSearch_replace;