Problème de taille d'ArrayList

Version imprimable

Bonjour,
Je travaille sur l’implémentation Java du Type abstrait Polynôme, il s'appuis sur le type abstrait Monôme déjà implémenter et cela dans le cadre de mes études.
Le type Polynôme doit être une arraylist j'ai donc chercher comment l'utiliser ici : http://javasearch.developpez.com/j2s...ArrayList.html
Mais j'ai quelque problème:

Quand je définie une taille ou essaye de l’agrandir l’opération n'effectue aucun changement:

Si je fait:
Code:

1 2 3 ArrayList<Monôme> Poly = new ArrayList<Monôme>(10); Poly.ensureCapacity(100); Poly.add(2,new Monôme(4,2));
J'obtient:
Code:

1 2 3 4 Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 2, Size: 0 at java.util.ArrayList.rangeCheckForAdd(ArrayList.java:612) at java.util.ArrayList.add(ArrayList.java:426) at test.run.main(run.java:9)
Le but est de ranger les monôme dans la case de leur exposant -1, 8^3 serait au rang 2 cela pour ensuite faciliter les opération somme et multiplication de Polynôme.

j'ai fais des test de taille et avec sa:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 package test; import java.util.*; public class run { public static void main(String[] args) { ArrayList<Monôme> Poly = new ArrayList<Monôme>(10); Poly.ensureCapacity(999999); System.out.println(Poly.size()); Poly.add(new Monôme(4,2)); Poly.add(new Monôme(5,3)); System.out.println(Poly.size()); System.out.println(Poly); } }
il me retourne:
Code:

1 2 3 0 2 [4.0xe2, 5.0xe3]
Pourquoi il garde une taille de 0?

22/02/2014, 18h57
joel.drigo

Salut,

Tu n'as aucun besoin d'appeler ensureCapacity() : cette méthode sert uniquement à dimensionner le tableau de stockage interne de la classe ArrayList, pas sa taille. Sa taille, c'est son nombre d'éléments. La classe ArrayList gère, toute seule, l'augmentation de sa taille, et la dimension du tableau interne de stockage, en fonction de ce qu'on y ajoute. On peut éventuellement utiliser ensureCapacity() si on veut ajouter beaucoup d'éléments à la suite, dans un temps très court, pour éviter des "redimensionnements" successifs du tableau interne (qui se fait par création d'un nouveau tableau plus grand, et une copie de tableau), lorsqu'on a un besoin de hautes performances. En aucun cas pour ajouter 1 seul élément !

Pour ajouter un élément à une classe implémentant l'interface java.util.List, comme ArrayList, on utilise la méthode add() à un paramètre, qui est l'élément à ajouter. La méthode add() à 2 paramètres, sert à insérer avant, ou après le dernier élément, comme l'indique sa javadoc. Le premier argument est l'index de l'élément avant lequel on veut ajouter, ou la taille de la liste, pour ajouter après le dernier. Aucune autre valeur d'index est acceptée (0<=index<=size()), sous peine d'obtenir l'exception que tu obtiens, et ce, quelque soit la taille du tableau interne de stockage.

EDIT: j'avais pas regardé tout ton code. Tu te rends compte de ce que fait ensureCapacity(999999) ?

enfaîte le ensureCapacity(999999) était juste pour le test.
Donc je ne peut inserer un élément a la nème position que si il existe un élémement a la nème ou nème-1 position?

J'ai essayer de remplir avec de monome null voici mon code:

Polynome.java

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
import java.util.*;
public class Polynôme {
 
	List<Monôme> Poly = new ArrayList<Monôme>();
 
	/**
         * construit un polynôme vide
         */
	public Polynôme()
	{
		Poly.add(new Monôme(0,0));
	}
 
