Discussion :

[blackhock]

Bonjour à tous, je viens vous voir pour un petit souci mais qui me bloque énormément :
J’ai deux tableaux de strings qui ne sont pas égaux, je veux récupérer les chaînes de caractères qui existe dans un tableaux mais pas dans l’autre (la différence entre les deux), voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
public class Test {
 
	private String[] toto = { "a", "b", "c", "d" };
	private String[] titi = { "a", "b", "c" };
 
	public String test() {
 
		for (int i = 0; i < toto.length; i++) {
			for (int j = 0; j < titi.length; j++) {
				if (!toto[i].equals(titi[j])) {
				System.out.println("\""
						+ toto[i]
						+ " \""
							+ " est la seule chaîne de caractères qui ne fait pas parti de titi");
				}
			}
		}
		return null;
 
	}
 
	public String[] getToto() {
		return toto;
	}
 
	public String[] getTiti() {
		return titi;
	}
}

Je veux récupérer le string ‘’d’’ mais à la compilation j’ai :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
"a " est la seule chaîne de caractères qui ne fait pas parti de titi
"a " est la seule chaîne de caractères qui ne fait pas parti de titi
"b " est la seule chaîne de caractères qui ne fait pas parti de titi
"b " est la seule chaîne de caractères qui ne fait pas parti de titi
"c " est la seule chaîne de caractères qui ne fait pas parti de titi
"c " est la seule chaîne de caractères qui ne fait pas parti de titi
"d " est la seule chaîne de caractères qui ne fait pas parti de titi
"d " est la seule chaîne de caractères qui ne fait pas parti de titi
"d " est la seule chaîne de caractères qui ne fait pas parti de titi

Pourriez-vous m’aider svp merci

[gifffftane]

Et avec un débugueur tu ne vois rien ?

En tous les cas, je pense que il se passe la chose suivante :

• première chaine examinée de toto est a
• comparée à la premiere chaine de titi qui est a ; c'est égal, donc on passe à la suivante de titi
• comparée à la deuxième chaîne de titi qui est b : c'est pas égal, donc on considère que a est une chaîne unique

Donc c'est pas bon

[blackhock]

Tout a fait je suis d'accord, j'ai compris le fonctionnement mais comment je peux faire pour récupérer ma chaine de caractères que je veux, je sais que c'est un problème d'indentation des boucles mais comment faire?
Merci à tous

[arnaud036]

Voici un exemple que j'ai fais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args) {
 
		String[] toto = { "a", "b", "c", "d", "e"};
		String[] titi = { "a", "b", "c" };
 
		for (int i = 0; i < toto.length; i++) {
			if(Arrays.binarySearch(titi, toto[i]) >= 0){
				continue;
			}
			else System.out.println("\""
					+ toto[i]
							+ " \""
							+ " est la seule chaîne de caractères qui ne fait pas parti de titi");
			}
	}

maintenant que je t'ai donnée les basses adapte le pour le faire sur les deux tableaux et ensuite supprimée les doublons

Si tu as des problèmes n'hésite pas !

[CyberChouan]

Pourquoi des tableaux et non pas des listes ?

La méthodes "contains()" de ces dernières faciliterait grandement ton travail.

[blackhock]

Merci pour toutes vos réponses, mais quand je change l'ordre dans mes tableaux j'obtiens pas le résultat souhaité:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
	public static void main(String[] args) {
 
		String[] toto = { "a", "b", "c", "d", "e" };
		String[] titi = { "c", "a", "b" };
 
		for (int p = 0; p < toto.length; p++) {
			if (Arrays.binarySearch(titi, toto[p]) >= 0) {
				continue;
			} else
				System.out.println("\"" + toto[p] + " \"");
		}
	}

et j'obtiens

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 "c "
"d "
"e "

Je ne sais pas trop pourquoi...?, encore merci
Cordialement

[jean.2edi]

1. Que tes tableaux soient triés ou non change beaucoup ton algorithme !
2. Pourquoi coder ce que d'autres ont déjà fait :
   
   • Tu peux mettre ta première liste dans une Map puis chercher chaque élément de la seconde.
   • Tu peux utiliser des bibliothèques existante comme Apache Commons Collections, voici ta liste en une seule ligne de code:
     

     Code :

     Sélectionner tout - Visualiser dans une fenêtre à part

     Collection r = CollectionUtils.subtract(Arrays.asList(toto), Arrays.asList(titi));

[blackhock]

Bonjour à tous et merci pour toutes vos réponses,
J’ai essayé d’utiliser les collections ou bien les listes malheureusement je n’arrive pas, j’ai un message d’erreur sur CollectionUtils. Je ne sais pas trop pourquoi ?? je rappelle que mes tableaux ne sont pas triés et que je veux bosser avec des listes si ça facilite les choses.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
	public static void main(String[] args) {
 
		String[] toto = { "a", "b", "c", "d", "e" };
		String[] titi = { "c", "a", "b" };
 
		/** ****** */
		Collection r = CollectionUtils.subtract(Arrays.asList(toto), Arrays.asList(titi));
		/** ****** */
		List<String> List1 = Arrays.asList(toto);
		List<String> List2 = Arrays.asList(titi);
		for (String str2 : List2) {
			for (String str1 : List1) {
				if (List1.contains(List2)) {
					System.out.println(str1);
				} 
			}
		}
	}

Encore Merci à tous

[nouknouk]

salut,

c'est pas optimisé du tout, mais ça devrait marcher:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
public static void main(String[] args) {
 
    String[] toto = { "a", "b", "c", "d", "e" };
    String[] titi = { "c", "a", "b", "f" };
 
    // on cherche ce qu'il n'y a que dans toto
    for (int p = 0; p < toto.length; p++) {
        int q;	
        for (q = 0; q < titi.length; q++) {
            if (toto[p].equals(titi[q]))
                break;
                // doublon trouvé.
                // on sort prématurément de la boucle ; q < titi.length
        }
        if (q== titi.length ) {
            // on a parcouru tout titi sans trouver toto[p]
            System.out.println("'" + toto[p] + "' n'existe que dans toto");
        }
    }
 
 
    // on cherche ce qu'il n'y a que dans titi
    for (int p = 0; p < titi.length; p++) {
        int q;
        for (q = 0; q < toto.length; q++) {
            if (titi[p].equals(toto[q]))
                break;
                // doublon trouvé.
                // on sort prématurément de la boucle ; q < toto.length
        }
        if (q== toto.length) {
            // on a parcouru tout toto sans trouver titi[p]
            System.out.println("'" + titi[p] + "' n'existe que dans titi");
        }
    }
}

'd' n'existe que dans toto
'e' n'existe que dans toto
'f' n'existe que dans titi

Après tout dépend de tes besoins:
- si ta fonction est appelée 10 000 fois par seconde sur des listes de 50 000 entrées de 1000 caractères chacune, ça vaut le coup de se creuser la tête pour optimiser.
- si ta fonction est appelée une fois tous les 34 du mois, pour 5 chaînes de 10 caractères, un algo basique comme celui ci-dessus sera largement suffisant.

[blackhock]

Merci à tous pour votre aide, encore Merci