Création de fichier index pour recherche rapide

Télécharger le projet
Commenter

Description

Ce programme sert à faire une recherche très rapide.
Il crée des fichiers (.log avez vous une autre extension à me proposer) qui sont des index des volumes choisis.
Puis vous pouvez faire une recherche (rapide) sur les fichier index de votre choix.
Les fichiers trouvés sont placés dans un composant "list". Vous pouvez lancer un fichier trouvé par double clique.
Plusieurs options sont possible pour la recherche :
Ignorer les majuscules, Ignorer les espaces et Ignorer les accents.
Pour le moment, seulement quelques caractères accentués sont pris en compte (environ 6 ou 7) mais sa va venir.
D'après un copain, très pratique pour faire des index de CD-Rom archive. Pas besoin de m'être tous les CD l'un après l'autre dans le lecteur. Merçi de m'indiquer les options qui peuvent être utiles pour que je les rajoute.
Je sait que le code n'est pas très beau mais sa marche. Je suis débutant (c'est mon deuxième programme et mon premier poster) alors comprenez...
Je suis pas très fort en français même pour mon age (15 ans)...

Source / Exemple : 


import java.awt.* ;
import java.awt.event.* ;
import java.io.* ;
import java.util.Vector ;
import java.awt.datatransfer.* ;
 
public class index implements ActionListener, WindowListener, ItemListener, Runnable {

Frame F = new Frame("Index") ;
Toolkit tk = F.getToolkit() ;
Button B1 = new Button() ;
Button B2 = new Button() ;
Button B3 = new Button("Portée de la recherche") ;
TextField tf = new TextField() ;
List list = new List() ;
Label L = new Label() ;
PrintStream PS ; //écriture des fichiers indexation
File fichierIndex ; //fichier d'indexation
static File dossierIndex = new File("index") ; //Dossier où son ranger les fichiers d'indexation
String rech ; //mot à rechercher
Vector V = new Vector(8,5) ; 
int nombreDossier ; //compte rendu recherche 
int nombreFichier ;
StringBuffer SB = new StringBuffer() ;
String[] listvol ; //liste des volumes
String[] listindex = null; //liste des index
String extension = ".log" ; //extension pour les index
int mode = -1 ; //mode en cour (voir methode setMode)
Checkbox checkMaj = new Checkbox("Ignorer les majuscules",true) ;
Checkbox checkIgnoreSpace = new Checkbox("Ignorer les espaces") ;
Checkbox checkIgnoreAccent = new Checkbox("Ignorer les accents") ;
boolean ignoreMaj ;
boolean ignoreSpace ;
boolean ignoreAccent ;
Font FPetite = new Font("Sans",Font.PLAIN,10) ;
Font FGrosse = new Font("Sans",Font.PLAIN,12) ;
boolean tourne ;
boolean exit ;
int erreur = 0 ;

static {
	dossierIndex.mkdir() ;
}
	
