Ajout d'un élément dans un tableau.

Version imprimable

Bonjour à tous,

Nouvel étudiant en école d'ingénieur, j'apprends le Java depuis quelques semaines.

Aujourd'hui j'essaye de terminer mon TP1 et je bute sur deux lignes de code (j'ai pour habitude d'écrire mes programmes en python, de les tester avec un interpréteur et ensuite de retranscrire dans le language désiré par l'enseignant).
Code:

1 2 3 4 5 6 7 // Boucle 'pour' partant de notre n "actuel" et ce décrémentant petit à petit pour donner, au premier passage par exemple, la deuxième ligne de mon PDF (celle en dessous du 'n' solitaire). for(int nombre = difference; nombre > 0; nombre--){ // Création de l'objet 'enfant' héritant de la classe branche. Branche enfant = new Branche(); //On met 'nombre' dans un tableau d'un élément monodimensionnel pour pouvoir l'ajouter à 'tableauListe'. tableauNombre[0] = nombre; enfant.tableauListe = branche.tableauListe.concat(tableauNombre);
C'est la dernière ligne qui affiche le message d'erreur suivant : - Cannot invoke concat(int[]) on the array type int[].

Je désirais ajouter le chiffre contenu dans la variable "nombre" à la fin de mon tableauListe (déclaré précédemment), en ajoutant un élément au tableauListe et cet élément prenant la valeur nombre. Ensuite je range tout ça dans ma variable "enfant.tableauListe" car j'utilise un arbre pour décomposer un nombre n en k partitions.

Je précise que j'ai aussi essayé la fonction push(), qui m'affiche le même message d'erreur.
J'ai essayé aussi de laisser 'nombre' en 'int' et de l'ajouter grossièrement avec un simple '+' ou à travers la fonction concat() ou en encore push().

Deuxième problème similaire :
Code:

1 2 // La fonction 'Push' va ajouter une nouvelle case, un nouvel élément, à la fin du tableau enfant avec la valeur entre parenthèses. branche.tableauEnfant.push(tableauEnfant);
Ici je souhaitais
Sur python j'utilisais

Code:

branche.enfant.append(enfant)

Je précise que bien évidemment mon programme tournait sur Python :ccool:

Je précise aussi avoir lu entièrement le manuel du site du 0 sur le Java (nos cours en amphithéâtres ne sont pas suffisant pour comprendre les TP ...) mais ces subtilitées n'y sont pas abordées ou du moins pas noir sur blanc et je n'ai pas compris :cry:

D'avance merci,

Bonne soirée,

Cordialement,

Ferrari Ugo

24/10/2013, 17h35
supergeoffrey

Citation:

C'est la dernière ligne qui affiche le message d'erreur suivant : - Cannot invoke concat(int[]) on the array type int[].

La méthode concat tableau exite pas en java.
Ta une solution la : http://www.developpez.net/forums/d68...-ner-tableaux/

Le deuxième problème je ne le comprend pas
24/10/2013, 17h57
joel.drigo

Salut,

les tableaux en java ne sont pas de tailles variables !!!

une alternative est d'utiliser une ArrayList : elle utilise un tableau en interne et le fait évoluer au besoin.

Une ArrayList étant une implémentation de List, elle implémente ses méthodes de manipulation de liste (ajout (add(element)), suppression (remove(element) ou remove(index)), insertion(add(index, element), suppression d'un intervalle(sublist(debut,fin exclue).clear()), etc...)

Les tableaux c'est fait pour gérer des listes d'éléments de taille fixe : tu peux utiliser une ArrayList pour construire ton "tableau de taille variable" puis passer à la fin à un tableau lorsqu'il ne change plus de taille par toArray(T[])
24/10/2013, 21h23
abj8077

C’est quoi ton code complet ?
Pour rajouter un tableau c’est mieux d’utiliser une liste (arrayList)
Mais ton cas je ne comprends pas bien, tu crées un objet enfant à chaque itération.
Si ton tableauNombre[0] est un élément d’un tableau, tu peux le rajouter directement !!!
24/10/2013, 23h17
tchize_
Citation:

Envoyé par UgoFerrari

(j'ai pour habitude d'écrire mes programmes en python, de les tester avec un interpréteur et ensuite de retranscrire dans le language désiré par l'enseignant).

Et bien, tu viens de découvrir que c'est une très mauvaise habitude dont tu dois te défaire. Chaque language est différent et, par conséquent, se programme différement. Par exemple, tu accède directement aux champs de tes objets. Ca se fait en python, mais en java on préfère passer par des getters et setters.

Tu as supposé à tord que java traitait les tableau de la même manière que python, ce n'est pas le cas. En java, les tableaux on une taille fixe.
Un code java "propre" devrais ressembler à ça:
Code:

1 2 3 for(int nombre = difference; nombre > 0; nombre--){ // Création de l'objet 'enfant' héritant de la classe branche. Branche enfant = new Branche(nombre);
et dans Branche
Code:

1 2 3 4 5 List<Integer> tableauList = new ArrayList<Integer>(); public Branche(Integer... contenu){ // 1 ou plusieurs éléments this.tableauListe=Arrays.asList(contenu); }

@ tchize_ : Oui effectivement je me rends compte, maintenant, qu'il reste toujours une 'boulette' quelque part en procedant de la sorte...

@supergeoffrey : Sur des annales elle existait mais les documents devait être faux ... Bref, la solution que tu présente ne convient pas car je souhaite ajouter un nombre (5, 6, 42, 3, ...) à la fin de mon tableau (ou ma liste donc ?) branche (et donc en 'agrandissant ce tableau / liste d'un élément) puis le stocker dans la variable enfant.

abj8077 : Voici mon code complet :

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
// Ceci importe la classe Scanner du package java.util
import java.util.Scanner;
 
// Voici ma classe Partition, contenant ma fonction principale.
public class Partition {
	// Fonction 'décomposition' utilisée avec la récursivité pour créer les différentes branches de mon arbre.
	public static void decomposition(int n, Branche branche, int k){
		// Déclaration d'une variable permettant de décrémenter n à chaque récursivité afin de composer une partition.
		int difference;
		difference = n - branche.somme;
		// Si une erreur se glisse dans la création de l'arbre et que la différence est supérieur à la nouvelle branche, je repars de sa valeur maximale.
		if(difference > branche.max){
			difference = branche.max;
		}
 
		// Boucle 'pour' partant de notre n "actuel" et ce décrémentant petit à petit pour donner, au premier passage par exemple, la deuxième ligne de mon PDF (celle en dessous du 'n' solitaire).
		for(int nombre = difference; nombre > 0; nombre--){
			// Création de l'objet 'enfant' héritant de la classe branche.
			Branche enfant = new Branche();
			enfant.tableauListe = branche.tableauListe.push(nombre)
			enfant.max = nombre;
			// La profondeur est notre 'k', on incrémente celle de l'enfant avec celle du parent + 1 pour toujours savoir où on en est et dès qu'on atteint k : terminer.
			enfant.profondeur = branche.profondeur + 1;
			// Calcule la somme du noeud avec la somme du noeud superieur, afin de vérifier si on est encore '<= n'.
			enfant.somme = branche.somme + nombre;
			// La fonction 'Push' va ajouter une nouvelle case, un nouvel élément, à la fin du tableau enfant avec la valeur entre parenthèses.
			branche.tableauEnfant.push(tableauEnfant)
			// Si notre somme est toujours inférieur à n, on repars dans une décomposition en créant une nouvelle branche.
			if(enfant.somme < n){
				decomposition(n, enfant, k);
			}
			// Si notre somme est atteinte et que notre nombre de partitions voulues ('k') est respectée, alors on peut imprimer la solution.
			else{
				if(enfant.profondeur == k){
					System.out.println(enfant.tableauListe);
				}
			}
		}
 
	}
 
	// Fonction principale.
	public static void main(String[] args){
		// L'objet 'sc' hériant de la classe 'Scanner' est là pour me permettre de récupérer un nombre entré au clavier par l'utilisateur.
		Scanner sc = new Scanner(System.in);
		// Création de l'objet 'arbre' héritant de la classe branche.
		Branche arbre = new Branche();
		// Ici je demande à l'utilisateur de sélectionner un nombre à décomposer.
		System.out.println("Veuillez saisir un nombre n à décomposer en k parties :");
		// Je récupère la valeur saisie par l'utilisateur pour la variable 'n'.
		int n = sc.nextInt();
		// Je renseigne l'utilisateur sur sa saisie pour qu'il se rende compte s'il y'a erreur ou non.
		System.out.println("Vous avez saisi : " + n);
		// Départ de l'arbre (ensuite le '.max' sera utilisé pour chaque départ de branche).
		arbre.max = n;
		// Ici je demande à l'utilisateur de sélectionner le nombre de partitions qu'il souhaite pour décomposer son nombre.
		System.out.println("Veuillez saisir un nombre k représentant le nombre d'éléments désirés pour décomposé le nombre n :");
		// Je récupère la valeur saisie par l'utilisateur pour la variable 'k'.
		int k = sc.nextInt();
		// Je renseigne l'utilisateur sur sa saisie pour qu'il se rende compte s'il y'a erreur ou non.
		System.out.println("Vous avez saisi : " + k);
		// Enfin, j'appelle la fonction 'décomposition' pour effectuer les partitions du nombre 'n' désirées et les afficher à l'écran.
		decomposition(arbre.max, arbre, k);
	}
 
}

Avec la classe Branche définit ensuite :

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
// Je déclare une nouvelle classe Branche afin de composer mon arbre petit à petit en créant des branches dans ma fonction récursive.
public class Branche {
	// Compteur permettant de faire la somme des partitions.
	int somme;
	// Variable permettant de reprendre une 'valeur de départ' à chaque nouvelle branche crée.
	int max;
	// Variable permettant de savoir à combien de k partitions nous en sommes.
	int profondeur;
	// Liste des enfants du noeud.
	// Je l'initialise à 1 case pour commencer et dans mon programme je "l'élargirais".
	int tableauEnfant[] = new int[1];
	// Liste pour stocker nos k partitions au cours de la creation de l'arbre.
	// Je l'initialise à 1 case pour commencer et dans mon programme je "l'élargirais".
	int tableauListe[] = new int[1];
 
	// Constructeur Branche.
	public Branche(){
		// J'initialise la somme à 0 car au début de ma construction d'arbre, il n'y a rien donc rien n'as été ajouté, l'origine est ainsi définie.
		somme = 0;
		// J'initialise max à 0 car au début de ma construction d'arbre, il n'y a pas de valeur prise.
		max = 0;
		// J'initialise la profondeur à 0 car au début de ma construction d'arbre, il n'y a pas de branches, de niveaux.
		profondeur = 0;
	}
}

Avec la slution des Array List de Joel.drigo ça marche :ccool: Enfin ça compile, après je n'ai pas encore les bons résultats d'impressions.

En fait le but est d'obtenir la décomposition d'un nombre 'n' en 'k' éléments.
Exemple : n = 6 et k = 3, le résultat est le suivant :
[4, 1, 1]
[3, 2, 1]
[2, 2, 2]

Et pour l'instant j'obtiens :
[6, 5, 1, 4, 2, 1, 1]
[6, 5, 1, 4, 2, 1, 1, 3, 3, 2, 1]
[6, 5, 1, 4, 2, 1, 1, 3, 3, 2, 1, 1, 1, 1, 2, 2, 2]

J'ai le bon nombre de solution mais pas les bonnes :mouarf:

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
// Ceci importe la classe Scanner du package java.util
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Iterator;
 
// Voici ma classe Partition, contenant ma fonction principale.
public class test {
	// Fonction 'décomposition' utilisée avec la récursivité pour créer les différentes branches de mon arbre.
	public static void decomposition(int n, Branche branche, int k){
		// Déclaration d'une variable permettant de décrémenter n à chaque récursivité afin de composer une partition.
		int difference;
		difference = n - branche.somme;
		// Si une erreur se glisse dans la création de l'arbre et que la différence est supérieur à la nouvelle branche, je repars de sa valeur maximale.
		if(difference > branche.max){
			difference = branche.max;
		}
 
		// Boucle 'pour' partant de notre n "actuel" et ce décrémentant petit à petit pour donner, au premier passage par exemple, la deuxième ligne de mon PDF (celle en dessous du 'n' solitaire).
		for(int nombre = difference; nombre > 0; nombre--){
			// Création de l'objet 'enfant' héritant de la classe branche.
			Branche enfant = new Branche();
			branche.liste.add(nombre);
			enfant.liste = branche.liste;
			enfant.max = nombre;
			// La profondeur est notre 'k', on incrémente celle de l'enfant avec celle du parent + 1 pour toujours savoir où on en est et dès qu'on atteint k : terminer.
			enfant.profondeur = branche.profondeur + 1;
			// Calcule la somme du noeud avec la somme du noeud superieur, afin de vérifier si on est encore '<= n'.
			enfant.somme = branche.somme + nombre;
			// La fonction 'Push' va ajouter une nouvelle case, un nouvel élément, à la fin du tableau enfant avec la valeur entre parenthèses.
			branche.enfantListe.addAll(enfant.enfantListe);
			// Si notre somme est toujours inférieur à n, on repars dans une décomposition en créant une nouvelle branche.
			if(enfant.somme < n){
				decomposition(n, enfant, k);
			}
			// Si notre somme est atteinte et que notre nombre de partitions voulues ('k') est respectée, alors on peut imprimer la solution.
			else{
				if(enfant.profondeur == k){
					System.out.println(enfant.liste);
				}
			}
		}
 
	}
 
	// Fonction principale.
	public static void main(String[] args){
		// L'objet 'sc' hériant de la classe 'Scanner' est là pour me permettre de récupérer un nombre entré au clavier par l'utilisateur.
		Scanner sc = new Scanner(System.in);
		// Création de l'objet 'arbre' héritant de la classe branche.
		Branche arbre = new Branche();
		// Ici je demande à l'utilisateur de sélectionner un nombre à décomposer.
		System.out.println("Veuillez saisir un nombre n à décomposer en k parties :");
		// Je récupère la valeur saisie par l'utilisateur pour la variable 'n'.
		int n = sc.nextInt();
		// Je renseigne l'utilisateur sur sa saisie pour qu'il se rende compte s'il y'a erreur ou non.
		System.out.println("Vous avez saisi : " + n);
		// Départ de l'arbre (ensuite le '.max' sera utilisé pour chaque départ de branche).
		arbre.max = n;
		// Ici je demande à l'utilisateur de sélectionner le nombre de partitions qu'il souhaite pour décomposer son nombre.
		System.out.println("Veuillez saisir un nombre k représentant le nombre d'éléments désirés pour décomposé le nombre n :");
		// Je récupère la valeur saisie par l'utilisateur pour la variable 'k'.
		int k = sc.nextInt();
		// Je renseigne l'utilisateur sur sa saisie pour qu'il se rende compte s'il y'a erreur ou non.
		System.out.println("Vous avez saisi : " + k);
		// Enfin, j'appelle la fonction 'décomposition' pour effectuer les partitions du nombre 'n' désirées et les afficher à l'écran.
		decomposition(arbre.max, arbre, k);
	}
 
}

Peut-être celà vient-il de ma déclaration et non initialisation des ArrayList dans ma classe Branche ? :

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
// Ceci importe la classe ArrayList du package java.util
import java.util.ArrayList;
 
// Je déclare une nouvelle classe Branche afin de composer mon arbre petit à petit en créant des branches dans ma fonction récursive.
public class Branche {
	// Compteur permettant de faire la somme des partitions.
	int somme;
	// Variable permettant de reprendre une 'valeur de départ' à chaque nouvelle branche crée.
	int max;
	// Variable permettant de savoir à combien de k partitions nous en sommes.
	int profondeur;
	// Liste des enfants du noeud.
	// Je l'agrandis au fur et à mesure de mon programme.
	ArrayList<Integer> enfantListe = new ArrayList<Integer>();
	// Liste pour stocker nos k partitions au cours de la creation de l'arbre.
	// Je l'agrandis au fur et à mesure de mon programme.
	ArrayList<Integer> liste = new ArrayList<Integer>();
 
	// Constructeur Branche.
	public Branche(){
		// J'initialise la somme à 0 car au début de ma construction d'arbre, il n'y a rien donc rien n'as été ajouté, l'origine est ainsi définie.
		somme = 0;
		// J'initialise max à 0 car au début de ma construction d'arbre, il n'y a pas de valeur prise.
		max = 0;
		// J'initialise la profondeur à 0 car au début de ma construction d'arbre, il n'y a pas de branches, de niveaux.
		profondeur = 0;
	}
}

25/10/2013, 11h37
tchize_
Désolé, mais ton code est imbuvable :)

comme suggérré: arrête d'accéder directement aux champs. Crée des méthodes propres pour faire ce que tu veux.

Tu te rends compte qu'avec ce code,
Code:

1 2 3 Branche enfant = new Branche(); branche.liste.add(nombre); enfant.liste = branche.liste;
Tous tes noeuds en sortie ont exactement la même liste, qui est la dernière valeur que tu affiche avec ton println.

Et ce code:

branche.enfantListe.addAll(enfant.enfantListe);

est inutile. Tu ne met jamais rien dans enfant.enfantListe, donc branche.enfantListe ne s'agrandis de rien.