Valeur non valide ?

voilà je un projet sur les tours de hanoï
Au départ, il n'y a aucune erreur, mais lorsque je lance mon menu dans mon MAIN ca ne fonctionne jamais, ca fais des heures que j'essais de le faire fonctionner et voilà le message d'erreur que ca m'envoie toujours:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -1
at Tour.peek(Tour.java:47)
public Anneau peek()
{
cette ligne là-----> return pile[top];
}

at ToursHanoi.Deplacer(ToursHanoi.java:58)
DA = this.tours[0].peek().getDiametre();

at Main.main(Main.java:46)
partie.Deplacer(position_de(), position_vers());

je n'ai pas réussi a resoudre aucune de ces erreurs et j'y travaille depuis des heures

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
public class Tour 
{
 
	private Anneau[] pile;
	private int taille;
	private char alias;
	private int top;
 
	//Constructeur
	public Tour(int taille, char alias)
	{
		this.taille = taille;
		this.alias = alias;
		this.pile = new Anneau[taille];
		top = -1;
	}
 
	//Accesseurs
	public int getTaille()
	{
		return this.taille;
	}
 
	public char alias()
	{
		return this.alias;
	}
 
	//Opérations primaires et secondaires
	public void push(Anneau anneau)
	{
		if(!isFull())
			this.pile[++top] = anneau;
	}
 
 
	public Anneau pop()
	{
		if(!isEmpty())
			return pile[top--];
		return null;
	}
 
	public Anneau peek()
	{
		return pile[top];
	}
 
	public boolean isEmpty()
	{
		return top == -1;
	}
 
	public boolean isFull()
	{
		return (top == pile.length - 1);
	}
 
	//Méthode permettant de vider la pile
	public void clear()
	{
		this.pile = new Anneau[taille];
	}
 
	public Anneau[] remplir(int nb_anneaux)
	{
 
		//créer tous les anneaux de 1 à N
		Anneau[] Tanneau = new Anneau[nb_anneaux];
 
		for(int i=nb_anneaux; i == 0 ;i--)
		{
			 Tanneau[i] = new Anneau(i);
 
			 //mettre les anneaux dans la pile
			 for(int j=0; j==taille;j++)
			 {
				 this.pile[j]=Tanneau[i];
				 this.pile[top]= this.pile[top++];
			 }
		}
		return this.pile;
 
	}
 
 
	//Redéfinition méthode toString
	public String toString()
	{
		String temp = new String();
		temp =(this.alias+": ");
 
		for(int j=0; j==taille;j++)
		{
			if (this.pile[j]==null)
			{
				temp += "-";
			}
			else
			{
				temp +=this.pile[j];
			}
		}
		return temp;
	}

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
public class ToursHanoi 
{	
	private Tour tours[] = new Tour[3];
	private int nb_anneaux;
	//je ne sais pas trop pourquoi on a ca : nb_deplacements... ?
	private int nb_deplacements;
	private Anneau A;
	private Anneau B;
	private Anneau C;
	private int DA;
	private int DB;
	private int DC;
 
	// Constructeur
	public ToursHanoi(int nb_anneaux)
	{
		this.nb_anneaux = nb_anneaux;
		this.tours[0] = new Tour(nb_anneaux, 'A');
		this.tours[1] = new Tour(nb_anneaux, 'B');
		this.tours[2] = new Tour(nb_anneaux, 'C');
		reinitialiser();
	}
 
	//Accesseurs
	public Tour getTourA()
	{
		return this.tours[0];
	}
 
	public Tour getTourB()
	{
		return this.tours[1];
	}
 
	public Tour getTourC()
	{
		return this.tours[2];
	}
 
	//Méthode permettant de vider les tours et de remplir la tour A
	public void reinitialiser()
	{
		this.getTourA().clear();
		this.getTourB().clear();
		this.getTourC().clear();
		this.getTourA().remplir(nb_anneaux);
		this.nb_deplacements = 0;
	}
 
