Treemap remove

W

watle

Mitglied
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
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:
F

FArt

Top Contributor
Übersetzung: Object cannot be cast to java.lang.Comparable
Anscheinend müssen die Objekte Comparable implementieren, tun es aber nicht.
 
A

Andi_CH

Top Contributor
EDIT: na ja geht ja irgendwie alles auf remove zurück.
Eclipse sagt ja sogar Unchecked cast und dort knallt es auch

Code:
 K[] keysarray = (K[]) key.toArray();

Keine Ahnung was die Methode remove eigentlich machen soll .....


Der header ist auch noch spannend :)
Wenn schon kopieren sollte es wenigstens etwas lauffähiges sein ;-)
Java:
/**
 * The Class ListTree.
 *
 * @param <K> the Key
 * @param <V> the Value into the key
 * @author Sylvain F
 */
/**
 * @author kathrin
 * 
 * @param <K>
 * @param <V>
 */
 
Zuletzt bearbeitet:
W

watle

Mitglied
Danke FArt,
wie soll ich es nun tun? Wenn du mir weiterhelfen kann, wäre es gut. Vielen Dank dich den Code anzuschauen.
 
W

watle

Mitglied
Das Problem war mit dem Code:
K[] keysarray = (K[]) key.toArray();

Danke für eure Hilfe
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
H TreeMap.remove(value) - und nicht mit key! Geht das? Java Basics - Anfänger-Themen 18
G Map (TreeMap in TreeMap) Java Basics - Anfänger-Themen 1
N TreeMap alphabetisch sortieren? Java Basics - Anfänger-Themen 3
O Erste Schritte TreeMap nach Value sortieren Java Basics - Anfänger-Themen 2
H Collections Was ist schneller - HashMap + Sort v TreeMap? Java Basics - Anfänger-Themen 75
D TreeMap: Höheren Key ermitteln und den Value liefern Java Basics - Anfänger-Themen 3
C TreeMap Abfragen Problem Java Basics - Anfänger-Themen 7
F HashMap vs. TreeMap Java Basics - Anfänger-Themen 5
I TreeMap Java Basics - Anfänger-Themen 4
H TreeMap/HashMap synchronisieren Java Basics - Anfänger-Themen 2
M TreeMap Java Basics - Anfänger-Themen 4
H TreeMap<> statt TreeMap<Long, String> Java Basics - Anfänger-Themen 2
algebraiker TreeMap<Date,Object> navigieren? Java Basics - Anfänger-Themen 24
N Frage zu TreeMap Java Basics - Anfänger-Themen 3
B OOP Jtree aus TreeMap<String, String[]> erstellen? Java Basics - Anfänger-Themen 6
H Datentypen TreeMap<Double, Object> - negative Werte? Java Basics - Anfänger-Themen 4
H TreeMap Rückgabe - Compiler-Warnings Java Basics - Anfänger-Themen 9
S Studentenverwaltung mit TreeMap Java Basics - Anfänger-Themen 8
F Treemap und Sortierung? Java Basics - Anfänger-Themen 2
G TreeMap Java Basics - Anfänger-Themen 6
T TreeMap lässt sich nicht sortieren Java Basics - Anfänger-Themen 8
P wie clont sich eine TreeMap? Java Basics - Anfänger-Themen 8
G TreeMap Probleme. Java Basics - Anfänger-Themen 10
G TreeMap vom 1. bis letzte eintrag durchgehen Java Basics - Anfänger-Themen 17
F TreeMap speichern und lesen Java Basics - Anfänger-Themen 3
Q TreeMap immer sortiert halten Java Basics - Anfänger-Themen 9
H Treemap mit zusammengesetzten Key erstellen Java Basics - Anfänger-Themen 13
G TreeMap sortieren über ArrayList als Value Java Basics - Anfänger-Themen 9
O TreeMap nach Object[] casten? Java Basics - Anfänger-Themen 3
G Java LinkedList remove Methode Java Basics - Anfänger-Themen 5
D remove arraylist by id not work Java Basics - Anfänger-Themen 6
H Collections JTree remove zeigt keinen Effekt! Java Basics - Anfänger-Themen 8
B Sorting List und Remove Java Basics - Anfänger-Themen 2
P Map - remove() ? Java Basics - Anfänger-Themen 46
Hacer remove at index Java Basics - Anfänger-Themen 31
J Methoden Doppelt verkettete Liste remove(Object) Java Basics - Anfänger-Themen 8
S Vererbung remove elment from Array Java Basics - Anfänger-Themen 0
J easy remove method Java Basics - Anfänger-Themen 1
K Methoden Probleme mit LinkedList.remove(object) Java Basics - Anfänger-Themen 1
U PriorityQueue remove Java Basics - Anfänger-Themen 2
M ArrayList - remove() löscht nicht! - weiß nicht wieso! Java Basics - Anfänger-Themen 8
B map.remove(long) Java Basics - Anfänger-Themen 5
Q queue.remove Element trotzdem noch vorhanden. Java Basics - Anfänger-Themen 10
B LinkedList remove Java Basics - Anfänger-Themen 5
I Liste Remove erstes Element Java Basics - Anfänger-Themen 5
D Wie Iterator Remove implementieren? Java Basics - Anfänger-Themen 11
H Remove Methode von List Java Basics - Anfänger-Themen 6
W ArrayLists: Verständnisproblem bei remove() Java Basics - Anfänger-Themen 2
C Datentypen ArrayList.remove(index) hinterlässt leeres Feld Java Basics - Anfänger-Themen 5
S OOP ArrayList Klasse nachbauen, prob mit remove Java Basics - Anfänger-Themen 5
U ArrayList.remove(i) funktioniert nicht Java Basics - Anfänger-Themen 9
J Remove from an AraayList Java Basics - Anfänger-Themen 8
J Iterator remove()? Java Basics - Anfänger-Themen 5
T ArrayList#remove Java Basics - Anfänger-Themen 8
M ArrayList remove Element? Java Basics - Anfänger-Themen 3
B HashMap remove Java Basics - Anfänger-Themen 2
J TreeSet methode Remove Java Basics - Anfänger-Themen 13
C Add / Remove Panel Java Basics - Anfänger-Themen 2
J remove Problem Java Basics - Anfänger-Themen 8
M remove()-Methode eines Iterators Java Basics - Anfänger-Themen 3
megachucky remove bei Vector klappt nicht Java Basics - Anfänger-Themen 11
M Problem mit Iterator.remove() Java Basics - Anfänger-Themen 5

Ähnliche Java Themen

Anzeige

Neue Themen


Oben