comment
IRC Chat
play_arrow
Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

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

  • 3 Respuestas
  • 1340 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado r00t_access

  • *
  • Underc0der
  • Mensajes: 7
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« en: Junio 17, 2015, 01:54:28 pm »
Buenas!

Sigo con Java... empiezo a cogerle manía :S Aquí planteo mi duda:

Teniendo un .txt, me gustaría saber como escribir un code que saque las palabras con una terminación dada por el usuario así como el numero de veces que aparece dicha palabras. Este sería el esquema a seguir:

1. Al ejecutarlo se le pide al usuario el nombre del archivo que tiene que escribirse con la extensión(ejemplo.txt)

2. Si el nombre introducido no se encuentra en la carpeta src, aparecerá el pensaje de archivo no encontrado vuelva a intentarlo, es decir, que vuelve al primero apartado de introducción de texto.

3. Si el nombre del archivo es el mismo que el nombre del txt de la carpeta src se le preguntara al usuario que terminación tienen que tener las palabras a buscar.

4. Tras escribir la terminación aparecerá en pantalla una lista con las palabras que terminan por la terminación escrita anteriormente. En la lista han de aparecer también el numero de veces que ha aparecido dicha palabra.

5. Si cuando el se ejecuta el programa el usuario escribe "end" el programa se dentendrá.

Y ahora un poco mas resumido:

 User -> nombre del archivo: (input)
           if nombre del archivo introducido.exist():
                  user -> que terminación tienen que tener las palabras que vamos a buscar: (input)
                          System.out.print(lista de palabras con esa terminación + numero de veces que aparecen)

          si el usuario escribe "end" -> Sysyem.exit(1)


Por ahora lo que llevo es esto:

Código: Java
  1. import java.io.Archivo;
  2. import java.io.FileNotFoundException;
  3. import java.util.regex.*;
  4. import java.util.ArrayList;
  5. import java.util.List;
  6. import java.util.Scanner;
  7. public class MorphSearchDemo extends ChatReader{
  8.        
  9.         //variables
  10.         String suffix;
  11.         List<String> tokenS = new ArrayList<String>(); //Contendrá las palabras que terminen con la terminacion indicada
  12.        
  13.         String Archivo;
  14.         String Terminacion;
  15.        
  16.         public MorphSearchDemo(String Archivoname, String suffix) {
  17.                 super(Archivoname);
  18.                 this.suffix=suffix;
  19.         }
  20.  
  21.         public String searchS() throws FileNotFoundException{
  22.  
  23.         Scanner scan = new Scanner(System.in);
  24.         System.out.print("introduce el nombre del archivo: "+ "\n");
  25.         this.Archivo = scan.next();
  26.         if(!this.Archivo.contains(".")){ // para asegurarme de que el user pone la extension! Pero quiero limitar las opciones del user y que
  27.                 System.out.print("el archivo existe, vueleve a intentarlo"); // solo pueda escribir el nombre de los archivos que hay en src
  28.         }
  29.         //System.out.println( "input = " + input );
  30.         /*if (!(input != Archivo)){
  31.                 for (String rs : getMessages()){
  32.                        
  33.                         String[] splitString = rs.split(" ");
  34.                        
  35.                         for (int i=0; i<splitString.length; i++){
  36.                                
  37.                                 Pattern patternS = Pattern.compile(suffix);
  38.                                 Matcher matcherS = patternS.matcher(splitString[i]);
  39.                                
  40.                                 if (matcherS.find()){ //if we found a token matching endS
  41.                                         splitString[i]=splitString[i].replaceAll("[^A-Za-z ]", ""); //quito todos los caracteres especiales y numeros
  42.                                         tokenS.add(splitString[i]);
  43.                                 }
  44.                         }
  45.                 }
  46.                 System.out.println(tokenS.toString());
  47.         }*/
  48.         System.out.print("Terminacion : ");
  49.         this.Terminacion = scan.next();
  50.         if (this.Terminacion.contains("end") || this.Archivo.contains("end")){     // si el usuario escribe end tiene que terminar de correr    
  51.                 System.out.print("el proceso ha terminado");
  52.                 System.exit(0);
  53.             }
  54.        
  55.        
  56.        
  57.         //Archivo Archivo = new Archivo(dat.nextLine());
  58.         //dat = new Scanner(Archivo);
  59.        
  60.                
  61.                 //look for the pattern in each token of each line
  62.                
  63.                 //System.out.println(tokenS.toString());
  64.                 return " ";
  65.         }
  66.        
  67. }

