Problème de choix d'une structure de données

Version imprimable

18/10/2016, 21h09
master4

Problème de choix d'une structure de données

Bonsoir !

Je voudrais implémenté le moteur d'inférence 0 en chaînage avant (système expert) en java. Le problème que j'ai, c'est que je n'arrive pas à trouver une structure de données avec laquelle je pourrais le faire.
Par exemple, j'ai la base de faits suivante :
ABC->D
BE->F
GD->F
A->H
B->C
FH->I
G->B

Contenue dans un fichier txt. Je voudrais donc extraire son contenu pour l'enregistrer dans une structure de données (qui est mon problème) sous ce format :
- D = clé avec doublons
- ABC = valeurs

Je voudrais en fait, une structure qui pourrait contenir des doublons (2è, et 3è ligne). J'ai déjà essayé avec Hashtable, HashMap mais ça n'a pas marché.

Merci !

Salut,

Une Map (oublie la Hashtable, c'est une vieille classe qu'il ne vaut mieux plus utiliser) permet effectivement d'associer une clef avec une valeur, la clef ne pouvant être qu'unique (entre autres, parce qu'elle doit aussi être non mutable). Mais on peut contourner ce problème lorsqu'on veut plusieurs clefs de même valeur : on peut faire une Map telle que la valeur est une Collection (List, Set, selon les besoins).

On peut déclarer la map comme ça par exemple :

Code:

Map<String, List<String>> map = new HashMap<>();

Pour ajouter un mapping :
Code:

1 2 3 4 5 6 7 8 9 public static void add(Map<String, List<String>> map, String key, String value) { map.compute(key, (k,list)-> { if ( list==null ) list=new ArrayList<String>(); list.add(value); return list; } ); }
ou
Code:

1 2 3 4 5 6 7 8 9 public static void add(Map<String, List<String>> map, String key, String value) { map.merge(key, new ArrayList<>(Arrays.asList(value)), (list,newList)-> { list.addAll(newList); return list; } ); }
Enfin, pour l'utiliser :
Code:

1 2 3 4 5 6 7 8 9 10 Map<String, List<String>> map = new HashMap<>(); add(map, "key1", "value1"); add(map, "key1", "value2"); add(map, "key2", "value1"); add(map, "key2", "value2"); add(map, "key2", "value3"); add(map, "key3", "value3"); System.out.println(map);
Affiche :

Citation:

{key1=[value1, value2], key2=[value1, value2, value3], key3=[value3]}

18/10/2016, 22h23
master4

Merci beaucoup cette prompte réponse. Je l'implémente d'abord...

Je viens de l'insérer dans mon code mais j'ai du rouge partout et je n'arrive pas à le déboguer. Stp, pourrais-tu me donner quelque chose de plus simple. Je ne pas vraiment trop bon en java. Je t'envoie une partie du code pour plus de clarté.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class Test {
 
	public static void main(String[] args) throws IOException {
		/*
		 * Voici ce qu'il me faut faire
		 * Je dois lire ce fichier .txt
		 * Ce fichier contient plusieurs lignes et son format est coe ceci : ABC -> D
		 * Il pourrait y arriver que j'ai aussi une autre ligne qui se termine par D. ex : CA->D
		 * Ce qu'il me faut donc faire, c'est d'extraire le contenu de ce fichier afin de le stocker dans une
		 * structure avec la possibilité d'avoir les doublons coe dans l'exemple ci-dessus.
		 * Et à partir de là, je pourrais faire mes tests. 
		 */
                // Ici, je lis le fichier
		Path path_br = Paths.get("files/br.txt");
 
		// Je stocke le fichier dans une List "lines_br"
		List<String> lines_br = Files.readAllLines(path_br, StandardCharsets.ISO_8859_1);	
 
                /*
                 *Cette partie du code me permet de séparer (ABC) et (->) et (D), pour pouvoir utiliser D coe clé et ABC coe valeur
                 * C'est donc à partir d'ici que je voudrais avoir une structure de données pour le faire.
                 */
		String extracted = null, extracted2=null;
 
		bf.addAll(lines_bf);
		br.addAll(lines_br);
 
		// Extraction des premisses 
		for(int i = 0;  i<lines_br.size(); i++){			
			String line = lines_br.get(i);
			String str = line;
			String str1 = line;
			extracted = str.substring(str.indexOf(i)+1, str.lastIndexOf("-"));			
			extracted2 = str1.substring(str1.indexOf("-")+1);
 
			ext.concat(extracted)
 
 
 
		}
 
 
 
	}

Déjà, regardons ton code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Test {
 
	public static void main(String[] args) throws IOException {
		Path path_br = Paths.get("files/br.txt");
		List<String> lines_br = Files.readAllLines(path_br, StandardCharsets.ISO_8859_1);	
 
		String extracted = null, extracted2=null;
 
		bf.addAll(lines_bf); // bf n'existe pas ! lines_bf n'existe pas !
		br.addAll(lines_br); // br n'existe pas
 
		// Extraction des premisses 
		for(int i = 0;  i<lines_br.size(); i++){			
			String line = lines_br.get(i);
			String str = line; // pourquoi  créer autant de chaînes ? tu peux faire directement le traitement sur line...
			String str1 = line;
			extracted = str.substring(str.indexOf(i)+1, str.lastIndexOf("-"));			
			extracted2 = str1.substring(str1.indexOf("-")+1);
 
			ext.concat(extracted) // ext n'existe pas
 
		}
 
	}

Tu crées trop de variables intermédiaires. Toi qui chercher la simplicité, tu devrais au contraire limiter le nombre de variables. De plus, il y a plein de variables qui sont déclarées nulle part, donc qui n'existent pas !

Code:

1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) throws IOException {
		Path path_br = Paths.get("files/br.txt");
		List<String> lines_br = Files.readAllLines(path_br, StandardCharsets.ISO_8859_1);	
 
		for(int i = 0;  i<lines_br.size(); i++){			
			String line = lines_br.get(i);
			String str = line; // pourquoi  créer autant de chaînes ? tu peux faire directement le traitement sur line...
 
                        String[] splitted  = line.split("->");
 
		}
}

Pour couper la chaîne en deux, en prenant -> comme séparateur, on peut faire String[] splitted = line.split("->");.
splitted[0] est la partie à gauche, et splitted[1] celle de droite. C'est super simple (et plus simple que tous ces substring() et indexof()), non ?

Ensuite, si tu cherches plus simple que ce que j'ai écrit dans mon premier message, tu peux faire comme ça :

Code:

1
2
3
4
5
6
7
8
public static void add(Map<String,List<String>> map, String key, String value) {
     List<String> list = map.get(key); // on cherche la liste associée à key
     if ( list==null ) { // si la liste est null, c'est qu'il n'y a pas encore de liste associée
         list = new ArrayList<>(); // on la créé donc
         map.put(key, list); // on la met dans la map, en l'associant à la clef
     }
     list.add(value); // on ajoute la valeur dans la liste
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public static void main(String[] args) throws IOException {
		Path path_br = Paths.get("files/br.txt");
		List<String> lines_br = Files.readAllLines(path_br, StandardCharsets.ISO_8859_1);	
 
                Map<String, List<String>> map = new HashMap<>(); 
		for(int i = 0;  i<lines_br.size(); i++){			
			String line = lines_br.get(i);
			String str = line; // pourquoi  créer autant de chaînes ? tu peux faire directement le traitement sur line...
 
                        String[] splitted  = line.split("->");
 
                        add(map, splitter[1], splitted[0]);
 
		}
 
 
 
}
 
public static void add(Map<String,List<String>> map, String key, String value) {
     List<String> list = map.get(key); // on cherche la liste associée à key
     if ( list==null ) { // si la liste est null, c'est qu'il n'y a pas encore de liste associée
         list = new ArrayList<>(); // on la créé donc
         map.put(key, list); // on la met dans la map, en l'associant à la clef
     }
     list.add(value); // on ajoute la valeur dans la liste
}