Fehler bei überschreiben eines Eintrags

[port45]

Hallo zusammen,

habe ein kleines Problem mit einer Hausaufgabe... bin schon seit ein paar Tagen dran und habe glaub ich nur noch einen kleinen Fehler im Programm.
Das Programm muss bestimmte Test durch JUnit bestehen, aber irgendwie find ich nicht den Fehler:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

/**
 * Die Klasse implementiert ein Verzeichnis, in dem nach unter einem Schluessel
 * gespeicherten Daten gesucht werden kann.
 */
public final class LinearMap<K, V> implements IMap<K, V> {
    /*
     * Hinweis:
     * 
     * @Override zeigt, dass eine Methode einer Oberklasse ueberschrieben wird
     * oder die Methode eines Interfaces implementiert wird.
     * 
     * Im letzten Jahr waren diese Annotationen noch auskommentiert, da
     * Java 5 damit Probleme hat. 
     * 
     * Bei sourcce->Clean Up fuegt Eclipse diese automatisch ein. Sie sind auch
     * sinnvoll, da sie Lesbarkeit und Fehlersicherheit verbessern.
     * Die Studierenden brauchen sie aber erst nicht zu beachten.
     * 
     * In Eclipse wird override am Rand durch einen gruenen Pfeil nach oben
     * angezeigt. Implementierung erkennt man an dem blauen Dreieck.
     */

    private static final int NOT_FOUND = -1;

    /**
     * Anzahl der gespeicherten Key-Value-Paare.
     */
    private int size = 0;

    /**
     * Feld mit den Daten.
     * <p>
     * Umgeht die Probleme beim Anlegen eines neuen Arrays mit Typparameter.
     * Beim Erzeugen einess Arrays darf kein Typparameter verwendet werden.
     */
    @SuppressWarnings("unchecked")
    private KeyValuePair<K, V>[] data = new KeyValuePair[4];

    @Override
    public int size() {
        return 0;
    }

    @Override
    public V put(K key, V value) 
    {
    	
            // TODO: Was zu tun?
    	 if(key == null)
      	   throw new NullPointerException();
        
     	 int index = indexOf(key);
         checkCapacity();
        	 if(index == NOT_FOUND) 
        	 {
        		 data[size++] = new KeyValuePair<K,V> (key, value);
        		 return null;
        	 } 
        	 else 
        	 {
        		 V temp = data[index].getValue();
        		 data[index] = new KeyValuePair<K,V>(key, value);
        		 return temp;
        	 }
      }
    

    /**
     * Sorgt dafuer, dass das data-Array gross genug ist. Bei Bedarf, werden
     * die Daten in ein doppelt grosses Array uebernommen.
     */
    private void checkCapacity() 
    {
        if (size == data.length)
            data = Arrays.copyOf(data, size * 2);
    }

    
	@Override
    public V get(K key) {
        // TODO: Was zu tun?
    	if (key == null)
            throw new NullPointerException();
    	 int index = indexOf(key);
    	 return index == NOT_FOUND ? null : data[index].getValue();
        
        
    }

    @Override
    public boolean containsKey(K key) {
        // TODO: Was zu tun?
    	if (key == null)
            	throw new NullPointerException(); 
    	
    	
    		return indexOf(key)!=NOT_FOUND;
    	
        
    }

    @Override
    public V remove(K key) 
    {
        // TODO: Was zu tun?
    	if (key == null)
            throw new NullPointerException();
    	 
    	int index = indexOf(key);
    	V value = get(key);
    	
    	if(index != NOT_FOUND) 
    	{
    		if(value != null)
    		{
    			for(int j = index;j<data.length - 1;j++) 
    			{
    				data[j] = data[j+1];
    			}
    			size--;
    		}
    		return value;
    	 }
    	 return null;
    }

    /**
     * Sucht in dem Array data nach einem Key-Value-Paar das zu dem gesuchten
     * 'key' passt. Wenn gefunden wird der Feldindex zurueckgegeben. Wenn nicht,
     * der Wert 'NOT_FOUND'.
     * <p>
     * Es ist nicht erlaubt, dass <tt>key == null</tt> ist.
     * 
     * @param key
     *            der zu suchende Schluessel
     * @return NOT_FOUND oder der index wo key gefunden wurde.
     * @throws NullPointerException
     *             wenn <tt>key</tt> gleich <tt>null</tt> ist.
     */
   
