les boucles for en java

Version imprimable

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:

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:

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

08/05/2009, 22h39
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:pan:
08/05/2009, 23h37
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

Voici un exemple que j'ai fais:

Code:

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 !

09/05/2009, 14h40
CyberChouan

Pourquoi des tableaux et non pas des listes ?

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

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

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:

1 2 3 "c " "d " "e "
Je ne sais pas trop pourquoi...?, encore merci
Cordialement

11/05/2009, 11h21
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:
    
    Collection r = CollectionUtils.subtract(Arrays.asList(toto), Arrays.asList(titi));

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:

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

salut,

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

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
 
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");
        }
    }
}

Citation:

'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.

12/05/2009, 14h04
blackhock

Merci à tous pour votre aide, encore Merci