Ajouter un élément d'une ArrayList déjà enlevé

Version imprimable

Bonjour à tous,

Après quelque recherche je n'ai pas trouvé de réponse a ma question :

Je fait un petit programme de réservation de voitures et voici le code qui me pose problème :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public static void choixVehiculeReservation() { //Choix du vehicule par numero de reservation System.out.println("\n" + "Selectionnez le numero du vehicule que vous voulez reserver "); Scanner sc = new Scanner(System.in); int choixUtil = sc.nextInt(); ArrayList<Vehicule> listeDeVehicules = Vehicule.getListeVehicule(); for (int i=0 ; i< listeDeVehicules.size(); i++) { if (choixUtil == listeDeVehicules.get(i).getReservation()) { listeDeVehicules.get(i).estReserve(); } } } public static void choixVehiculeRestitution() { // Restiturion du vehicule System.out.println("\n" + "Selectionnez le numero du vehicule que vous voulez restituer "); Scanner sc = new Scanner(System.in); int choixRestit = sc.nextInt();
Je voudrais pouvoir remettre l'élément enlevé lors d'une réservation grâce à ma méthode choixVehiculeRestitution. Ça ne fonctionne pas, sûrement car l'élément est enlevé pendant la réservation et lors du parcours de l'ArrayList et pour la restitution il ne la trouve pas (enfin je suppose).

Je bloque pas mal sur ce petit point et je vous remercie de votre aide :)

31/10/2017, 21h51
joel.drigo

Salut,

Il faudrait déjà nous montrer tout le code, déjà la fin de la méthode choixVehiculeRestitution() et celui de la classe Vehicule.

Et c'est quoi que tu appelles "enlevé" ? Est-ce que c'est ce qu'il se passe quand on appelle cette méthode listeDeVehicules.get(i).estReserve(); ? Que fait cette méthode ? Avec le code de Vehicule on le saurait.

Bonjour et merci pour votre réponse et vos conseils!

Voici les deux classes dont je me sers pour ce code, j'ai remis ce que j'avais ecrit dans la methode choixVehiculeRestitution mais ca ne fonctionne pas...

Merci :)

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
package co.simplon;
 
import java.util.ArrayList;
 
public class Vehicule {
 
	private String modele;
	private String marque;
	public static ArrayList<Vehicule> listeVehicule = new ArrayList<>();
	private static int compteur = 0;
	private boolean reserve;
	private static int nbVehiculeDispo;
	private int reservation;
 
		public Vehicule(String marque, String modele, int reservation) {
		super();
		this.modele = modele;
		this.marque = marque;
		this.reservation = reservation;
		this.reserve = false;
	}
 
	public void ajoutStock() {
		listeVehicule.add(this);
		compteur++;
		nbVehiculeDispo = compteur;
	}
 
	public void estReserve () {
		this.reserve = true;
		listeVehicule.remove(this);
		nbVehiculeDispo--;
		System.out.println("Vehicule réservé : " + this.getModele() + " " + this.getMarque());
		System.out.println("********");
	}
 
	public void estRestitue() {
		this.reserve=false;
		listeVehicule.add(this);
		nbVehiculeDispo++;
		System.out.println("Vehicule restitué : " + this.getMarque());
		System.out.println("********");
	}
 
 
	public static void afficherStock() {
		for (Vehicule vehicule : listeVehicule) {
			System.out.println("Vehicule disponible : " +  vehicule.getReservation() + ". " + vehicule.getModele() + " " + vehicule.getMarque());
			}
		System.out.println("********");
	}
 
	public String getModele() {
		return modele;
	}
	public void setModele(String modele) {
		this.modele = modele;
	}
	public String getMarque() {
		return marque;
	}
	public void setMarque(String marque) {
		this.marque = marque;
	}
 
	public static int getCompteur() {
		return compteur;
	}
 
	public static void setCompteur(int compteur) {
		Vehicule.compteur = compteur;
	}
 
	public boolean isReserve() {
		return reserve;
	}
 
	public void setReserve(boolean reserve) {
		this.reserve = reserve;
	}
 
	public static int getNbVehiculeDispo() {
		return nbVehiculeDispo;
	}
 
	public static void setNbVehiculeDispo(int nbVehiculeDispo) {
		Vehicule.nbVehiculeDispo = nbVehiculeDispo;
	}
 
	public int getReservation() {
		return reservation;
	}
 