	public boolean Deplacer(char de,char vers)
	{
		this.getTourA().toString();
		this.getTourB().toString();
		this.getTourC().toString();
		de = Character.toUpperCase(de);
		vers = Character.toUpperCase(vers);
		DA = this.tours[0].peek().getDiametre();
		DB = this.tours[1].peek().getDiametre();
		DC = this.tours[2].peek().getDiametre();;
 
 
		if (de == 'A')
		{
			if(vers == 'B')
			{		
				if (DA>DB)
				{
					System.out.println("Deplacement Illegal!");
					return false;
				}
				else
				{
					this.tours[1].push(A);
					this.tours[0].pop();
 
					System.out.println("L'anneau de diamètre"+ DA + "est déplacé de la tour A vers la tour B");
					nb_deplacements++;
					return true;
				}
			}
			else
			{
				if (DA > DC)
				{
					System.out.println("Deplacement Illegal");
					return false;
				}
				else
				{
					this.tours[2].push(A);
					this.tours[0].pop();
 
					System.out.println("L'anneau de diamètre"+ DA + "est déplacé de la tour A vers la tour C");
					nb_deplacements++;
					return true;
				}
			}
		}
		else
		{	
			if(de == 'B')
			{
				if(vers == 'A')
				{
					if (DB>DA)
					{
						System.out.println("Deplacement Illegal");
						return false;
					}
					else
					{
						this.tours[0].push(B);
						this.tours[1].pop();
 
						System.out.println("L'anneau de diamètre"+ DB + "est déplacé de la tour B vers la tour A");
						nb_deplacements++;
						return true;
					}
				}
				else
				{
 
					if (DB>DC)
					{
						System.out.println("Deplacement Illegal");
						return false;
					}
					else
					{
						this.tours[2].push(B);
						this.tours[1].pop();
 
						System.out.println("L'anneau de diamètre"+ DB + "est déplacé de la tour B vers la tour C");
						nb_deplacements++;
						return true;
					}
				}
			}
			else 
			{
				if(vers == 'A')
				{
					if (DC>DA)
					{
						System.out.println("Deplacement Illegal");
						return false;
					}
					else
					{
						this.tours[0].push(C);
						this.tours[2].pop();
 
						System.out.println("L'anneau de diamètre"+ DC + "est déplacé de la tour C vers la tour A");
						nb_deplacements++;
						return true;
					}
				}
				else
				{
					if (DC>DB)
					{
						System.out.println("Deplacement Illegal");
						return false;
					}
					else
					{
						this.tours[1].push(C);
						this.tours[2].pop();
 
						System.out.println("L'anneau de diamètre"+ DC + "est déplacé de la tour C vers la tour B");
						nb_deplacements++;
						return true;
					}
				}
			}
		}
	}
 
	public void DeplacerAuto(int nb_anneaux, char de, char milieu, char vers)
	{
		//S'il n'y a qu'un seul anneau dans la tour A
		if(nb_anneaux==1)
		{
			Deplacer(de,vers);
		}
		else
		{
			DeplacerAuto(nb_anneaux-1, de, vers, milieu);
			nb_deplacements++;
			Deplacer(de,vers);
			nb_deplacements++;
			DeplacerAuto(nb_anneaux-1, milieu, de, vers);
			nb_deplacements++;
			this.getTourA().toString();
			this.getTourB().toString();
			this.getTourC().toString();
		}
	}
 
	public void resoudre()
	{
		reinitialiser();
		DeplacerAuto(this.nb_anneaux, 'A','B','C');
 
	}
 
	public void Test()
	{
		System.out.println(tours[0].peek().getDiametre());
		System.out.println(tours[1].peek().getDiametre());
		System.out.println(tours[2].peek().getDiametre());
	}
}

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
import java.io.*;
 
public class Main {
	//Méthode principale
	public static void main(String[] args) throws IOException
	{
		System.out.println("-- Jeu des tours d'Hanoi");
		ToursHanoi partie = new ToursHanoi(3);
		int choix = -1;
		int nb_anneaux;
 
		System.out.println(partie);
 
		do
		{
			choix = MenuPrincipal();
 
			switch(choix)
			{
				case 1: //Déterminer le nombre d'anneaux (3 par défaut)
				{
					do
					{
						System.out.println("Entrer le nombre d'anneaux (entre 1 et 9 inclusivement).\n " +
								"Entrer 0 pour retourner au menu principal.");
						nb_anneaux = getInt();
 
					}while(nb_anneaux <= 0 || nb_anneaux >= 9);
 
					if (nb_anneaux != 0)
						partie = new ToursHanoi(nb_anneaux);
					System.out.println(partie);
					break;				
				}
 
				case 2: //Réinitialiser les tours
				{
					partie.reinitialiser();	
					System.out.println(partie);
					break;
				}
 
				case 3: //Jouer un coup
				{
					//Deplacer est une méthode dans ToursHanoi
					partie.Deplacer(position_de(), position_vers());
					System.out.println(partie);
					break;
				}
 
				case 4: //Montrer la solution
				{
					//Resoudre est une méthode dans ToursHanoi
					partie.resoudre();
					break;					
				}
 
				case 5: //Quitter
				{
					break;
				}
 
 
				default:
					System.out.println("\nChoix invalide! Veuillez recommencer.");
					break;
 
			}
 
		}while (choix != 5);
 
	}
 
 
 
	//
	public static char position_de() throws IOException
	{
		System.out.print("Entrez la tour de départ (a, b ou c): ");
		return getChar();
	}
 
	//
	public static char position_vers() throws IOException
	{
		System.out.print("Entrez la tour d'arrivée (a, b ou c): ");
		return getChar();
	}
 
 
	//Menu principal
	public static int MenuPrincipal() throws IOException
	{
		System.out.println("\n[MENU]");
		System.out.println("1: Déterminer le nombre d'anneaux (3 par défaut)");
		System.out.println("2: Réinitialiser les tours");
		System.out.println("3: Jouer un coup");
		System.out.println("4: Montrer la solution");
		System.out.println("Quitter");
		System.out.println("Faites votre choix et appuyer sur ENTER");
		return getInt();
	}
 
 
	public static int getInt() throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		return Integer.parseInt(br.readLine());	
	}
 
	 public static char getChar() throws IOException 
	 {
		 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));	      
		 return br.readLine().charAt(0);
	 }
 
}