Salut!

Tu trouveras ci-dessous une classe qui étend Vector. Elle contient deux méthodes supplémentaires qui te permettent de réaliser ce que tu as demandé.

Regarde dans la doc du code (en début de classe) pour plus d'infos.

J'ai volontairement utilisé unautre Vector interne à la classe pour stocker les éléménts qui n'ont pas encore été retourné par la méthode getRandomElement(). Cette solution n'est pas la meilleure car on utilise ici l'espace méméoire nécessaire à 2 Vector pour en uitiliser finalement un seul.

Je te laisse adapter le code en utilisant, par exemple, un boolean[] pour stocker si oui ou non un élément à déjà été renvoyé.

;-)

import java.util.Collection;
import java.util.Vector;

import org.omg.CORBA.portable.RemarshalException;

/**
 * Created on 01-mai-07
 * 
 * Description: Cette classe étend la classe Vector.
 * Elle contient deux méthodes supplémentaires:
 * <ul>
 * <li>getRandomElement() qui retourne aléatoirement un objet de type E qui
 * appartient au vecteur sans jamais renvoyer deux fois le même objet</li>
 * <li>resetRandom() qui permet de réinitialiser le retoru aléatoire d'un
 * élément du vecteur
 * </ul>
 * 
 * @author: HackTrack for CCM
 */

public class RandomGetVector<E extends Object> extends Vector<E> {
	private Vector<E> remainingObjects;

	private static final long serialVersionUID = -6047874282826032292L;

	public RandomGetVector() {
		remainingObjects = new Vector<E>();
	}

	public RandomGetVector(int initialCapacity) {
		super(initialCapacity);
		remainingObjects = new Vector<E>(initialCapacity);
	}

	public RandomGetVector(Collection<E> c) {
		super(c);
		remainingObjects = new Vector<E>(c);
	}

	public RandomGetVector(int initialCapacity, int capacityIncrement) {
		super(initialCapacity, capacityIncrement);
		remainingObjects = new Vector<E>(initialCapacity, capacityIncrement);
	}

	public boolean add(E o) {
		if (remainingObjects.add(o))
			return super.add(o);
		return false;
	}

	public void add(int i, E o) {
		super.add(i, o);
		remainingObjects.add(i, o);

	}

	public void addAll(Collection<E> c) {
		super.addAll(c);
		remainingObjects.addAll(c);
	}

	public void addAll(int i, Collection<E> c) {
		super.addAll(i, c);
		remainingObjects.addAll(i, c);
	}

	/**
	 * Returns in a random way an element of the <code>RandomGetVector

.
* The same element is returned once and only once while the
*

RandomGetVector#resetRandom

method hasn'been called.
*
* @return A random element which belongs to the
*

RandomGetVector

* @throws ArrayIndexOutOfBoundsException
* If all element have already been returned.
*/
public E getRandomElement() throws ArrayIndexOutOfBoundsException {
int randomIndex = (int) (Math.random() * remainingObjects.size());
return remainingObjects.remove(randomIndex);
}

/**
* Resets the random. Any element of the

RandomGetVector

may
* been returned after call to this method.
*
*/
public void resetRandom() {
remainingObjects = new Vector<E>();
remainingObjects.addAll(this);
}

public static void main(String[] args) {
RandomGetVector<String> vector = new RandomGetVector<String>();
vector.add("Hack");
vector.add("Track");
vector.add("CCM");
vector.add("Java");
for (int i = 0; i < 5; i++) {
System.out.println(vector.getRandomElement());
}
}
}

</code>

;-)
HackTrack