	public void setReservation(int reservation) {
		this.reservation = reservation;
	}
 
	public static ArrayList<Vehicule> getListeVehicule() {
		return listeVehicule;
	}
 
	public static void setListeVehicule(ArrayList<Vehicule> listeVehicule) {
		Vehicule.listeVehicule = listeVehicule;
	}
 
}

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
 
package co.simplon;
 
import java.util.ArrayList;
import java.util.Scanner;
 
public class Choix {
 
		public static void choixUtil() {
 
		while(true) {
 
			try {							// gerer l'exception si un utilisateur rentre autre chose qu'un int
 
				Scanner sc = new Scanner(System.in);
				System.out.println("Voulez-vous reserver ou restituer un vehicule : " + "\n" + "1. Reserver" + "\n"+ "2. Restituer" + "\n" + "3. Afficher les vehicules disponibles\n" + "4. Quitter le programme");
				int choix = sc.nextInt();
 
				switch (choix) {
 
				case 1: choix1() ;
					break;
 
				case 2: choix2(); 
					break;
 
				case 3: Vehicule.afficherStock();
					break;
 
				case 4: arretProgramme();
					break;
 
				default:
					choixUtil();
				break;
				}
			}
 
			catch (java.util.InputMismatchException exception)  {		//bloc de code executer si mauvaise entre de l'utilisateur
				System.out.println("Choix incorrect");
				arretProgramme();
				}
			}
		}
 
	public static void choix1() {									// 
 
		System.out.println("Voici la liste des vehicules disponible : " + "\n");
		Vehicule.afficherStock(); 
		choixVehiculeReservation();
		System.out.println("********");
	}
 
	public static void choix2() {								//Restitution vehicule par numero de reservation
		choixVehiculeRestitution();
 
	}
 
	public static void arretProgramme() {							//Fonction pour arreter le programme
		Scanner lectClavier = new Scanner(System.in);
			System.out.println("Souhaitez-vous quitter le programme? O/N ");
			String reponse = lectClavier.nextLine();
			if (reponse.equals("O")) 
				System.exit (0);
			}
 
 
	public static void choixVehiculeReservation() {					//Choix du vehicule par numero de reservation
		System.out.println("\n" + "Selectionnez le numero du vehicule que vous voulez reserver ");
		Scanner sc = new Scanner(System.in);
		int choixUtil = sc.nextInt();
		ArrayList<Vehicule> listeDeVehicules = Vehicule.getListeVehicule();
		for (int i=0 ; i< listeDeVehicules.size(); i++) {
				if (choixUtil == listeDeVehicules.get(i).getReservation()) {
					listeDeVehicules.get(i).estReserve();
			}
		}
	}
 
	public static void choixVehiculeRestitution() {
		System.out.println("\n" + "Selectionnez le numero du vehicule que vous voulez restituer ");
		Scanner sc = new Scanner(System.in);
		int choixRestit = sc.nextInt();
		ArrayList<Vehicule> listeDeVehicules = Vehicule.getListeVehicule();
		for (int i=0 ; i< listeDeVehicules.size(); i++) {
				if (choixRestit == listeDeVehicules.get(i).getReservation()) {
					listeDeVehicules.get(i).estRestituer();
			}
		}
	}
}

Le souci est effectivement que la méthode estReserve() retire l'élément de la liste, donc quand tu parcours la liste de véhicules pour en restituer tu ne risques pas de trouver un véhicule réservé (et donc pas possible de le restituer).

Il y a beaucoup de façon de résoudre ce genre de problématique.