	private int indexOf(K key) 
	{
      if (key == null)
            throw new NullPointerException();
        // TODO: Was zu tun?
      
      for(int i = 0; i<data.length;i++)
      {
    	  if(data[i] != null)
    	  {
    		  if(data[i].getKey().equals(key))
    		  {
    			  return i;
    		  }
    	  }
       }
       return NOT_FOUND;
    }

    @Override
    public Set<K> keys() {
        Set<K> keys = new HashSet<K>(2 * size);
        for (int i = 0; i < size; i++)
            keys.add(data[i].getKey());
        return keys;
    }

    @Override
    public Collection<V> values() {
        Collection<V> values = new ArrayList<V>(size);
        for (int i = 0; i < size; i++)
            values.add(data[i].getValue());
        return values;
    }

    @Override
    public String toString() {
        return Arrays.toString(data);
    }
}

Ich glaube das der Fehler bei der Methode "PUT" ist.
Test:

public void testOverwriting() {
        objTable.put(K1, K2);
        assertSame("das eingetragene Objekt kommt nicht wieder zurueck",
                K2, objTable.get(K1));
        objTable.put(K1, K3);
        assertSame("beim Ueberschreiben darf kein neues Objekt angelegt werden",
            K3, objTable.get(K1));
        assertTrue("zuviele Vergleiche!", 3 >= K1.getCompares());
        assertEquals(1, objTable.size());

Beschreibung der Methode:

/**
     * Traegt ein Objekt unter einem Suchbegriff ein.
     * Wenn der Suchbegriff bereits vorhanden, wird die zugehoerige
     * Objektreferenz ueberschrieben und das vorher dort gespeicherte
     * Objekt wird zurueckgegeben. Wenn bisher unter dem Schluessel kein
     * Objekt gespeichert war, wird <code>null</code> zurueckgegeben.
     * 
     * @param key Suchschluessel.
     * @param value Inhaltsobjekt.
     * @return vorheriger Eintrag oder <code>null</code>.
     * @throws NullPointerException wenn <code>key == null</code>
     */
    public V put(K key, V value);

Versteh ich das richtig das ich den Eintrag falsch überschreibe?
das ich einfach wenn ich überschreibe kein new benutzen darf?

Bin echt am verzweifeln

Edit: Achso meine Fehlerausgabe:
java.lang.AssertionError: expected:<1> but was:<0>
at org.junit.Assert.fail(Assert.java:88)
at org.junit.Assert.failNotEquals(Assert.java:743)
at org.junit.Assert.assertEquals(Assert.java:118)
at org.junit.Assert.assertEquals(Assert.java:555)
at org.junit.Assert.assertEquals(Assert.java:542)
at BasicLinearMapTest.testOverwriting(BasicLinearMapTest.java:154)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:47)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:44)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:271)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:70)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:50)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:238)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:63)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:236)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:53)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:229)
at org.junit.runners.ParentRunner.run(ParentRunner.java:309)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)

 

[turtle]

Ich BEHAUPTE , das dein Code so keinen Sinn macht.
Ich habe folgendes

	@Test
	public void testOverwriting() {
		LinearMap<String, String> objTable = new LinearMap<>();
		String K1 = "turtle";
		String K2 = "doof";
		String K3 = "schlau";
		objTable.put(K1, K2);
		assertSame("das eingetragene Objekt kommt nicht wieder zurueck", K2, objTable.get(K1));
		objTable.put(K1, K3);
		assertSame("beim Ueberschreiben darf kein neues Objekt angelegt werden", K3, objTable.get(K1));
		// assertTrue("zuviele Vergleiche!", 3 >= K1.getCompares()); Nee
		assertEquals(1, objTable.size());
	}

LinearMap ist generisch und kann also mit allen möglichen Typen instanziert werden. Ich mache das mit LinearMap<String, String>.

Also macht die Anweisung K1.getCompares() keinen Sinn, denn diese ist für String nicht definiert.

PS: Variable beginnen mit einem Kleinbuchstaben, Klassennamen mit einem Grossbuchstaben.

 

[port45]

Die Testklasse stimmt aber komplett ich musste nur den Code in der Klasse LinearMap einfügen damit die Tests ja alle klappen.

Dennoch funktioniert das nicht so wie ich bereits beschrieben habe...

Jemand eine Idee?