Hola, lo que puedes hacer es separar las palabras del archivo 1.
Puedes leer el archivo con BufferedReader que te dará lineas enteras en un String. Estas lineas puedes trocearlas con el metodo split() de la clase String.
Si suponemos que las palabras a buscar están separadas por espacios en blanco, usando split(" "); te dará un array de String con las palabras separadas de ESA LINEA.
Puedes guardar todas esas palabras en otra colección, mejor que sea dinámica porque no sabes cuántas palabras vas a tener. Puedes usar Vector o ArrayList por ejemplo.
Una vez tienes esas palabras, ahora lees el texto. En el texto no puedes saber con certeza si las palabras están separadas, por espacios, comas, puntos, guiones, símbolos.... por lo que split() no te puede ayudar de manera fiable.
Lo mejor es guardar las líneas completas, tal cual, en otro Vector/ArrayList distinto.
Ahora tendríamos palabras en un sitio y lineas de texto en otro.
¿Cómo empezar a buscar palabras en esas líneas? Lo mejor es usar
expresiones regulares.
En otro bucle, con cada palabra construimos un nuevo patrón y comparamos en cada línea si hay coincidencia o no.
Tras comprobar todas las palabras, ya podríamos crear el nuevo archivo indicando que palabras se han encontrado y cuáles no.
Pero, ¿como marcamos las palabras encontradas de las que no?
Mira, he hecho un código para probarlo. Y me ha parecido que lo mejor es crear primero una clase Palabra.
Simplemente será un String y un booleano, para poder marcarla como encontrada o no.
Además le sobreescribo el método toString(), para usarlo luego al crear el archivo de resultados y que escriba la palabra acompañada de un SI o un NO según el valor del atributo boolean.
Entonces, cuando vaya a leer el archivo de palabras a buscar, crearé un objeto Palabra a partir de cada String obtenido.
A continuación voy a poner la parte del código que se encarga de leer archivos, comparar y crear archivo de resultados.
Es un poco extenso, aunque tan solo sigue los 4 pasos que he descrito antes, así que primero lo pongo por partes para mayor legibilidad.
He de decir, que para poder interactuar correctamente con la barra de progreso en la interfaz, esta parte del código será una clase que herede de Thread, es decir, será un hilo de ejecución paralelo al programa principal.
Voy por partes:
Como dije, es una clase Thread (interna a la clase principal del programa). Ahí declaro los dos Vector, uno de tipo Palabra y otro de tipo String donde guardaré las lineas del texto donde hay que buscar.
Tras esto, hago la lectura del archivo de palabras. En mi código, este archivo es un objeto File llamado
arc1
Como ves, leo linea del archivo y con split(" ") separo palabras en un array. Luego cojo esas palabras y creo objetos de mi clase Palabra para guardarlas en el Vector.
Fase 1 completada xD. Ahora hay que leer el archivo de texto. En mi código, es un File llamado
arc2
Es similar al paso anterior, pero ahora no hacemos nada con split(). Guardamos las líneas enteras en el Vector de String.
Ahora viene el paso más importante. Buscar coincidencias.
Lo primero que hago es indicar a la barra de progreso cual es su valor máximo y reiniciarla a 0.
Como el progreso va a mostrar cada vez que termino de comprobar una palabra, pues su valor máximo depende de la cantidad de palabras que me haya dado el primer archivo, es decir, del tamaño que tenga el Vector de palabras.
Luego recorro cada una de estas palabras y creo un patrón con ellas.
Con este patrón, en un bucle anidado recorro todas las lineas del texto del archivo 2. Si el Matcher que analiza el patrón (la expresión regular) encuentra una coincidencia, entonces marco dicha palabra como encontrada.
Para entender esto hay que tener unas nociones mínimas de expresiones regulares y como usarlas en Java.
Tras cada palabra, actualizo barra de progreso y paso a la siguiente. Hago un ligero delay para que se vea la barra progresar. De lo contrario, todo ocurre rapidísimo y el usuario no verá la barra progresar.
Bien, llegados a este punto, los objetos Palabra del Vector ya están marcados unos como encontrados y otros como no. Es el momento de crear el archivo de resultados.
Para ello inicio un BufferedWriter con el archivo donde voy a guardar los resultados.
Recorro el vector de Palabra y a cada palabra invoco su método toString(), el cuál recuerdo que hemos sobreescrito para que muestre la palabra acompañada de SI o NO según su atributo.
Además actualizo un JTextField llamado campoArc3, que es donde muestro al usuario la ruta donde puede encontrar este archivo que hemos creado.
Y ya está, eso es todo. Como digo son 4 pasos sencillos, parece que hay mucho código, debido a los obligatorios try catch cuando operamos con archivos, pero en realidad no es para tanto.
Entonces, si pongo a prueba mi programa con estas palabras:
Y este texto:
Obtengo un archivo con este resultado:
Abajo te adjunto un zip, con las dos clases.
La clase Palabra y una clase main donde construyo el JFrame y contiene todo el código.
Lo adjunto todo para que lo veas funcionar y tal, pero vamos, la parte que te interesa entender para poder adaptarla a tu programa son los 4 pasos que he comentado aquí.
Échale un vistazo y pregunta cualquier cosa que no entiendas.
Un saludo.
Crear cuenta