Par exemples (en partant du principe qu'on est pas en multithread) :
Par exemple avec une seule liste (le plus simple à mon avis), on ne retire jamais d'éléments de cette liste, et on utilise uniquement les états

Avec une version simplifiée de la classe Vehicule, avec un état qui dit si le véhicule est réservé ou non :
Code:

1 2 3 4 5 6 7 8 9 public class Vehicule { private boolean booked; public boolean isBooked() { return booked; } public void setBooked(boolean booked) { this.booked=booked; } }
Réserver un véhicule se fera tout simplement par
Code:

1 2 3 Vehicule vehicule = listVehicules.get(i); vehicule.setBooked(true);
Obtenir la liste des véhicules réservés se fera tout simplement par un filtre :

Code:

List<Vehicule> bookedVehicules = listVehicules.stream().filter(Vehicule::isBooked).collect(Collectors.toList());

Ou à l'ancienne :
Code:

1 2 3 4 5 6 List<Vehicule> bookedVehicules = new ArrayList<>(listVehicules.size()); for(Vehicule vehicule : listVehicules) { if( vehicule.isBooked() ) { bookedVehicules.add(vehicule); } }
Obtenir la liste des véhicules disponibles :

Code:

List<Vehicule> bookedVehicules = listVehicules.stream().filter(vehicule-> !vehicule.isBooked()).collect(Collectors.toList());

etc.
En utilisant une liste et un set. Une qui contient tous les véhicules et une avec uniquement les véhicules réservés
Code:

1 2 3 4 5 public class Flotte { private List<Vehicule> vehicules = new ArrayList<>(); private Set<Vehicule> bookedVehicules = new HashSet<>(); /*...setters et getters qui vont bien*/ }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public class Vehicule { private static Flotte flotte = new Flotte(); private boolean booked; public Vehicule() { flotte.getVehicules().add(this); } public boolean isBooked() { return flotte.getBookedVehicules().contains(this); } public void setBooked(boolean booked) { if ( booked ) { booked.add(this); } else { booked.remove(this); } } }
Pour réserver un véhicule :
Code:

1 2 3 Vehicule vehicule = listVehicules.get(i); vehicule.setBooked(true);
Avec ton système, il n'y a pas que le souci qu'un véhicule réservé ne se trouve pas dans la liste et donc ne peut être restitué, mais il y a aussi que si on le remet dans la liste pour le restitué, il change de position. Réserver donc deux fois le véhicule de position n ne réservera pas le même véhicule. Cela peut être un choix, mais pour la restitution, même si on ajoutait le véhicule dans une seconde liste, il n'aurait pas la même position que dans la liste d'origine et donc le numéro de restitution ne serait pas le même que le numéro de location, et là, ça risque d'être plutôt perturbant pour l'utilisateur et très compliqué pour restituer correctement le véhicule.
On pourrait utiliser un tableau de la même taille que la liste pour stocker les véhicules réservés, ou utiliser un autre moyen d'identifier le véhicule (un attribut de l'objet Vehicule). Avec ce moyen, on pourrait avec deux collections, une des véhicules disponibles, et une des véhicules loués, gérer le problème. Voire avec deux maps pour simplifier un peu :
Code:

1 2 3 4 5 public class Flotte { private Map<Vehicule,Integer> availableVehicules = new HashMap<>(); private Map<Vehicule,Integer> bookedVehicules = new HashMap<>(); /*...setters et getters qui vont bien*/ }
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 public class Vehicule { private static Flotte flotte = new Flotte(); private static int IDS = 0; private final int id; private boolean booked; public Vehicule() { id = IDS++; // chaque véhicule a un id différent, un int incrémenté flotte.getAvailableVehicules().put(id, this); } public int getId() { return id; } public boolean isBooked() { return flotte.getBookedVehicules().containsKey(id); // ou flotte.getBookedVehicules().containsValue(this) } public void setBooked(boolean booked) { if (booked ) { flotte.getAvailableVehicules().remove(id); flotte.getBookedVehicules().put(id,this); } else { flotte.getBookedVehicules().remove(id); flotte.getAvailableVehicules().put(id,this); } } }
Pour connaître la liste des véhicules loués, disponibles, existants... :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public class Flotte { /** ... **/ private Stream<Vehicule> stream(Map<Integer, Vehicule> map) { return map.values.stream(); } private List<Vehicule> list(Stream<Vehicule> stream) { return Collections.unmodifiableList(stream.sorted(Comparator.comparing(Vehicule:getId)).collect(Collectors.toList()); // le sorted permet de garantir que les véhicules sont toujours dans le même ordre, celui des id } public List<Vehicule> availableVehicules() { return list( stream( availableVehicules ) ); } public List<Vehicule> bookedVehicules() { return list( stream( bookedVehicules) ); } public List<Vehicule> allVehicules() { return list( Stream.concat( stream( availableVehicules ), stream( bookedVehicules) ); } }

03/11/2017, 09h02
Hemoroide

Merci pour tous ces conseils, effectivement peut etre que mon approche n'etait pas la plus simple, etant debutant je n'ai pas encore tous les automatismes. Je ne connaissais pas le HashMap je vais donc essayer de finir le programme grace a cet outils.

Merci encore :)