	/**
         * ajoute un monôme à un polynôme
         * @param mono
         * @throws PolynômeException 
         */
	public void ajouterMonôme(Monôme mono) throws PolynômeException
	{
		Monôme mono2 = this.Poly.get(mono.exposant());
		if (mono.exposant() > this.Poly.size()){
			for (int i=this.Poly.size();i < mono.exposant();i++){
				if (i >= this.Poly.size() || this.Poly.get(i) == null){
					this.Poly.add(new Monôme(0,0));}
				}
			this.Poly.add(mono);
		}
		else if (mono2.estNul())
			this.Poly.set(mono.exposant(),mono);
		else
			throw new PolynômeException();
	}

testPolynome

Code:

1
2
3
4
5
6
7
8
9
10
11
public class client {
	public static void main(String[] args) throws PolynômeException
	{
		Polynôme A = new Polynôme();
		A.ajouterMonôme(new Monôme(5,0));
		A.ajouterMonôme(new Monôme(6,1));
		A.ajouterMonôme(new Monôme(1,2));
 
            }
 
}

Et j'ai toujours un problème de taille

Code:

1
2
3
4
5
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 1, Size: 1
	at java.util.ArrayList.rangeCheck(ArrayList.java:604)
	at java.util.ArrayList.get(ArrayList.java:382)
	at Polynôme.ajouterMonôme(Polynôme.java:21)
	at client.main(client.java:8)

Pourtant la fonction ajouterMonôme créé des monôme vide jusqu’à ce que on arrive au rang voulu je ne comprend pas.

Le but est de pouvoir par la suite effectuer des opération somme et produit entre polynôme, si il sont ranger de manière anarchique dans la liste je ne vois pas trop comment faire alors que si a un exposant correspond un rang de la liste sa devient plus simple.

Les indices des éléments dans les List (comme dans les tableau) en java vont de 0 à n-1 (entre 0 inclus et n exclu), où n est le nombre d'éléments (qu'on appelle la taille de la liste).

Quand tu écris :
Code:

1 2 3 for (int i=this.Poly.size();i < mono.exposant();i++){ if (i >= this.Poly.size() || this.Poly.get(i) == null){ this.Poly.add(new Monôme(0,0));} ... }
Ton indice de boucle i commence à la valeur n, valeur d'indice exclue, donc le get(i) plante à la première itération (c'est le sens de l'exception
IndexOutOfBoundsException : indice en dehors des limites).

22/02/2014, 23h05
ShadStrike

Je doit donc utiliser i-1 et pas i c'est bien sa?
22/02/2014, 23h36
thelvin

Ou simplement estimer que i doit être inférieur ou égal à l'exposant.

Après tout, un monôme doit toujours être situé à l'index correspondant à son exposant.
(... Et donc la classe Monôme ne sert pas à grand-chose...)

Si j'ai bien compris tu veux placer un monôme d'exposant i en position i dans la liste.

Le plus simple est de raisonner d'abord comme si la liste était remplie. Pour placer un monôme d'exposant i en position i, il suffit d'écrire (en admettant que i n'est jamais négatif) :
Code:

1 2 int i = monome.getExposant(); liste.set(i, monome);
Maintenant, on ne peut appeler cette méthode que si i est compris entre 0 inclus et la taille de la liste exclue, donc on ajoute un test :
Code:

1 2 3 4 int i = monome.getExposant(); if ( i<liste.size() ) { liste.set(i, monome); }
Et maintenant, on gère le "else". On doit ajouter le monôme d'exposant i, à l'indice i, qui n'existe pas encore, donc faire liste.add(i, monome), ce qu'on ne pourra faire que si la liste à un nombre d'éléments suffisant, soit que i==liste.size(). Commençons par :
Code:

