Hallo zusammen.
Ich versuche ohne erfolg aber ein treemap ListTree zu implementieren. Der Code funktionniert aber nicht.Die Methode remove funktionieren nicht. erstmal der Code
Die JUnit-Fehler lautet:
[junit] Testcase: testMutatorPermutations took 0.081 sec
[junit] Caused an ERROR
[junit] [Ljava.lang.Object; cannot be cast to [Ljava.lang.Comparable;
[junit] java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Comparable;
[junit] at jpp.listtree.ListTree.removeValue(ListTree.java:422)
[junit] at tests.reqTests.TestListTree.removeValue(TestListTree.java:169)
[junit] at tests.reqTests.TestListTree.performAction(TestListTree.java:272)
[junit] at tests.reqTests.TestListTree.testMutatorPermutations(TestListTree.java:292)
[junit]
[junit] Testcase: firstLastEntryTest took 0.001 sec
[junit] Caused an ERROR
[junit] [Ljava.lang.Object; cannot be cast to [Ljava.lang.Comparable;
[junit] java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Comparable;
[junit] at jpp.listtree.ListTree.removeValue(ListTree.java:422)
[junit] at jpp.listtree.ListTree.removeFirstEntry(ListTree.java:277)
[junit] at tests.reqTests.TestListTree.firstLastEntryTest(TestListTree.java:331)
[junit]
[junit] Test tests.reqTests.TestListTree FAILED
Ich bedanke mich für Ihre Mühe
Ich versuche ohne erfolg aber ein treemap ListTree zu implementieren. Der Code funktionniert aber nicht.Die Methode remove funktionieren nicht. erstmal der Code
Java:
package jpp.listtree;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.TreeMap;
// TODO: Auto-generated Javadoc
/**
* The Class ListTree.
*
* @param <K> the Key
* @param <V> the Value into the key
* @author Sylvain F
*/
/**
* @author kathrin
*
* @param <K>
* @param <V>
*/
public class ListTree<K extends Comparable<?>, V> {
/** The data. */
private TreeMap<K, List<V>> data = null;
/** The size. */
private int size = 0;
/**
* Constructor ListTree. legt eine neue leere data-Intanz an
*/
public ListTree() {
data = new TreeMap<K, List<V>>();
data.comparator();
clear();
}
/**
* delete all data.
*/
public void clear() {
data.clear();
size = 0;
}
/**
* containsValue(V value) Gibt genau dann true zurueck, wenn der ListTree
* den als Argument gegebenen Wert enthaelt (egal unter welchem Schluessel
* er abgespeichert ist). Ist value auf null gesetzt, so liefert die Methode
* false zurueck.
*
* @param value
* the value
* @return true, if successful
*/
public boolean containsValue(V value) {
if (value == null) {
return false;
}
Collection<List<V>> val = this.data.values();
for (List<V> list : val) {
if (list.contains(value)) {
return true;
}
}
return false;
// return data.containsValue(value);
}
/**
* containsKey(K k) Gibt genau dann true zurueck, wenn Baum irgendein
* Element enthaelt, das unter dem gegebenen Schluessel k abgespeichert ist.
* Die Methode wirft eine NullPointerException, falls das Argument null ist.
*
* @param k
* the k
* @return true, if successful
*/
public boolean containsKey(K k) {
if (k == null) {
throw new NullPointerException();
}
return data.containsKey(k);
}
/**
* public List<V> get (K k) Gibt die Liste zurueck, die unter dem gegebenen
* Schluessel k abgespeichert ist, falls eine solche Liste existiert und
* null sonst. Die Methode wirft eine NullPointerException, falls das
* Argument null ist.
*
* @param k
* the k
* @return the list
*/
/**
* public List<V> get(K k) {
*
* try{ if (containsKey(k) == true) return data.get(k); }
*
* catch(RuntimeException e){ e.printstacktrace(); }
*
* }
*/
public List<V> get(K k) {
if (k == null) {
throw new NullPointerException();
}
if (containsKey(k) == true) {
return data.get(k);
}
return null;
}
/**
* getNumberOfEntries(K key) Gibt die Anzahl der Werte zurueck, die unter
* dem gegebenen Schluessel key abgespeichert ist. Die Methode wirft eine
* NullPointerException, falls das Argument null ist.
*
* @param key
* the key
* @return the number of entries
*/
public int getNumberOfEntries(K key) {
if (key == null) {
throw new NullPointerException();
}
if (!data.containsKey(key)) {
throw new IllegalArgumentException();
}
return data.get(key).size();
}
/**
* keySize() Gibt die Anzahl der unterschiedlichen Schluessel des Baumes
* zurueck, unter denen Werte abgespeichert sind.
*
* @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;
return data.size();
}
/**
* public int valueSize() Gibt die Anzahl der Werte im Baum zurueck
* (unabhaengig vom Schluessel unter dem sie jeweils abgespeichert sind).
*
* @return the int
*/
public int valueSize() {
// size = data.size();
// return size;
return size;
}
/**
* public V getFirstEntry() Gibt den "ersten" Wert des Baumes zurueck, d.h.
* einen Wert mit dem kleinsten Schluessel. Da es verschiedene Werte mit
* diesem Schluessel geben kann, ist nicht definiert, welcher dieser Werte
* tatsaechlich zurueckgegeben wird. Es ist aber wichtig, dass diese Methode
* den gleichen Wert zurueckgibt, der beim Aufruf der Methode
* removeFirstEntry() geloescht wuerde.
*
* @return the first entry
*/
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();
return firstIndexOf(liste);
}
// private V firstIndexOf(List<V> liste) {
//
// V firstIndexListe = firstIndexOf(liste);
// return firstIndexListe;
// }
/**
* First index of.
*
* @param liste
* the liste
* @return the v
*/
private V firstIndexOf(List<V> liste) {
return liste.get(0);
}
//
// private V lastIndexOf(List<V> liste) {
//
// V lastIndexListe = lastIndexOf(liste);
// return lastIndexListe;
// }
/**
* Last index of.
*
* @param liste
* the liste
* @return the v
*/
private V lastIndexOf(List<V> liste) {
return liste.get(0);
}
/**
* public V getLastEntry() Gibt den "letzten" Wert des Baumes zurueck, d.h.
* einen Wert mit dem groessten Schluessel. Da es verschiedene Werte mit
* diesem Schluessel geben kann, ist nicht definiert, welcher dieser Werte
* tatsaechlich zurueckgegeben wird. Es ist aber wichtig, dass diese Methode
* den gleichen Wert zurueckgibt, der beim Aufruf der Methode
* removeLastEntry() geloescht wuerde.
*
* @return the last entry
*/
public V getLastEntry() {
if (data.isEmpty()) {
throw new NoSuchElementException();
}
NavigableMap<K, List<V>> nav = new TreeMap<K, List<V>>();
nav = data;
List<V> liste = nav.lastEntry().getValue();
return lastIndexOf(liste);
}
/**
* public V removeFirstEntry() Entfernt den "ersten" Wert aus dem Baum, d.h.
* einen Wert mit dem kleinsten Schluessel. Da es verschiedene Werte mit
* diesem Schluessel geben kann, ist nicht definiert, welcher dieser Werte
* tatsaechlich geloescht wird. Es ist aber wichtig, dass diese Methode den
* gleichen Wert loescht, der beim Aufruf der Methode getFirstEntry()
* zurueckgegeben wuerde.
*
* @return the v
*/
public V removeFirstEntry() {
V ergebnis = getFirstEntry();
removeValue(ergebnis);
return ergebnis;
// if (data.isEmpty())
// throw new NoSuchElementException();
// return data.remove(getFirstEntry());
}
/**
* public V removeLastEntry() Entfernt den "letzten" Wert aus dem Baum, d.h.
* einen Wert mit dem groessten Schluessel. Da es verschiedene Werte mit
* diesem Schluessel geben kann, ist nicht definiert, welcher dieser Werte
* tatsaechlich geloescht wird. Es ist aber wichtig, dass diese Methode den
* gleichen Wert loescht, der beim Aufruf der Methode getLastEntry()
* zurueckgegeben wuerde.
*
* @return the v
*/
public V removeLastEntry() {
V ergebnis = getLastEntry();
removeValue(ergebnis);
return ergebnis;
// if (data.isEmpty())
// throw new NoSuchElementException();
//
// return data.remove(getLastEntry());
}
/**
* public Iterator<K> keys() Gibt einen Iterator ueber die Schluessel des
* Baums zurueck.
*
* @return the iterator
*/
public Iterator<K> keys() {
Iterator<K> it = keySet().iterator();
return it;
}
/**
* Gibt ein Set zuruck, das genau die Schlussel des Baumes enthalt.
*
* @return the sets the
*/
public Set<K> keySet() {
return data.keySet();
}
/**
* Diese Methode fugt alle Eintrage der gegebenen Map in den Baum ein, wobei
* die Schlussel aus der Map ubernommen werden. Die Methode wirft eine
* NullpointerException, falls das Argument null ist.
*
* @param t
* the t
*/
public void putAll(Map<? extends K, ? extends V> t) {
for (Entry<? extends K, ? extends V> iterable_element : t.entrySet()) {
put(iterable_element.getKey(), iterable_element.getValue());
}
// if (data.isEmpty())
// throw new NullPointerException();
// data.putAll(t);
}
/**
* public void put(K key, V value) Fuegt den gegebenen Wert in den Baum ein.
* Der Wert wird entweder in die Liste, die dem gegebenen Schluessel
* zugeordnet ist eingefuegt, falls eine solche Liste existiert. Ist das
* nicht der Fall, muss eine neue Liste erzeugt werden. Sie koennen fuer die
* Listen eine beliebige Klasse benutzen, die das java.util.List-Interface
* implementiert, wie z.B. die Klasse java.util.LinkedList. Die Methode
* wirft eine NullPointerException, falls eines der Argumente null ist.
*
* @param key
* the key of the given element
* @param value
* the value of the given element
*/
public void put(K key, V value) {
if (key == null || value == null) {
throw new NullPointerException();
}
if (containsKey(key)) {
data.get(key).add(value);
} else {
K key2 = key; // Create a key
List<V> values = new LinkedList<V>(); // create a list values
values.add(value);
data.put(key2, values); // add a key-value pair
}
size++;
}
/**
* public void remove(K key) Diese Methode entfernt alle Werte mit dem
* gegebenen Schluessel aus dem Baum. Die Methode wirft eine
* NullPointerException, falls das Argument null ist.
*
* @param key
* the key
*/
public void remove(K key) {
if (key == null) {
throw new NullPointerException();
}
while (containsKey(key)) {
size -= data.get(key).size();
data.remove(key);
}
}
/**
* public void removeValue(V value) Diese Methode entfernt jeden Wert aus
* dem Baum, der gleich dem Argument value ist. Beachten Sie, dass der Wert
* mehrfach und unter verschiedenen Schluesseln abgelegt sein kann. Die
* Methode wirft eine NullPointerException, falls das Argument null ist.
*
* @param value
* the value
*/
public void removeValue(V value) {
if (value == null) {
throw new NullPointerException();
}
Collection<List<V>> val = this.data.values();
for (List<V> list : val) {
list.remove(value);
size--;
}
Set<K> key = keySet();
K[] keysarray = (K[]) key.toArray();
for (int i = 0; i < keysarray.length; i++) {
if (get(keysarray[i]).isEmpty()) {
remove(keysarray[i]);
}
}
// while (containsValue(value)) {
//
// data.remove(value);
// }
}
/**
* public void removeValue(K key, V value) Entfernt jeden Wert aus dem Baum,
* der gleich dem Argument value ist und den Schluessel key besitzt. Die
* Methode wirft eine NullPointerException, falls eines der Argumente null
* ist.
*
* @param key
* the key
* @param value
* the value
*/
public void removeValue(K key, V value) {
if (key == null || value == null) {
throw new NullPointerException();
}
if (this.containsKey(key)) {
this.get(key).remove(value);
size--;
if (this.get(key).isEmpty()) {
this.remove(key);
}
}
// while (containsKey(key) && containsValue(value)) {
// data.remove(value);
// }
}
/**
* public boolean isEmpty() Diese Methode gibt genau dann true zurueck, wenn
* kein Wert im Baum gespeichert ist.
*
* @return true if the map is empty, false if not
*/
public boolean isEmpty() {
return data.isEmpty();
}
/**
* public void changeKey(K oldKey, K newKey, V value) Diese Methode ordnet
* dem Wert value aus dem Baum, der unter dem Schluessel oldKey gespeichert
* ist, einen neuen Schluessel zu, naemlich newKey. Die alte Zuordnung wird
* dabei entfernt. Befindet sich bereits vor Ausfuehrung dieser Methode kein
* entsprechender Wert im Baum, so bleibt dieser durch die Methode
* unveraendert. Die Methode wirft eine NullPointerException, falls eines
* der Argumente null ist.
*
* @param oldKey
* the old key
* @param newKey
* the new key
* @param value
* the value
*/
public void changeKey(K oldKey, K newKey, V value) {
if (oldKey == null || newKey == null || value == null) {
throw new NullPointerException();
}
changeKey(oldKey, newKey);
put(newKey, value);
}
/**
* public void changeKey(K oldKey, K newKey) Ordnet allen Werten des Baumes,
* die unter dem Schluessel oldKey zu finden waren, den neuen Schluessel
* newKey zu und entfernt alle alten Zuordnungen. Die Methode wirft eine
* NullPointerException, falls eines der Argumente null ist.
*
* @param oldKey
* the old key
* @param newKey
* the new key
*/
public void changeKey(K oldKey, K newKey) {
if (oldKey == null || newKey == null) {
throw new NullPointerException();
}
if (containsKey(oldKey)) {
return;
}
data.put(newKey, get(oldKey));
data.remove(oldKey);
}
Die JUnit-Fehler lautet:
[junit] Testcase: testMutatorPermutations took 0.081 sec
[junit] Caused an ERROR
[junit] [Ljava.lang.Object; cannot be cast to [Ljava.lang.Comparable;
[junit] java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Comparable;
[junit] at jpp.listtree.ListTree.removeValue(ListTree.java:422)
[junit] at tests.reqTests.TestListTree.removeValue(TestListTree.java:169)
[junit] at tests.reqTests.TestListTree.performAction(TestListTree.java:272)
[junit] at tests.reqTests.TestListTree.testMutatorPermutations(TestListTree.java:292)
[junit]
[junit] Testcase: firstLastEntryTest took 0.001 sec
[junit] Caused an ERROR
[junit] [Ljava.lang.Object; cannot be cast to [Ljava.lang.Comparable;
[junit] java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Comparable;
[junit] at jpp.listtree.ListTree.removeValue(ListTree.java:422)
[junit] at jpp.listtree.ListTree.removeFirstEntry(ListTree.java:277)
[junit] at tests.reqTests.TestListTree.firstLastEntryTest(TestListTree.java:331)
[junit]
[junit] Test tests.reqTests.TestListTree FAILED
Ich bedanke mich für Ihre Mühe
Zuletzt bearbeitet von einem Moderator: