1. VIRGINIO.CLASS
/**
* Questo programma gestisce un piccolo motore di ricerca denominato
* Virginio Desktop. Esso indicizza una lista di parole presente
* nei file di una cartella e, a seconda della scelta fatta in un
* apposito menù, può eseguire una ricerca booleana per OR o per AND
* ed esegue automaticamente l'indicizzazione delle parole nei file
* nella directory indicata in input dall'utente.
*/
// Importazione del pacchetto di utilità delle libreria di Java
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.util.*;
/**
* @author BaelSoft Production®: Centrone Sergio e Gadaleta Fabio
* Classe principale del programma
*/
public class Virginio
{
/**
* Metodo per richiamare la stampa dell'indice
* @param indice dizionario HashMap contenente le parole indicizzate
*/
private static void stampaIndice(HashMap<String, Parola> indice)
{
//il parametro valori sara' uguale al valore presente nel dizionario in quella
posizione
Collection<Parola> valori = indice.values();
//ciclo for che serve per visualizzare tutte le parole con i relativi file in
cui è presente la parola
for(Iterator<Parola> iterator = valori.iterator(); iterator.hasNext();)
{
Parola parola = iterator.next();
System.out.println("nparola: " + parola.getParola());
ArrayList<String> paths = parola.getPath();
for(int i = 0; i < paths.size(); i++)
{
//Stampa di tutte le paths
System.out.println("t" + paths.get(i));
}
}
}
/**
* Metodo per richiamare la stampa dei risultati delle ricerche
* @param risultati ArrayList che contiene le paths
*/
private static void stampaRisultati(ArrayList<String> risultati)
{
System.out.println("La ricerca ha restituito i seguenti files:");
//Fintanto che l'ArrayList non e' finito ...
for(int i = 0; i < risultati.size(); i++)
{

2. //... stampa i risultati nella posizione indicata dall'indice i
System.out.println((i+1) + ") " + risultati.get(i));
}
}
/**
* Main della classe Virginio
*/
public static void main(String[] args)
{
//Costruzione dell'input
Scanner in = new Scanner(System.in);
//dare in input la cartella da indicizzare
System.out.println("Inserisci il percorso della cartella");
String percorso = in.next();
//Inizio dell'indicizzazione
System.out.println("Indicizzazione in corso");
//HashMap dichiarato "null"
HashMap<String,Parola> indice = null;
//Provare e se il programma prosegue verso un errore cattura l'eccezione
try
{
//Costruiamo un indicizzatore dando come parametro il percorso
Indicizzazione indexer = new Indicizzazione(percorso);
//Mettiamo nel dizionario il risultato dell'indicizzazione
indice = indexer.indicizza();
System.out.println("Indicizzazione completata e salvata sul file.");
//Salva l'indicizzazione su un file di nome indice
FileOutputStream f = new FileOutputStream("Indice.txt");
ObjectOutput s = new ObjectOutputStream(f);
s.writeObject(indice);
//Costruzione del nuovo oggetto Ricerca dando in input l'HashMap indice
Ricerca ricerca = new Ricerca(indice);
// Costruzione del menù con le varie scelte
boolean done = false;
while (!done)
{
System.out.println("**********************************************
**************");
System.out.println("*
*");
System.out.println("* VIRGINIO DESKTOP
*");
System.out.println("* by BaelSoft Production
*");
System.out.println("*
*");
System.out.println("**********************************************
**************");
System.out.println("
");
System.out.println("
__________________________________________________________ ");
System.out.println("|
|");
System.out.println("| Cosa vuoi fare?
|");
System.out.println("| Inserisci: 1 per eseguire la visualizzazione
dell'indicizzazione |");
System.out.println("| 2 per eseguire la ricerca
booleana OR |");

3. System.out.println("| 3 per eseguire la ricerca
booleana AND |");
System.out.println("|
|");
System.out.println("| Q (quit) per uscire
|");
System.out.println("|_____________________________________________
_____________|");
String scelta =in.next();
//Caso di scelta = "1"
if (scelta.equals("1"))
{
//Visualizzazione dell'indicizzazione
stampaIndice(indice);
}
//Caso di scelta = "2"
else if (scelta.equals("2"))
{
//Inserimento delle parole da ricercare
System.out.print("Inserisci le parole da ricercare separate
da ' , ': ");
String frase = in.next();
//Effettuare la ricerca OR e inserire i risultati
nell'ArrayList omonima
ArrayList<String> risultati = ricerca.ricercaOR(frase);
//Caso in cui non ha trovato nessun risultato
if(risultati == null)
{
System.out.println("Le parole cercate non hanno
prodotto risultati");
}
//Stampa dei risultati
else
stampaRisultati(risultati);
}
//Caso di scelta = "3"
else if (scelta.equals("3"))
{
//Inserimento delle parole da ricercare
System.out.print("Inserisci le parole da ricercare separate
da ',': ");
String frase = in.next();
//Effettuare la ricerca OR e inserire i risultati
nell'ArrayList omonima
ArrayList<String> risultati = ricerca.ricercaAND(frase);
//Caso in cui non ha trovato nessun risultato
if(risultati == null)
{
System.out.println("Le parole cercate non hanno
prodotto risultati");
}
//Stampa dei risultati
else
stampaRisultati(risultati); }
}
//Caso di scelta = "q"
else if (scelta.equalsIgnoreCase("q"))

4. {
//Terminazione del programma
s.close();
System.out.println("Programma Terminato");
done = true;
}
//Caso in cui la scelta non sia una delle proposte precedenti
else
{
//Segnalazione di errore
System.out.println("Scelta sbagliata. Riprova per favore");
}
}
}
//Cattura l'eccezione in caso il file non è trovato
catch (FileNotFoundException e)
{
System.out.println(e.getMessage());
}
//Cattura l'eccezione in caso ci sono errori di Input/Output
catch (IOException e)
{
System.out.println(e.getMessage());
}
}
}

5. INDICIZZAZIONE.CLASS
//Importazione dei vari pacchetti
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
/**
* @author BaelSoft Production®: Centrone Sergio e Gadaleta Fabio
* Classe Indicizzazione
*/
public class Indicizzazione
{
/**
* Costruttore con lancio dell'eccezione in caso di file non trovato
* @param per percorso della directory da indicizzare
* @throws FileNotFoundException eccezione lanciata in caso di directory non trovata
*/
public Indicizzazione(String per) throws FileNotFoundException
{
percorso = new File(per);
//Casi limite:
//1 - se il percorso esiste
if(!percorso.exists())
throw new FileNotFoundException("La cartella non esiste");
//2 - se il percorso e' una directory
if (!percorso.isDirectory())
throw new FileNotFoundException("Il percorso inserito non e' una
directory");
//3 - se la directory contiene file txt o html
files = percorso.listFiles(new ValidFileFilter());
if(files.length == 0)
throw new IllegalArgumentException("La cartella non contiene file txt o
html");
//in questo caso si accettano solo file txt o file html
}
/**
* Creazione di un indicizzatore/dizionario di tipo HashMap
* @return ritorna l'hashMap indicizzato
* @throws IOException lancio dell'eccezione in caso di errori nei dati
*/
public HashMap<String, Parola> indicizza() throws IOException
{
//costruzione dell'indice
HashMap<String, Parola> indice = new HashMap<String, Parola>();
//scorre tutta la directory fino a che non controlla tutti i file
for (int i = 0; i < files.length; i++)
{
System.out.println("indicizzazione parole del file: " + files[i]);
File file = files[i];
//FileReader fr = new FileReader(file);
Scanner in = new Scanner(file);
while (in.hasNext())
{
String parola = in.next();
//Verifica se la parola è una stopWord.
if(!Ricerca.isStopword(parola))

6. {
//Verifica che la parola sia gia presente nell'indice
if (indice.containsKey(parola))
{
Parola word = (Parola) indice.get(parola);
//Recupera la lista dei path che contengono la parola
ArrayList<String> listaPath = word.getPath();
if(!listaPath.contains(file.getCanonicalPath()))
word.AggiungiFile(file.getCanonicalPath());
}
else
{
//Inseriamo la nuova parola nel dizionario
Parola word = new Parola(parola,
file.getCanonicalPath());
indice.put(parola, word);
}
}
}
}
return indice;
}
//Parametri della classe Indicizzazione
private File[] files;
private File percorso;
}

7. RICERCA.CLASS
//Importazione delle librerie necessarie per la classe
import java.util.ArrayList;
import java.util.HashMap;
/**
* @author BaelSoft Production®: Centrone Sergio e Gadaleta Fabio
* Classe Ricerca
*/
public class Ricerca
{
/**
* Costruzione delle stopwords
*/
public static String[] stopwords =
{
"il","lo","la","i","gli","le",
"di","a","da","in","con","su","per","tra","fra",
"non","no","si",
"della","delle","dei","degli",
"alla","alle","ai","agli",
"dalla","dalle","dai","dagli",
"sulla","sulle","sui","sugli",
".",",",":",";","_","<",">","^","?","'",")","=","(","/",""",""
};
/**
* Costruttore della classe Ricerca
*/
public Ricerca(HashMap<String, Parola> index)
{
indice = index;
}
/**
* Metodo per la ricerca OR
* @param frase stringa di caratteri per la ricerca data in input
* @return restituisce "null" se non trova risultati altrimenti il risultato della
ricerca
*/
public ArrayList<String> ricercaOR(String frase)
{
//Divide la frase data in parole separate da " , "
String[] parole = frase.split(",");
ArrayList<String> risultatoRicerca = new ArrayList<String>();
//Inizio della ricerca OR
for(int i = 0; i < parole.length; i++)
{
String parola = parole[i];
//Controllo se la parola è una stopword
if(!isStopword(parola))
{
//Controllo se l'HashMap contiene la parola
if(indice.containsKey(parola))
{
Parola word = (Parola) indice.get(parola);
addPathsOR(risultatoRicerca,word.getPath());
}
}
}
//Restituisco "null" se il risultato della ricerca è vuoto

8. if(risultatoRicerca.size() == 0)
return null;
//altrimenti restituisco il risultato della ricerca
return risultatoRicerca;
}
/**
* Questo metodo aggiunge (per la ricerca OR) i percorsi dei file al risultato della
ricerca
* @param risultatoRicerca risultato delle parole cercate
* @param paths percorso del file in cui si trova la parola ricercata
*/
private void addPathsOR(ArrayList<String> risultatoRicerca, ArrayList<String> paths)
{
for(int i = 0; i < paths.size(); i++)
{
String path = paths.get(i);
if(!risultatoRicerca.contains(path))
risultatoRicerca.add(path);
}
}
/**
* Metodo per la ricerca AND
* @param frase stringa di caratteri per la ricerca data in input
* @return restituisce "null" se non trova risultati altrimenti il risultato della
ricerca
*/
public ArrayList<String> ricercaAND(String frase)
{
String[] parole = frase.split(",");
ArrayList<String> risultatoRicerca = new ArrayList<String>();
boolean trovato = false;
int i;
for(i = 0; i < parole.length && !trovato; i++)
{
String parola = parole[i];
if(!isStopword(parola))
{
if(indice.containsKey(parola))
{
Parola word = (Parola) indice.get(parola);
risultatoRicerca.addAll(word.getPath());
trovato = true;
}
else
/**
* nella ricerca AND tutte le parole devono essere contenute
* almeno in un file. Se questo nn avviene, il risultato della
ricerca
* è "null", cioè la ricerca fallisce.
*/
return null;
}
}
for(; i < parole.length; i++)
{
String parola = parole[i];
if(!isStopword(parola))
{
if(indice.containsKey(parola))
{

9. Parola word = (Parola) indice.get(parola);
addPathsAND(risultatoRicerca, word.getPath());
}
else
/**
* nella ricerca AND tutte le parole devono essere contenute
* almeno in un file. Se questo nn avviene, il risultato della
ricerca
* è "null", cioè la ricerca fallisce.
*/
return null;
}
if(risultatoRicerca.size() == 0)
return null;
}
return risultatoRicerca;
}
/**
* Questo metodo aggiunge (per la ricerca AND) i percorsi dei file al risultato
della ricerca
* @param risultatoRicerca risultato delle parole cercate
* @param paths percorso del file in cui si trova la parola ricercata
*/
private void addPathsAND(ArrayList<String> risultatoRicerca, ArrayList<String>
paths)
{
for (int i=0; i < risultatoRicerca.size();)
{
if (!paths.contains(risultatoRicerca.get(i)))
risultatoRicerca.remove(i);
else
i++;
}
}
/**
* dichiarazione metodo privato per le stopwords che controlla
* se la stringa contiene stopwords o se non le contiene.
* In caso affermativa esso restituisce un valore boolean true
* che gli dice che la parola fa parte del vettore stopwords
* altrimenti continua la ricerca fino alla fine del vettore e non
* restituisce solo
* @param parola
* @return
*/
public static boolean isStopword(String parola)
{
boolean trovato = false;
for(int j= 0; j < stopwords.length && !trovato; j++)
{
if(parola.equalsIgnoreCase(stopwords[j]))
trovato = true;
}
return trovato;
}
//Parametri della classe Ricerca
private HashMap<String, Parola> indice;
}

10. VALIDFILEFILTER.CLASS
//Importazione dei vari pacchetti
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
/**
* @author BaelSoft Production®: Centrone Sergio e Gadaleta Fabio
* Costruzione della classe per verificare se i file sono file txt o html
*/
public class ValidFileFilter implements FileFilter
{
public boolean accept(File file)
{
//Tentare le istruzioni senno restituisce un'eccezione
try
{
//Controlla se i file sono txt o html
if(file.getCanonicalPath().endsWith("txt") ||
file.getCanonicalPath().endsWith("htm") || file.getCanonicalPath().endsWith("html"))
return true;
}
//Cattura l'eccezione in caso l'Input o l'Output sono errati (o non trova file
di quel genere)
catch (IOException e)
{
e.printStackTrace();
}
//Senno' ritorna falso
return false;
}
}

11. PAROLA.CLASS
//importazione dei pacchetti che serviranno alla classe
import java.io.Serializable;
import java.util.ArrayList;
/**
* @author BaelSoft Production®: Centrone Sergio e Gadaleta Fabio
* Costruzione della classe Parola con serializzazione (per il salvataggio nel file)
*/
public class Parola implements Serializable
{
// Costruttori della classe Parola
public Parola(String parola)
{
this.parola = parola;
}
/**
* @param parola stringa dei file
* @param filePath percorso in cui si trova la stringa
*/
public Parola(String parola, String filePath)
{
this(parola);
files = new ArrayList<String>();
files.add(filePath);
}
//Metodi della classe Parola
public ArrayList<String> getPath()
{
return files;
}
/**
* Aggiunge il percorso del file
* @param filePath percorso del file
*/
public void AggiungiFile(String filePath)
{
files.add(filePath);
}
/**
* Questo metodo serve a restituire parola
* @return ridà ciò che contiene parola
*/
public String getParola()
{
return parola;
}
//Parametri della classe Parola
public String parola;
private ArrayList<String> files;
}