Esto es lo poco que llevo y ya me he atascado. El reader lo tengo en otro archivo que no creo que rea muy importante ya que me lo he probado y me lee el texto y he probado lo de que encuentre las palabras terminadas en X y me ha funcionado bien.

Otro problema esta en que al correr el programa si cuando pide el nombre del archivo escribo end pasa directamente a preguntarme la terminación a buscar y si ahí escribo end ya si me dice lo de proceso finalizado :S

Alguien podría darme algún empujón?
Ya que escribo esto, alguien me puede decir que diferencia hay entre escribir un numero u otro en el System.exit(int);
« Última modificación: Junio 18, 2015, 06:50:01 am por blackdrake »

Desconectado Gus Garsaky

  • *
  • Underc0der
  • Mensajes: 93
  • Actividad:
    0%
  • Reputación -1
    • Ver Perfil
  • Skype: gus.garsaky
« Respuesta #1 en: Junio 17, 2015, 06:38:28 pm »

Código: Java
  1. package org.underc0de.util;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.util.ArrayList;
  8. import java.util.List;
  9. import java.util.Scanner;
  10.  
  11. public class CharsFinder {
  12.         public boolean checkExt(String fileName) {
  13.                 if (fileName.endsWith(".txt")) {
  14.                         return true;
  15.                 }
  16.                 return false;
  17.         }
  18.  
  19.         public boolean exists(String fileName) {
  20.                 try {
  21.                         InputStream is = CharsFinder.class.getClassLoader()
  22.                                         .getResourceAsStream(fileName);
  23.                         is.available();
  24.                         return true;
  25.                 } catch (IOException | NullPointerException e) {
  26.                         return false;
  27.                 }
  28.         }
  29.  
  30.         public List<String> checkMatches(String fileName, String suffix)
  31.                         throws IOException {
  32.                 List<String> matches = new ArrayList<>();
  33.  
  34.                 InputStream is = CharsFinder.class.getClassLoader()
  35.                                 .getResourceAsStream(fileName);
  36.                 BufferedReader bf = new BufferedReader(new InputStreamReader(is));
  37.                 String line = "";
  38.                 while ((line = bf.readLine()) != null) {
  39.                         if (line.endsWith(suffix)) {
  40.                                 matches.add(line);
  41.                         }
  42.                 }
  43.  
  44.                 return matches;
  45.         }
  46.  
  47.         public static void main(String[] args) throws IOException {
  48.                 CharsFinder cf = new CharsFinder();
  49.                 final Scanner reader;
  50.                 List<String> matches = new ArrayList<>();
  51.                 String fileName;
  52.                 reader = new Scanner(System.in);
  53.                 do {
  54.                         System.out.println("Ingrese el fichero a buscar");
  55.                         fileName = reader.next();
  56.                         if (cf.checkExt(fileName)) {
  57.                                 System.out.println("Ingrese la terminación que desea buscar");
  58.                                 String suffix = reader.next();
  59.                                 matches = cf.checkMatches(fileName, suffix);
  60.                         } else {
  61.                                 System.out.println("El fichero debe tener extensión .txt");
  62.                         }
  63.                 } while (!fileName.endsWith(".txt"));
  64.                 reader.close();
  65.  
  66.                 if (!matches.isEmpty()) {
  67.                         for (String coincidence : matches) {
  68.                                 System.out.println(coincidence);
  69.                         }
  70.                 } else {
  71.                         System.out.println("No se encontraron coincidencias");
  72.                 }
  73.         }
  74. }

Desconectado r00t_access

  • *
  • Underc0der
  • Mensajes: 7
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #2 en: Junio 18, 2015, 10:52:23 am »
Gracias por responder compañero. Pero podrías explicarme  como funciona un poco el Charsfinder?
Porq cuando lo ejecuto puedo escribir "blablabla.txt" y luego me pregunta por el sufijo pero si no existe el archivo blablabla.txt no tendría que pedirme el sufijo ya que no puede trabajar con un archivo que no existe.