	public static void main(String[] argv) {
		/*boolean graph = false ;
		if ((argv.length > 0) && (argv[0].equalsIgnoreCase("ui"))) {
			graph = true ;
		}
		new index(graph) ;*/
		new index() ;
	}
	//public index (boolean graph) {
	public index () {
		//if (graph) {
		F.addWindowListener(this) ;
			F.setLocation(300,100) ;
		Panel P = new Panel() ;
			P.setSize(440,420) ;
		P.setLayout(null) ;
		B1.addActionListener(this) ;
			B1.setBounds(20,20,140,20) ;
		B2.addActionListener(this) ;
			B2.setBounds(170,100,100,20) ;
		B3.addActionListener(this) ;
			B3.setBounds(280,100,140,20) ;
			B3.setActionCommand("portée") ;
		tf.addActionListener(this) ;
			tf.setBounds(20,100,140,20) ;
		list.addActionListener(this) ;
			list.addItemListener(this) ;
			list.setBounds(20, 140, 400, 260) ;
		checkIgnoreAccent.setBounds(280,10,150,20) ;
		checkIgnoreSpace.setBounds(280,40,150,20) ;
		checkMaj.setBounds(280,70,150,20) ;
		L.setBounds(20, 120, 400, 20) ;
		P.add(list) ; P.add(L) ; P.add(B1) ; P.add(B2) ; P.add(tf) ; P.add(B3) ; 
		P.add(checkMaj) ; P.add(checkIgnoreSpace) ; P.add(checkIgnoreAccent) ;
		F.add(P) ;
		setMode(0) ; //initialisation des composants graphiques
		 F.pack() ; F.setResizable(false) ; F.show() ;
		/*}
		else {
			execIndex() ;
			rech = "salut" ;
			recherche() ;
			Fermer() ;
		}*/
	}
	public void runThread() {
		Thread THR = new Thread(this) ;
		tourne = true ; 
		THR.start () ;
	}
	public void run() {
		if (mode == 4) { //execution du Thread d'indexation
			try {
				FileOutputStream FOS = new FileOutputStream(fichierIndex) ; //ouvre le flux de l'index à créer
				PS = new PrintStream(FOS) ; 
				for (int i = 0 ;(tourne) && (i < listvol.length) ; i++) {
					L.setText("Indexation de " + listvol[i]) ;
					File dir = new File(listvol[i]) ;
					PS.println(dir.getAbsolutePath()) ;
					indexdossier(dir,1) ;
				}
				PS.close() ; //ferme le flux
				if (! tourne) fichierIndex.delete() ;
			}
			catch (Exception e) {  /*erreur = 1*/ ; e.printStackTrace() ; } //*********************************************
			setMode(0) ;
			if (erreur != 0) L.setText(erreur + " erreur lors de l'indexation") ;
			tk.beep() ;
		}
		else if (mode == 1) { //recherche
			BufferedReader BR = null ;
			for ( int i = 0 ;(tourne) && (i < listindex.length) ; i++) {
				fichierIndex = new File(dossierIndex,listindex[i]) ;
				try {
					BR = new BufferedReader(new FileReader(fichierIndex)); //ouverture flux de lecture
					V.removeAllElements() ;
					String line ; //contient une ligne
					while (tourne && ((line = BR.readLine() ) != null)) Analyse(line) ; //Analyse la ligne
					BR.close() ; //femeture du flux
				}
				catch (Exception e) {
					System.out.println(fichierIndex) ;
					e.printStackTrace() ;
				}
			}
			traitResultat() ; //stastistique
			setMode(6) ;
		}
		if (exit) Fermer() ;
		tourne = false ;
	}
	public void recherche() {
		if ((listindex == null) && (mode != 5)) sourceRecherche() ;
		else execRecherche() ;
	}
	public void sourceRecherche() {
		list.removeAll() ;
		setMode(5) ;
		fichierExtension() ;
	}
	public void execRecherche() {
		if (mode == 5) listindex = list.getSelectedItems() ;
		if (listindex.length == 0) {
			L.setText("Aucun index selectionné pour effectuer la recherche") ;
			return ;
		}
		setMode(1) ;
		traiteOptions() ;
		nombreDossier = nombreFichier = 0 ; //compteur  à 0
		runThread() ; //lance la boucle de recherche dans un thread séparé
		//la fin du thread place le mode à 0
	}
	char[] charRech ;
	char[] charLine ;
	public boolean compare(String str) {
		if (ignoreMaj) str = str.toUpperCase() ;
		charLine = str.toCharArray() ;
		if (ignoreSpace) charLine = ignoreSpace(charLine) ;
		if (ignoreAccent) charLine = ignoreAccent(charLine) ;
		int i = 0 ;
		int y = 0 ;
		int espoir = -1 ;
		int c1 = charRech.length ;
		int c2 = charLine.length ;
		boolean esp = false ;
		while(true) {
			if (i == c1) return(true) ;
			if (y == c2) return(false) ;
			if (charLine[y] == charRech[i]){
				if (i == 0) { espoir = y ; esp = true ; }
				i++ ; y++ ;
			}
			else {
				if (esp) {
					y = espoir + 1 ; 
					i = 0 ;
					esp = false ;
				}
				else y++ ;
			}
		}
	}
	public void traiteOptions() {
		rech = tf.getText() ;
		ignoreMaj = checkMaj.getState() ;
		ignoreSpace = checkIgnoreSpace.getState() ;
		ignoreAccent = checkIgnoreAccent.getState() ;
		if (ignoreMaj) rech = rech.toUpperCase() ;
		charRech = rech.toCharArray() ; // transforme rech en tableau de caractères
		if (ignoreSpace) charRech = ignoreSpace(charRech) ;
		if (ignoreAccent) charRech = ignoreAccent(charRech) ;
	} 
	public char[] ignoreSpace(char[] ch) {
		int length = ch.length ;
		int y = 0 ;
		for (int i = 0; i < length ; i++ ) {
			if (! Character.isWhitespace(ch[i])) ch[y++] = ch[i] ;
		}
		if (length == y) return(ch) ;
		char[] retour = new char[y] ;
		System.arraycopy(ch,0,retour,0,y) ;
		return(retour) ;
	}
	public char[] ignoreAccent(char[] ch) {
		char c ;
		int length = ch.length ;
		for (int i = 0; i < length ; i++ ) {
			c = ch[i] ;
			if (c < 128) {
				SB.append(c) ; 
				continue ;
			}
			switch (c) { //**********************************
				case 'é' : 
				case 'è' :
				case 'ê' :
				case 'ë' : SB.append('e') ; break ;
				case 'à' : SB.append('a') ; break ;
				case 'ç' : SB.append('c') ; break ;
				case '?' : SB.append('o').append('e') ; break ;
				default : SB.append(c) ;
			}
		}
		length = SB.length() ;
		char[] retour = new char[length] ;
		SB.getChars(0,length,retour,0) ;
		SB.setLength(0) ;
		return(retour) ;
	}
	public void Analyse(String line) { //Analyse une ligne
		int i = 0 ;
		while (line.charAt(i) == '\t') { i++ ; }
		line = line.substring(i) ; //enleve les tabulations de la ligne
		boolean isDossier = line.endsWith("\\") ; //si dossier
		if (isDossier) { //met la ligne dans le vector au niveau du dossier
			if (V.size() == i ) V.addElement(line) ;
			else V.setElementAt(line, i) ;
		}
		if (compare(line)) { 
			for (int y = 0 ; y < i ; y++ ) {
				SB.append(V.elementAt(y)) ; //concaténe les éléments du path
			}
			if (isDossier) nombreDossier++ ; //met à jour le compte rendu de recherche
			else nombreFichier++ ;
			SB.append(line) ; //concaténe le nom du fichier au path
			list.addItem(SB.toString() ) ; //add à la list la chaine créée
			SB.setLength(0) ; //vide la chaine
		}
	}
	public void traitResultat() { //Créer des statistiques
		if (! tourne) {
			L.setText("Recherche annulée") ; 
			return ;
		}
		int nombreTotal = nombreDossier + nombreFichier ; //créer le total
		if (nombreTotal == 0) { //pas de résultat
			L.setText("Aucun resultat") ;
		}
		else {
			L.setText("Total : " + nombreTotal + " (" + nombreFichier +
							" Fichier(s), " + nombreDossier + " Dossier(s) )") ;
		}
	}
	public void ouvrirPath(String path) {
		File F = new File(path) ;
		if (! F.exists()) {
			L.setText("L'élément est introuvable") ; 
			return ;
		}
		L.setText("Ouverture...") ;
		path = '\"' + path + '\"' ; // guillemets, sinon start.exe echoue s'il y a un espace
		int pf = -1 ;
		String strOs = System.getProperty("os.name", "???") ;
		if ( strOs.equals("Mac OS") ) pf = 2 ; // Macintosh
		else if ( strOs.equals("Windows NT") ) pf = 1 ; // Windows NT, 2000 et XP
		else if ( strOs.equals("Windows 95") ) pf = 0 ; // Windows 95, 98 et Me
		boolean succes = false ;
		switch (pf) {
			case 0 : succes = startWin(path) ; break ;
			case 1 : succes = startNT(path) ; break ;
			default : L.setText("Ouverture sur la plate forme " + strOs + " non programmée") ;
		}
		if (! succes) L.setText("Echec de l'ouverture") ;
		else L.setText("") ;
	}
	public boolean startWin (String path) { // "start" lance l'exe lie a l'extension DOS (selon la base de registres)
		try { Runtime.getRuntime( ).exec (new String [] { "start ", path } ) ; } // lance la commande
		catch (IOException floc) { return (false) ; } // erreur : pas d'application, erreur commande = false
		return (true) ; 
	} // -------------------- fin de methode start 
	public boolean startNT (String path) { // "start" lance l'exe lie a l'extension DOS (selon la base de registres)
		try { Runtime.getRuntime( ).exec (new String [] { "cmd", "/c", "start", "\"\"",  path } ) ; }
		catch (IOException floc) { return (false) ; } // erreur : pas d'application, erreur commande = false
		return (true) ; 
	} // -------------------- fin de methode start
	public void actionPerformed(ActionEvent ae) {
		//Object source = ae.getSource() ;
		String command = ae.getActionCommand() ;
		if (command.equals("stop")) tourne = false ;
		else if (tourne) return ;
		else if (command.equals("getvol")) sourceIndex() ; //bouton 1 en mode 0(défault)
		else if (command.equals("saveas")) cibleIndex() ; //bouton 2 en mode 2(choix des volumes à indexer)
		else if (command.equals("lanceindexation")) execIndex() ; //bouton 2 en mode 3(choix fichier d'index)
		else if (command.equals("recherche")) recherche() ; //bouton 2 en mode 0,2,5(défault)
		else if (command.equals("portée")) { //bouton 3
			switch (mode) {
				case 0 :
				case 5 :
				case 6 : sourceRecherche() ;
			}
		}
		else if (command.equals("index0")) setMode(0) ;
		else {Object source =ae.getSource() ;
			if (source == tf) {
				switch (mode) {
					case 0 :
					case 5 :
					case 6 : recherche() ;
				}
			}
			else if (source == list) {
				switch (mode) {
					case 6 : ouvrirPath(command) ;
				}
			}
		}
	}
	public void itemStateChanged(ItemEvent ie)  {
		if (mode == 3) { //en mode de selection d'un fichier pour enregistrer l'index
			if (list.getSelectedIndex() == 0) tf.setText("index" + extension) ;
			else tf.setText(list.getSelectedItem()) ; //place le texte de l'item dans le text field
		}
	}
	public void setMode(int md) {
		if (md == mode) return ; //si mode inchanger : return ;
		switch (md) {
			case 0 : //Réinitialisation
				list.removeAll() ;
				tf.setText("") ;
				B1.setLabel("Indexer l'ordinateur") ;
				B1.setActionCommand("getvol") ;
				B2.setLabel("Rechercher") ;
				B2.setActionCommand("recherche") ;
				L.setText("") ;
				break ;
			case 1 : //Recherche en cours
				L.setText("Recherche en cours...") ;
				list.removeAll() ;
				B1.setLabel("Annuler") ;
				B1.setActionCommand("stop") ;
				list.setFont(FPetite) ;
				list.setMultipleMode(false) ;
				break ;
			case 2 : //Obtention des volumes
				L.setText("Selectionner les volumes à indexer et cliquer \"J'ai fini\" ") ;
				B1.setLabel("Annuler") ;
				B1.setActionCommand("index0") ;
				B2.setLabel("J'ai fini") ;
				B2.setActionCommand("saveas") ;
				list.setMultipleMode(true) ;
				list.removeAll() ;
				list.setFont(FGrosse) ;
				break ;
			case 3 : //demande d'emplacement et du nom de fichier pour l'enregistrement de l'index
				B2.setLabel("Enregistrer") ;
				B2.setActionCommand("lanceindexation") ;
				L.setText("Taper un nouveau nom ou cliquez sur un fichier existant") ;
				list.removeAll() ;
				list.setMultipleMode(false) ;
				break ;
			case 4 : //pendant l'indextation
				B1.setActionCommand("stop") ;
				B2.setLabel("Rechercher") ;
				B2.setActionCommand("rien") ;
				break ;
			case 5 : //porté de la recherche
				list.setMultipleMode(true) ;
				list.setFont(FGrosse) ;
				break ;
			case 6 : //fin de la recherche
				list.setMultipleMode(false) ;
				B1.setLabel("Indexer l'ordinateur") ;
				B1.setActionCommand("getvol") ;
		}
		mode = md ;
	}
	public void sourceIndex () { // obtenir la list des volumes dans la list
		setMode(2) ;
		listvol = getVolumes() ;
		for (int i = 0 ; i < listvol.length ; i++) {
			list.addItem(listvol[i]) ; //met dans la list tous les volumes
		}
	}
	public void cibleIndex() { //met dans la list les fichiers d'index déja créer
		listvol = list.getSelectedItems() ; //enregistrer les volumes selectionner pour l'indextation
		setMode(3) ;
		list.addItem("Fichier par défault(index" + extension + ")") ; //item fichier par défault
		fichierExtension() ;
	}
	public void fichierExtension() {
		String[] listfichier = dossierIndex.list() ; //demande la list du dossier des index
		for (int i = 0 ; i < listfichier.length ; i++) {
			if (listfichier[i].endsWith(extension)) {
				list.addItem(listfichier[i]) ; //propose les fichiers terminé par l'extension des index
			}
		}
	}
	public void execIndex () { //lance l'indextation avec les paramètre régler précédament
		String name = tf.getText() ; //nom pour enregistrer le fichier
		if (! name.endsWith(extension)) name += extension ; //rajoute l'extension si il n'y a pas
		fichierIndex = new File(dossierIndex, name) ; //créer le file du fichier index à créer
		setMode(4) ;
		runThread() ; //lance la boucle d'indextation dans un thread séparé
		//la fin du thread place le mode à 0
	}
	public String [] getVolumes () { // renvoie les noms des volumes montes
		char [] vol = new char [26] ; int count = 0 ; String sep = ":\\" ;
		for (char c = 'B' ; c < '[' ; c ++) { // essaie toutes les lettres de volumes
			if ( (new File (c + sep)).exists() ) vol [count ++] = c ; } 
		String [] ret = new String [count] ;
		for (int pif = 1 ; pif < count ; pif ++) ret [pif] = vol [pif] + sep ;
		ret [0] = "A" + sep ;
		return (ret) ; 
	}
	public void indexdossier (File dir, int j) { //index le dossier et les dossiers contenu en se rappelant
		try {
			String[] list = dir.list() ;
			int len = list.length ;
			for (int i = 0 ;(tourne) && (i < len) ; i++) {
				File F = new File(dir,list[i]) ;
				boolean b = F.isDirectory() ;
				traiteDonnées(F,j,b) ;
				if (b) {
					indexdossier(F,j+1) ;
				}
			}
		}
		catch (Exception e) {
			if (e.getMessage() == null) erreur = 2 ;
			else erreur++ ;
		}
	}	
	public void traiteDonnées(File F, int j, boolean b) { //écrit les donner récolter dans le fichier
		for (; j >0 ; j--) { //écrit le nbr de tabu en raport avec l'implementation
			PS.print('\t') ;
		}
		PS.print(F.getName()) ;
		if (b) PS.println('\\') ;
		else PS.println() ;
	}
	public void Fermer() { //créer si un jour y'a besoin de faire un truc avant de quitter
		if (tourne) {
			exit = true ;
			tourne = false ;
		}
		System.exit(0) ;
	}
    public void windowClosing (WindowEvent e) { 
            Fermer () ; }
    public void windowClosed (WindowEvent e) { }
    public void windowActivated (WindowEvent e) { }
    public void windowDeactivated (WindowEvent e) { }
    public void windowIconified (WindowEvent e) { }
    public void windowDeiconified (WindowEvent e) { }
    public void windowOpened (WindowEvent e) { }
}

Conclusion :


Bugs : je n'en connais pas mais je trouve le logiciel pas très pratique à utiliser.
Les composants sont mal ranger (encors en teste) mais sa va venir.
Prochaine mise à jour dans une ou deux semaine.
Commentaire bienvenu.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.