1 2 3 4 5 6 7 8 9 int i = monome.getExposant(); if ( i<liste.size() ) { liste.set(i, monome); } else { ... liste.add(monome); // ceci est l'équivalent de liste.add(liste.size(), monome); }
Il ne reste qu'à remplacer les "..." par une boucle qui ajoute suffisamment de monômes du type 0xⁱ. C'est-à-dire, si on reprend la règle du placement d'un monôme énoncée au début, ajouter un monôme 0x^liste.size(), tant que liste.size()<i.
Code:

1 2 3 4 5 6 7 8 9 10 11 int i = monome.getExposant(); if ( i<liste.size() ) { liste.set(i, monome); } else { while( liste.size()<i ) { liste.add(new Monome(0, liste.size())); } liste.add(monome); }

23/02/2014, 00h20
ShadStrike

Merci pour vos réponses je commence a mieux comprendre je vais essayer avec sa, et si j'utilise la classe monôme c'est par ce que c'est imposer par l’énoncer.

Citation:
J'ai réussis avec ton code que j'ai modifier pour interdire l'ajout d'un monome si il en existe déja un de même degré dans le polynôme (exiger par la spécification de polynôme).

Mais j'ai encore un problème j'ai créé une méthode somme et produit, et la fonction produit a encore un problème de taille pourtant j'ai mis des condition < Polynome.size() :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public Polynôme produit(Monôme m) throws PolynômeException { Polynôme r = new Polynôme(); for (int i = 0;i < this.Poly.size(); i++){ if ((((this.Poly.get(i)).produit(m)).exposant() < this.Poly.size()) && (this.Poly.get(i)).estNul()) {r.Poly.set(((this.Poly.get(i)).produit(m)).exposant(),(this.Poly.get(i)).produit(m)); if (((this.Poly.get(i)).produit(m)).exposant() != i) r.Poly.set(i,new Monôme(0,0)); } else if ((((this.Poly.get(i)).produit(m)).exposant() < this.Poly.size()) && !(this.Poly.get(((this.Poly.get(i)).produit(m)).exposant())).estNul()) {r.Poly.set(((this.Poly.get(i)).produit(m)).exposant(),(this.Poly.get(((this.Poly.get(i)).produit(m)).exposant())).somme(((this.Poly.get(i)).produit(m)))); if (((this.Poly.get(i)).produit(m)).exposant() != i) r.Poly.set(i,new Monôme(0,0)); } else if ((((this.Poly.get(i)).produit(m)).exposant() >= this.Poly.size())) r.ajouterMonôme(((this.Poly.get(i)).produit(m))); } return r; }
Cette méthode pour chaque élément du polynôme :

-si l'exposant du produit est inférieur à la taille et le polynôme au rang de l'exposant du produit est nul

-> il range le polynôme issu du produit au rang de son exposant.
-sinon si l'exposant du produit est inférieur à la taille et le polynôme au rang de l'exposant du produit n'est pas nul

-> il range la somme du polynôme issu du produit et de celui qui est déjà à ce rang au rang de son exposant .
-sinon si l'exposant du produit est supérieur à la taille du polynôme

-> il fait appelle à la fonction ajouterMonôme qui va tout seul ajouter les monômes nul et le monôme du produit au bon rang.

Mais quand j’exécute mon client de test:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class client { public static void main(String[] args) throws PolynômeException { Polynôme A = new Polynôme(); A.ajouterMonôme(new Monôme(5,0)); A.ajouterMonôme(new Monôme(6,6)); A.ajouterMonôme(new Monôme(1,5)); Monôme Z = new Monôme(2,3); Polynôme B = A.produit(Z); for (int i=0;i<B.Poly.size();i++){ Monôme Zi = B.Poly.get(i); System.out.println(Zi);} } }
J'obtient l’erreur
Code:

1 2 3 4 5 Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 4, Size: 1 at java.util.ArrayList.rangeCheck(ArrayList.java:604) at java.util.ArrayList.set(ArrayList.java:397) at Polynôme.produit(Polynôme.java:63) at client.main(client.java:11)
La ligne 63 de polynôme est :
Code:

1 2 3 4 5 if ((((this.Poly.get(i)).produit(m)).exposant() < this.Poly.size()) && (this.Poly.get(i)).estNul()) {r.Poly.set(((this.Poly.get(i)).produit(m)).exposant(),(this.Poly.get(i)).produit(m)); <---------------------------- ICI if (((this.Poly.get(i)).produit(m)).exposant() != i) r.Poly.set(i,new Monôme(0,0)); }
Pourtant juste au dessus j'ai vérifier que ((this.Poly.get(i)).produit(m)).exposant() < this.Poly.size()) donc je ne comprend pas.
Problème résolu juste une erreur de this.Poly.size() à la place d'un r.Poly.size()

Merci à tous pour votre aide