chansey123
Nouveau membre
Bonjour!
J'ai récemment eu à programmer une interface qui créait un Index avec deux ArrayList (1 pour l'element, 1 pour la position de l'element dans l'index). J'ai terminé cette interface de multiples méthodes avec succès et elle ressemble à ceci :
/**
* Implementation de TDAIndex.
*
* Un index est un ensemble dans lequel il y a des elements de type <T>. Chaque element est accompagne d'un entier ou plusieurs qui peuvent corresponde a
* un numero de ligne, un numero de page, etc.
*
* @author
* @version
*/
import java.util.ArrayList;
public class Index<T> implements TdaIndex<T> {
private ArrayList<T> elements; // les elements (pas de doublons)
private ArrayList<ArrayList<Integer>> listesNumeros; // les numeros pour chaque elements
public Index () {
elements = new ArrayList<T>();
listesNumeros = new ArrayList<ArrayList<Integer>>();
}
/**
* Retourne true si cet index est vide.
* @return true si cet index est vide, false sinon
*/
public boolean estVide () {
return elements.isEmpty();
}
/**
* Vide cet index
*/
public void vider () {
elements.clear();
listesNumeros.clear();
}
/**
* Retourne le nombre d'elements distincts
* @return le nombre d'elements distincts de cet index
*/
public int nombreDistincts () {
return elements.size();
}
/**
* Retourne le nombre total d'elements
* @return le nombre total d'elements incluant les doublons
*/
public int nombreTotal () {
// On pourrait aussi maintenir un compteur. On ne serait pas obliges alors de faire cette boucle
int reponse = 0;
for ( int i = 0; i < listesNumeros.size(); ++i ) {
reponse += listesNumeros.get(i).size(); // nombre de numeros accompagnant le i-eme element
}
return reponse;
}
/**
* Ajoute l'element avec son numero
* @param element element a ajouter
* @param numero numero accompagnant l'element
* @return true s'il s'agit d'un nouvel element, false si l'element est deja dans l'index.
*/
public boolean ajouter ( T element, int numero ) {
int pos = elements.indexOf ( element );
boolean estAbsent = pos == -1;
if ( estAbsent ) {
// ajouter ce nouvel element
pos = elements.size();
elements.add ( element );
// preparer sa liste de numeros
listesNumeros.add ( new ArrayList<Integer>() ); // liste vide
}
// pos contient la position de l'element (nouveau ou non) dans sa liste
listesNumeros.get(pos).add ( numero );
return estAbsent;
}
/**
* Retire le numero (une occurrence) accompagnant l'element. Les autres numeros demeurent avec l'element le cas echeant.
* @param element element a retirer
* @param numero numero accompagnant l'element.
* @return true si le retrait s'est effectue avec succes (element present et numero present), false si le numero ou l'element n'existe pas.
*/
public boolean retirer ( T element, int numero ) {
boolean reponse = false;
int pos = elements.indexOf ( element );
if ( pos >= 0 ) {
// element present a la position pos
reponse = listesNumeros.get ( pos ).remove ( (Integer) numero ); // enleve une occurrence si numero present
if ( listesNumeros.get ( pos ).isEmpty() ) {
// s'il ne reste aucun numero avec l'element, il faut retirer cet element ainsi que sa liste vide de numeros
listesNumeros.remove ( pos );
elements.remove ( pos );
}
}
return reponse;
}
/**
* Retire completement l'element de l'index.
* @param element element a retirer
* @return true si le retrait s'est effectue avec succes, false si l'element n'existe pas.
*/
public boolean retirer ( T element ) {
boolean reponse = false;
int pos = elements.indexOf ( element );
if ( pos >= 0 ) {
// element present
elements.remove ( pos );
listesNumeros.remove ( pos );
reponse = true;
}
return reponse;
}
/**
* Retourne l'union de cet index avec celui en parametre.
* @param autre TdaIndex avec lequel faire l'union
* @return le nouvel index resultat de l'union de cet index avec autre.
*/
public TdaIndex<T> union ( TdaIndex<T> autre ) {
Index<T> reponse = new Index<T>();
// copier integralement this dans reponse
for ( int i = 0; i < elements.size(); ++i ) {
reponse.elements.add ( elements.get(i) );
ArrayList<Integer> laListeDeNumerosDeElementI = listesNumeros.get(i);
ArrayList<Integer> laCopie = new ArrayList<Integer>();
for ( int j = 0; j < laListeDeNumerosDeElementI.size(); ++j ) {
laCopie.add ( laListeDeNumerosDeElementI.get(j) );
}
reponse.listesNumeros.add ( laCopie );
}
// ajouter les elements et leurs numeros contenus dans l'index autre
// (version non optimisee)
for ( int i = 0; i < ((Index<T>)autre).elements.size(); ++i ) {
T elem = ((Index<T>)autre).elements.get ( i );
ArrayList<Integer> laListeDeNumerosDeElementI = ((Index<T>)autre).listesNumeros.get(i);
for ( int j = 0; j < laListeDeNumerosDeElementI.size(); ++j ) {
reponse.ajouter ( elem, laListeDeNumerosDeElementI.get ( j ) );
}
}
return reponse;
}
/**
* Retourne true si cet index contient l'element
* @param element element a verifier
* @return true si element est dans l'index, false sinon
*/
public boolean estElement ( T element ) {
return elements.indexOf ( element ) >= 0;
}
/**
* Retourne le nombre de numeros accompagnant l'element dans cet index.
* @param element element a verifier
* @return le nombre de numeros accompagnant l'element dans cet index.
*/
public int nbApparitions ( T element ) {
int reponse = 0;
int pos = elements.indexOf ( element );
if ( pos >= 0 ) {
reponse = listesNumeros.get ( pos ).size();
}
return reponse;
}
/**
* Retourne le tableau de numeros accompagnant l'element dans cet index.
* @param element element pour lequel on veut les numeros
* @return le tableau de numeros accompagnant l'element dans cet index.
*/
public int[] lesNumeros ( T element ) {
int [] reponse;
int pos = elements.indexOf ( element );
if ( pos == -1 ) {
// element absent, donc aucun numero qui l'accompagne
reponse = new int [0]; // tableau de longueur 0
} else {
ArrayList<Integer> liste = listesNumeros.get ( pos );
reponse = new int [ liste.size() ];
for ( int i = 0; i < liste.size(); ++i ) {
reponse [ i ] = liste.get(i);
}
}
return reponse;
}
/**
* Retourne le tableau d'elements de cet index.
* @return le tableau d'elements de cet index.
*/
public T[] lesElements () {
T[] reponse = (T[])(new Object[elements.size()]);
for ( int i = 0; i < reponse.length; ++i ) {
reponse = elements.get(i);
}
return reponse;
}
/**
*
*
*/
public String toString () {
String reponse = "";
for ( int i = 0; i < elements.size(); ++i ) {
reponse += elements.get(i).toString() + '\n' + " ";
ArrayList<Integer> liste = listesNumeros.get ( i );
for ( int j = 0; j < liste.size(); ++j ) {
reponse += liste.get ( j ) + " ";
}
reponse += '\n';
}
return reponse;
}
} // Index
--------------------------------
Maintenant avec ces méthodes, je dois faire un nouveau programme qui prends un fichier de commandes.txt et qui sort ensuite un fichier resultats.txt. Dans le nouveau programme il y a deux methodes que je ne sais plus trop comment programmer, je crois que ça fait trop longtemps que j'regarde du code et je n'y voit plus clair. :S
1. Une méthode qui prends un numéro et qui affiche tous les mots associés à ce numéro de l'index.
2. Une méthode qui affiche tous les mots qui n'ont qu'un seul numéro.
Si vous pouviez m'aider ce serait grandement apprécié...
Merci d'avance!!
-Chansey
J'ai récemment eu à programmer une interface qui créait un Index avec deux ArrayList (1 pour l'element, 1 pour la position de l'element dans l'index). J'ai terminé cette interface de multiples méthodes avec succès et elle ressemble à ceci :
/**
* Implementation de TDAIndex.
*
* Un index est un ensemble dans lequel il y a des elements de type <T>. Chaque element est accompagne d'un entier ou plusieurs qui peuvent corresponde a
* un numero de ligne, un numero de page, etc.
*
* @author
* @version
*/
import java.util.ArrayList;
public class Index<T> implements TdaIndex<T> {
private ArrayList<T> elements; // les elements (pas de doublons)
private ArrayList<ArrayList<Integer>> listesNumeros; // les numeros pour chaque elements
public Index () {
elements = new ArrayList<T>();
listesNumeros = new ArrayList<ArrayList<Integer>>();
}
/**
* Retourne true si cet index est vide.
* @return true si cet index est vide, false sinon
*/
public boolean estVide () {
return elements.isEmpty();
}
/**
* Vide cet index
*/
public void vider () {
elements.clear();
listesNumeros.clear();
}
/**
* Retourne le nombre d'elements distincts
* @return le nombre d'elements distincts de cet index
*/
public int nombreDistincts () {
return elements.size();
}
/**
* Retourne le nombre total d'elements
* @return le nombre total d'elements incluant les doublons
*/
public int nombreTotal () {
// On pourrait aussi maintenir un compteur. On ne serait pas obliges alors de faire cette boucle
int reponse = 0;
for ( int i = 0; i < listesNumeros.size(); ++i ) {
reponse += listesNumeros.get(i).size(); // nombre de numeros accompagnant le i-eme element
}
return reponse;
}
/**
* Ajoute l'element avec son numero
* @param element element a ajouter
* @param numero numero accompagnant l'element
* @return true s'il s'agit d'un nouvel element, false si l'element est deja dans l'index.
*/
public boolean ajouter ( T element, int numero ) {
int pos = elements.indexOf ( element );
boolean estAbsent = pos == -1;
if ( estAbsent ) {
// ajouter ce nouvel element
pos = elements.size();
elements.add ( element );
// preparer sa liste de numeros
listesNumeros.add ( new ArrayList<Integer>() ); // liste vide
}
// pos contient la position de l'element (nouveau ou non) dans sa liste
listesNumeros.get(pos).add ( numero );
return estAbsent;
}
/**
* Retire le numero (une occurrence) accompagnant l'element. Les autres numeros demeurent avec l'element le cas echeant.
* @param element element a retirer
* @param numero numero accompagnant l'element.
* @return true si le retrait s'est effectue avec succes (element present et numero present), false si le numero ou l'element n'existe pas.
*/
public boolean retirer ( T element, int numero ) {
boolean reponse = false;
int pos = elements.indexOf ( element );
if ( pos >= 0 ) {
// element present a la position pos
reponse = listesNumeros.get ( pos ).remove ( (Integer) numero ); // enleve une occurrence si numero present
if ( listesNumeros.get ( pos ).isEmpty() ) {
// s'il ne reste aucun numero avec l'element, il faut retirer cet element ainsi que sa liste vide de numeros
listesNumeros.remove ( pos );
elements.remove ( pos );
}
}
return reponse;
}
/**
* Retire completement l'element de l'index.
* @param element element a retirer
* @return true si le retrait s'est effectue avec succes, false si l'element n'existe pas.
*/
public boolean retirer ( T element ) {
boolean reponse = false;
int pos = elements.indexOf ( element );
if ( pos >= 0 ) {
// element present
elements.remove ( pos );
listesNumeros.remove ( pos );
reponse = true;
}
return reponse;
}
/**
* Retourne l'union de cet index avec celui en parametre.
* @param autre TdaIndex avec lequel faire l'union
* @return le nouvel index resultat de l'union de cet index avec autre.
*/
public TdaIndex<T> union ( TdaIndex<T> autre ) {
Index<T> reponse = new Index<T>();
// copier integralement this dans reponse
for ( int i = 0; i < elements.size(); ++i ) {
reponse.elements.add ( elements.get(i) );
ArrayList<Integer> laListeDeNumerosDeElementI = listesNumeros.get(i);
ArrayList<Integer> laCopie = new ArrayList<Integer>();
for ( int j = 0; j < laListeDeNumerosDeElementI.size(); ++j ) {
laCopie.add ( laListeDeNumerosDeElementI.get(j) );
}
reponse.listesNumeros.add ( laCopie );
}
// ajouter les elements et leurs numeros contenus dans l'index autre
// (version non optimisee)
for ( int i = 0; i < ((Index<T>)autre).elements.size(); ++i ) {
T elem = ((Index<T>)autre).elements.get ( i );
ArrayList<Integer> laListeDeNumerosDeElementI = ((Index<T>)autre).listesNumeros.get(i);
for ( int j = 0; j < laListeDeNumerosDeElementI.size(); ++j ) {
reponse.ajouter ( elem, laListeDeNumerosDeElementI.get ( j ) );
}
}
return reponse;
}
/**
* Retourne true si cet index contient l'element
* @param element element a verifier
* @return true si element est dans l'index, false sinon
*/
public boolean estElement ( T element ) {
return elements.indexOf ( element ) >= 0;
}
/**
* Retourne le nombre de numeros accompagnant l'element dans cet index.
* @param element element a verifier
* @return le nombre de numeros accompagnant l'element dans cet index.
*/
public int nbApparitions ( T element ) {
int reponse = 0;
int pos = elements.indexOf ( element );
if ( pos >= 0 ) {
reponse = listesNumeros.get ( pos ).size();
}
return reponse;
}
/**
* Retourne le tableau de numeros accompagnant l'element dans cet index.
* @param element element pour lequel on veut les numeros
* @return le tableau de numeros accompagnant l'element dans cet index.
*/
public int[] lesNumeros ( T element ) {
int [] reponse;
int pos = elements.indexOf ( element );
if ( pos == -1 ) {
// element absent, donc aucun numero qui l'accompagne
reponse = new int [0]; // tableau de longueur 0
} else {
ArrayList<Integer> liste = listesNumeros.get ( pos );
reponse = new int [ liste.size() ];
for ( int i = 0; i < liste.size(); ++i ) {
reponse [ i ] = liste.get(i);
}
}
return reponse;
}
/**
* Retourne le tableau d'elements de cet index.
* @return le tableau d'elements de cet index.
*/
public T[] lesElements () {
T[] reponse = (T[])(new Object[elements.size()]);
for ( int i = 0; i < reponse.length; ++i ) {
reponse = elements.get(i);
}
return reponse;
}
/**
*
*
*/
public String toString () {
String reponse = "";
for ( int i = 0; i < elements.size(); ++i ) {
reponse += elements.get(i).toString() + '\n' + " ";
ArrayList<Integer> liste = listesNumeros.get ( i );
for ( int j = 0; j < liste.size(); ++j ) {
reponse += liste.get ( j ) + " ";
}
reponse += '\n';
}
return reponse;
}
} // Index
--------------------------------
Maintenant avec ces méthodes, je dois faire un nouveau programme qui prends un fichier de commandes.txt et qui sort ensuite un fichier resultats.txt. Dans le nouveau programme il y a deux methodes que je ne sais plus trop comment programmer, je crois que ça fait trop longtemps que j'regarde du code et je n'y voit plus clair. :S
1. Une méthode qui prends un numéro et qui affiche tous les mots associés à ce numéro de l'index.
2. Une méthode qui affiche tous les mots qui n'ont qu'un seul numéro.
Si vous pouviez m'aider ce serait grandement apprécié...
Merci d'avance!!
-Chansey
