Bonjour les Zéros
En tant que gros Zéro, j'ai quelque difficultés à résoudre un exercise sur les arbres ordonnées. Nous avons un arbre avec des clés comme index d'une liste de valeurs, qui peuvent être égales.Je voudrais implémenter les méthodes suivantes: public V getFirstEntry(), public V removeFirstEntry(), public void putAll(Map<? extends K, ? extends List<V>> t), public void put(K key, V value), public void changeKey(K oldKey, K newKey, V value), public void changeKey(K oldKey, K newKey). Je ne sais pas si c'est adéquat d'utiliser l'interface NavigableMap pour getFirstEntry and removefirstEntry. Bon voici mon code.
Merci d´avance

class ListTree<K extends Comparable<?>, V> {

private TreeMap<K, List<V>> data = null;
private int size = 0;
/**
* Constructor ListTree.
*/
public ListTree() {

data = new TreeMap<K, List<V>>();
//data.comparator();
}


/**
* Retourne true, si notre ListTree contient la valeur value.
* Retourne false si value == null
*
* @param value
* @return
*/
public boolean containsValue(V value) {

if (value == null)
return false;

if (data.containsValue(value))
return true;

return false;
}


/**
* Retourne true, si l´arbre contient un element enregistré sous la clé k.
*
* @param k
* @return
*/
public boolean containsKey(K k) {

if (k == null)
throw new NullPointerException();

if (data.containsKey(k))
return true;

return false;
}


/**
* Retourne la liste qui est enregistrée sous l´index k.
* Retourne null si elle n´existe pas
*
* @param key
* the key to search for
* @return
*/
public List<V> get(K k) {

if (k == null)
throw new NullPointerException();

if (containsKey(k) == true)
return data.get(k);

return null;
}


/**
* Retourne le nombre de valeur qui sont enregistrées sous l´index donné
*
* @return
*/
public int getNumberOfEntries(K key) {

if (key == null)
throw new NullPointerException();

if (!data.containsKey(key))
throw new IllegalArgumentException();

return data.get(key).size();
}


/**
* Retourne le nombre de clés DISTINCTES de l´arbre sous lesquelles des valeurs sont
* enregistrées
*
* @return thr number of different keys in the map
*/
public int keySize() {

int keyNumber = 0, result = 0;

while (keys().hasNext()) {
if (data.isEmpty())
keyNumber = 0;
keyNumber++;
}

return result += keyNumber;
}


/**
*The size of the tree
*/
public int valueSize() {
size = data.size();
return size;
}

/**
*retourne la 1ère valeur de l'arbre c'est à dire la valeur avec le plus petit index
*Important est que cette méthode retourne la même valeur que RemoveFirstEntry()
*/
public V getFirstEntry() {

if (data.isEmpty())
throw new NoSuchElementException();

NavigableMap<K, List<V>> nav = new TreeMap<K, List<V>>();
nav = data;
List<V> liste = nav.firstEntry().getValue();

// CompareTo????
return firstIndexOf(liste);
}

private V firstIndexOf(List<V> liste) {

V firstIndexListe = firstIndexOf(liste);
return firstIndexListe;
}


/**
*Méthode removeFirstENtry()
*
*la méthode enlève la première valeur de l'arbre, donc celle avec le plus petit index
*/
public List<V> removeFirstEntry() {

if (data.isEmpty())
throw new NoSuchElementException();

return data.remove(getFirstEntry());
}


/**
* public Iterator<K> keys() Retourne une itérateur d'index de l'arbre
*
* @return
*/
public Iterator<K> keys() {

Iterator<K> it = keyset().iterator();
return it;
}


/**
* Retourne un Set qui contient les index de l´arbre
*
* @return
*/
public Set<K> keyset() {
return data.keySet();
}


/**
* Ajoute tous les données d'un arbre donné dans notre arbre. Notre arbre reprendra
* ainsi les index de l'arbre donné
*/
public void putAll(Map<? extends K, ? extends List<V>> t) {

if (data.isEmpty())
throw new NullPointerException();

data.putAll(t);
}


/**
* Ajoute une valeur donnée dans notre arbre.
* La valeur sera soit affectée à la liste-si elle existe- avec l'index donné
* Dans le cas où la liste n'existe pas, crée une nouvelle liste
* La nouvelle liste peut avoir une classe quelconque, mais qui implementera
* l'interface java.util.List, par exemple la classe java.util.LinkedList.
*
* @param key
* the key of the given element
* @param value
* the value of the given element
*/
@SuppressWarnings("unchecked")
public void put(K key, V value) {

if (key == null || value == null)
throw new NullPointerException();

if (containsKey(key))
data.get(key).add(value);

data.put(key, (List<V>) value);
}


/**
* Cette méthode attribue la valeur value de notre arbre, qui est sous l'index oldKey
* à une nouvelle clé newKey. Ensuite elle efface l'index oldKey
* Avant l'execution de la méthode, s'il n'existe pas une valeur concordante
* alors l'arbre restera inchangé
*/
public void changeKey(K oldKey, K newKey, V value) {

if (oldKey == null || newKey == null || value == null)
throw new NullPointerException();

if (containsValue(value) && containsKey(oldKey)) {
newKey = oldKey;
data.remove(oldKey);
}
}


/**
* Attribue toutes les valeurs de l'index oldKey à newKey.
* Efface ensuitetoutes les affectations
*/
public void changeKey(K oldKey, K newKey) {

if (oldKey == null || newKey == null)
throw new NullPointerException();

if (containsKey(oldKey)) {
newKey = oldKey;
data.remove(oldKey);
}

}
}