El chatreader lo he hecho en otro archivo:

Código: [Seleccionar]
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;
    }
 
}


Para el contador de frecuencia de una palabra he escrito esto, pero me gustaría saber si alguien tiene una forma mas fácil(que no implique por ejemplo tener que hacer un reverse para que primero vayan los mas frecuentes):

Código: [Seleccionar]
//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 " ";
}

}

Un saludo!  ;D
« Última modificación: Junio 18, 2015, 12:24:55 pm por elmoyer »

Desconectado Gus Garsaky

  • *
  • Underc0der
  • Mensajes: 93
  • Actividad:
    0%
  • Reputación -1
    • Ver Perfil
  • Skype: gus.garsaky
« Respuesta #3 en: Junio 18, 2015, 08:27:14 pm »
1. El método checkExt, verifica si la extensión es válida (.txt).
2. El método exists verifica si el archivo existe en el folder src.
3. El método checkMatches recorre el archivo en busca de las líneas con la extensión especificada.

El flujo es el siguiente:

1. Pide el nombre del archivo.
    1.2 Verifica si tiene extensión .txt
2. Comprueba que el archivo exista.
3. Si punto 2 retorna true, pide extensión a buscar.
4. Recorre el archivo en busca de líneas que terminen con dicha extensión.

Código: Java
  1. CharsFinder cf = new CharsFinder();
  2. final Scanner reader;
  3. List<String> matches = new ArrayList<>();
  4. String fileName;
  5. reader = new Scanner(System.in);
  6. do {
  7.         System.out.println("Ingrese el fichero a buscar");
  8.         fileName = reader.next();
  9.         // si la extensión es correcta
  10.         if (cf.checkExt(fileName)) {
  11.                 // si el archivo existe
  12.                 if(cf.exists(fileName)) {
  13.                         System.out.println("Ingrese la terminación que desea buscar");
  14.                         String suffix = reader.next();
  15.                         matches = cf.checkMatches(fileName, suffix);
  16.                 }
  17.                 // caso contrario salimos del programa
  18.                 else {
  19.                         System.out.println("El archivo no existe");
  20.                         System.exit(-1);
  21.                 }
  22.         }
  23.         // la extension no es .txt
  24.         else {
  25.                 System.out.println("El fichero debe tener extensión .txt");
  26.         }
  27. } while (!fileName.endsWith(".txt"));
  28. reader.close();
  29.  
  30. if (!matches.isEmpty()) {
  31.         for (String coincidence : matches) {
  32.                 System.out.println(coincidence);
  33.         }
  34. } else {
  35.         System.out.println("No se encontraron coincidencias");
  36. }

En caso quieras buscar palabras, solo debes hacer:

Código: Java
  1. String[] words = line.split(" ");
  2. for(String word : words) {
  3.     if(word.endsWith(".txt")) { matches.add(word); }
  4. }

 

¿Te gustó el post? COMPARTILO!



Java - Funcionamiento del método "compareTo"

Iniciado por Zepovop

Respuestas: 3
Vistas: 1641
Último mensaje Enero 17, 2017, 10:59:02 pm
por seth
Ayuda Java (Salta lectura de teclado "consola")

Iniciado por AroonVa

Respuestas: 2
Vistas: 320
Último mensaje Octubre 26, 2018, 04:36:58 pm
por AroonVa
[SOLUCIONADO] Programa compila pero tiene errores - import java.awt.EventQueue;

Iniciado por Only

Respuestas: 3
Vistas: 2038
Último mensaje Agosto 23, 2018, 08:28:55 pm
por noxonsoftwares
[SOLUCIONADO] Llamar métodos no estáticos/final desde constructores - JAVA

Iniciado por phr4ckl0t

Respuestas: 6
Vistas: 2309
Último mensaje Agosto 20, 2017, 11:24:39 pm
por phr4ckl0t
Me podrian echar una mano para el método submit post en java ...?

Iniciado por Hu3c0

Respuestas: 0
Vistas: 1015
Último mensaje Enero 25, 2014, 10:53:59 am
por Hu3c0