Collections Suche etwas Sorted-List-Artiges...hat jemand eine Idee?

Guten Abend

Folgendes Problem: Ich hab eine Klasse wie diese:
Java:
public enum Side{
    LEFT,
    RIGHT
}

public class SortableObject{
    public final Side mySide;
}
Jetzt will ich eine Liste haben, die die Elemente so anordnet, daß z.B. alle Objekte mit mySide == LEFT; zuerst stehen, und danach jene mit mySide == RIGHT;. Innerhalb dieser zwei Blöcke möchte ich die Items jedoch umherschieben können.

Kennt da jemand etwas? Ich habe da etwas im Hinterkopf, womit man mittels Interface eine Sortiermethode implementieren muß, komme aber nicht mehr drauf was es war, aber so in etwa stelle ich mir das vor.
 
Zum Beispiel Map<Side, List<SortableObject>> (falls es irgendwann noch weitere Seiten gibt) oder einfach zwei Listen, eine für LEFT und eine für RIGHT.

String steht dabei stellvertretend für deinen zu speichernden Typen. Dazu brauchts du ggf. noch ein paar Methoden zum Füllen und Auslesen der Liste. Genaueres kann ich nicht sagen, ohne den genauen Anwendungsfall zu kennen.

Ergänzung: Alles das wird natürlich in einer separaten Klasse gekapselt.
 
Zwei Listen sind leider keine Option.

Es geht um Folgendes: Ich habe nach diesem Thread hier
eine Tabelle geschrieben. Diese Tabelle hält Items in Zeilen und Spalten, besitzt Header für beides, und stellt die Items einerseits mit den ihnen zugeordneten Headern sowie deren kompletter Spalte in Beziehnung. (Was man mit dieser Beziehung macht hängt von der konkreten Implementierung ab, da sind einige abstrakte Klassen die dazu überschrieben werden müssen, die jedoch die Basisfunktionalitäten mitbringen). Außerdem ist die Tabelle in der Lage, ein Modell ihrer selbst zu liefern. Dies hat den Zweck, nicht ständig die vollständigen Nutzdaten umherkarren zu müssen.

Um es kurz zu machen: Diese Tabelle funktioniert ausgezeichnet, der Wunsch nach Sortierung war da aber noch nicht eingeplant. Dafür will ich eine neue Klasse "SortedRowTable" schreiben.
Im Wesentlichen funktioniert die Klasse bisher wie folgt:
Alle Items werden über Identifier-Objekte identifiziert. Ein Identifier-Objekt hat eigentlich nichts weiter zu tun als einzigartig zu sein und sich vergleichen zu lassen.

Jetzt habe ich die Sortierung der Tabelle über zwei ArrayLists<Identifier> gelöst, je eine für Zeilen- und eine für Spaltenidentifier. Für diesen Mechanismus muß ich mir etwas anderes einfallen lassen.

Wenn ich es recht überlege: Ich bräuchte nicht nur ein SortedArrayList<>, sondern eine SortedHashMap<Key, Value>, also eine Kreuzung aus HashMap und SortedList. Denn die Sortierung würde über die Headerobjekte laufen, die will ich miteinander vergleichen.

Ich sag mal so: Ich habe keine Skrupel, etwas selber zu stricken wenn es nichts Fertiges gibt. (Wo ich schon eine Baumstruktur und das TableSet-Zeugs implementiert habe wo ich mir bis heute nicht sicher bin, ob ich meine Gedankengänge im verlinkten Thread deutlich machen konnte...)

Edit:
Den Indexzugriff würde ich gerne behalten bei dem, was ich suche.
 
Ich hab noch nicht so ganz verstanden, was du wie und wonach sortieren willst, kannst du mal ein ganz einfaches Beispiel geben?

Die "SortedHashMap" kann man verschieden interpretieren, eine Map sortiert nach Keys, eine Map sortiert nach Keys mit sortierten Listen als Value oder eine Map mit sortierten Listen als Value, welches davon brauchst du?

Möglicherweise auch einfach nur eine List<Tupel<X,Y>>, wobei erst nach X und dann nach Y sortiert wird?
 
Beispiel:
Java:
//Danach soll sortiert werden:
public enum Numeric {
    FIRST,
    SECCOND
}

//Beteiligte Klassen
public class SortableItem implements Comparable{
    public final Numeric num;
  
    @Override
    int compareTo(SortableItem item){
        if(num == SECCOND && item.num == FIRST){return -1;}
        if(num == FIRST && item.num == FIRST){return 0;}
        if(num == SECCOND && item.num == SECCOND){return 0;}
        if(num == FIRST && item.num == SECCOND){return 1;}
    }
}

public class Identifier{
    @Override
    public boolean equals(Objekct o){
        return this == o;
    }
}


//Die Lösung die ich suche:
SortedHashmapList<key, value>

//Und so soll die Liste benutzt werden:
SortedHashmapList<Identifier, SortableItem> list = new SortedHashmapList<>();

SortableItem first = new SortableItem(FIRST);
SortableItem seccond = new SortableItem(SECCOND);
SortableItem third = new SortableItem(FIRST);

//Liste füllen:
Identifier i0 = new Identifier;
Identifier i1 = new Identifier;
Identifier i2 = new Identifier;

list.add(i0, first);
list.add(i1, seccond);
list.add(i2, third);

//Elemente ausgeben:
list.get(0); //Erwarte 'first'
list.get(1); //Erwarte 'third', da third mit FIRST initialisiert ist
list.get(2); //Erwarte 'seccond', da seccond mit SECCOND initialiert ist

//Aber auch:
list.get(i0); //Erwarte 'first'
list.get(i1); //Erwarte 'seccond'
list.get(i2); //Erwarte 'third'
Ist das verständlicher?

Nachtrag:
@mrBrown
Möglicherweise auch einfach nur eine List<Tupel<X,Y>>, wobei erst nach X und dann nach Y sortiert wird?
Nein, ja...List<Tupel<X,Y>> wäre das im Prinzip. Es soll allerdings nur nach Y sortiert werden, und die Key-Funktion (darf nur einmal vorkommen) von X sollte erhalten bleiben. Bzw. sollte über X auf Y zugegriffen werden können.
 
Zuletzt bearbeitet:
Ah, also im wesentlichen eine Collection, die ungefähr folgendes anbietet:

add(Key, Value)
get(Key) - gibt den Wert für den Key zurück
get(index) - gibt das n'te Element zurück, wobei sich der index auf eine sortierte Liste aller Values bezieht

Ne passende Collection ist mir da nicht bekannt, SortedMap zB sortiert nur nach Keys, das müsste man also selber bauen (wobei vielleicht irgendeine Lib was passendes bietet.)

Im einfachsten Fall könnte man das erreichen, wenn man einfach Daten intern als Map und als Liste vorhält, wobei man letztere dauerhaft sortiert hält (zB immer passend einfügen oder über Collections.sort).
Alle verändernden Methoden fügen immer in beide ein, alle nur lesenden Methoden nutzen jeweils die passende Datenstruktur für den Zugriff.
 
Ja, das wird wohl das Einfachste sein. Ich hab grad mal geschaut wie HashMap eigentlich funktioniert-das wird wohl kaum anders gehen als mit zwei Collections. Für das, was ich vorhabe, muß die Collection nicht allzu schnell sein, aber wer weiß wofür ich (oder wer anders, ich werd das Ergebnis sicher wieder hier reinstellen) das mal gebrauchen wird.
 
Damit wäre die Liste doch wieder nicht sortiert...
Naja, wenn ich nur zwei Einträge in der Enumeration, aber z.B. 10 Elemente in der Liste habe, dann ist da durchaus noch Platz zum Herumrangieren. In dem Beispiel oben hab ich die Reihenfolge first, third, seccond, der Sortieralgorythmus (der sich ja nur nach FIRST und SECCOND richtet und Mehrfacheinträge zulässig sind) würde aber third, first, seccond genauso unangetastet lassen. Der Index der Elemente wäre aber ein neuer.
 
Die Liste ist aber "final" also es dürfen keine neuen Objekte hinzugefügt werden oder? Das heißt, es dürfen nur in der vorhandenen Liste Plätze getauscht werden? Falls ja, dann würde ich mir sowas basteln:


Java:
public enum Numeric {
    FIRST,
    SECOND;
}

Java:
public class SortableObject {
    
    private final int id;
    private final Numeric numeric;   

    public SortableObject(int id, Numeric numeric) {
        this.id = id;
        this.numeric = numeric;   
    }

    public int getId() {
        return id;
    }
      
    public Numeric getNumeric() {
        return numeric;
    }   

    @Override
    public String toString() {
        return "SortableObject id: " +id + " numeric: " + numeric;
    }   
}

Java:
public class SwapableList extends AbstractList<SortableObject>{

    private final List<SortableObject> objects;

    public SwapableList(List<SortableObject> objects) {
        this.objects = new ArrayList<>(objects);
        Collections.sort(this.objects, Comparator.comparing(SortableObject::getNumeric));
    }
          
    public boolean swap(SortableObject o1, SortableObject o2) {       
        //Wenn beide Objekte unterschiedliche numeric haben, dürfen sie nicht getauscht werden, 
       // da sie sonst den "Block" verlassen würden       
        if(o1.getNumeric() != o2.getNumeric()) {
            return false;
        }
                
        int pos1 = objects.indexOf(o1);
        
        //Objekt o1 nicht in der Liste
        if(pos1 < 0) {
            return false;
        }
        
        int pos2 = objects.indexOf(o2);       
        //Objekt o2 nicht in der Liste
        if(pos2 < 0) {
            return false;
        }
        
        objects.set(pos2, o1);
        objects.set(pos1, o2);
        
        return true;
    }
    
    @Override
    public SortableObject get(int index) {
        return objects.get(index);
    }

    @Override
    public int size() {
        return objects.size();
    }   
}
Java:
    public static void main(String[] args) {       
        
        SortableObject o1 = new SortableObject(1, Numeric.FIRST);
        SortableObject o2 = new SortableObject(2, Numeric.SECOND);
        SortableObject o3 = new SortableObject(3, Numeric.FIRST);
        SortableObject o4 = new SortableObject(4, Numeric.SECOND);
        SortableObject o5 = new SortableObject(5, Numeric.FIRST);
        SortableObject o6 = new SortableObject(6, Numeric.FIRST);
        
        List<SortableObject> objects = Arrays.asList(o1, o2, o3, o4, o5, o6);
              
        System.out.println("Unsortiert");
        System.out.println(objects);
        
        SwapableList swapableList = new SwapableList(objects);
        
        System.out.println("Sortiert");
        System.out.println(swapableList);
        
        swapableList.swap(o1, o6);
        
        System.out.println("Nach vertauschen von o1 und o6");
        System.out.println(swapableList);
    }
 
Mal eine Frage: Ich will jetzt einen Sortieralgorithmus implementieren. Die Objekte, nach denen sortiert wird, implementieren das Comparable-Interface ( Zahl <0, 0 oder >0 wenn das Objekt kleiner, gleich oder größer dem Vergleichspartner ist).

Hat jemand einen Vorschlag, welchen Algorithmus ich dafür am Besten verwenden sollte? Und kann mir den kurz erklären? Es gibt ja anscheinend unzählige, aber gut sind längst nicht alle.
 
Danke euch...jetzt funktioniert es. :)

Als Revange dafür hier der Quellcode für die Klasse zur freien Verwendung.
Java:
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;

//package private
class Tupel<K, V extends Comparable> implements Comparable<Tupel>{
    public final K k;
    public final V v;
  
    Tupel(K k, V v) {
        this.k = k;
        this.v = v;
    }

    @Override
    public int compareTo(Tupel o) {
        return v.compareTo(o.v);
    }
}

public class SortedHashmapList<K, V extends Comparable>{
  
    private HashMap<K, V> hm;
    private ArrayList<Tupel<K, V>> l;

    public SortedHashmapList() {
        this.hm = new HashMap<K, V>();
        this.l = new ArrayList<>();
    }

    /**
     * Calling this method brings all elements in an order, which is
     * defined about the implemented Comparable interface by the
     * value objects.
     */
    public void sort(){
        Collections.sort(l);
    }
  
  
//    @Override
//    public void sort(Comparator<? super Entry<K, V>> c) {
//        super.sort(c);
//    }

//    @Override
//    public void replaceAll(UnaryOperator<Entry<K, V>> operator) {
//        super.replaceAll(operator);
//    }

//    @Override
//    public boolean removeIf(Predicate<? super Entry<K, V>> filter) {
//        return super.removeIf(filter);
//    }

//    @Override
//    public Spliterator<Entry<K, V>> spliterator() {
//        return super.spliterator();
//    }

//    @Override
//    public void forEach(Consumer<? super <V>> action) {
//        super.forEach(action);
//    }
//
//    @Override
//    public List<V> subList(int fromIndex, int toIndex) {
//        return super.subList(fromIndex, toIndex);
//    }
//
//    @Override
//    public Iterator<Entry<K, V>> iterator() {
//        return super.iterator();
//    }
//
//    @Override
//    public ListIterator<Entry<K, V>> listIterator() {
//        return super.listIterator();
//    }
//
//    @Override
//    public ListIterator<Entry<K, V>> listIterator(int index) {
//        return super.listIterator(index);
//    }
//
//    @Override
//    public boolean retainAll(Collection<?> c) {
//        return super.retainAll(c);
//    }
//
//    @Override
//    public boolean removeAll(Collection<?> c) {
//        return super.removeAll(c);
//    }
//
//    @Override
//    protected void removeRange(int fromIndex, int toIndex) {
//        super.removeRange(fromIndex, toIndex);
//    }
//
//    @Override
//    public boolean addAll(int index, Collection<? extends Entry<K, V>> c) {
//        return super.addAll(index, c);
//    }
//
//    @Override
//    public boolean addAll(Collection<? extends Entry<K, V>> c) {
//        return super.addAll(c);
//    }
//
//    @Override
//    public void clear() {
//        super.clear();
//    }
//
//    @Override
//    public boolean remove(Object o) {
//        return super.remove(o);
//    }
  
    /**
     * Removes the element with the specified key in this list
     * (optional operation). Shifts any subsequent elements to the
     * left (subtracts one from their indices). Returns the element
     * that was removed from the list.
     *
     * @param key key whose mapping is to be removed from the MapList.
     * @return the previous value associated with key, or null if
     * there was no mapping for key. (A null return can also indicate
     * that the map previously associated null with key.)
     */
    public V remove(K key) {
        if(hm.containsKey(key)){
            Tupel<K, V> t = new Tupel<>(key, hm.remove(key));
            l.remove(t);
            return t.v;
        }
        return null;
    }

    /**
     * Removes the element at the specified position in this list
     * (optional operation). Shifts any subsequent elements to the
     * left (subtracts one from their indices). Returns the element
     * that was removed from the list.
     *
     * @param index the index of the element to be removed
     * @return the element previously at the specified position
     */
    public V remove(int index) {
        hm.remove(l.get(index).k);
        return l.remove(index).v;
    }


    /**
     * Appends the specified element to the end of this list.
     * Return true, if appending was successfully.
     * False otherwise. This will happen, e.g. if the instance contains
     * even the key object.
     *
     * @param key is the key to access the value object.
     * @param value is linked with the key.
     * @return false, if adding goes wron. True otherwise.
     */
    public boolean add(K key, V value) {
        if(!hm.containsKey(key)){
            l.add(new Tupel<>(key, value));
            hm.put(key, value);
            return true;
        }
        return false;
    }

//    @Override
//    public Entry<K, V> set(int index, Entry<K, V> element) {
//        return super.set(index, element);
//    }

    /**
     * Returns the element at the specified position in this list.
     *
     * @param index index of the element to return.
     * @return the element at the specified position in this list.
     */
    public V getValue(int index) {
        return l.get(index).v;
    }


//    /**
//     * Returns an array containing all of the elements in this list in
//     * proper sequence (from first to last element).<p>
//     *
//     * The returned array will be "safe" in that no references to it
//     * are maintained by this list. (In other words, this method must
//     * allocate a new array). The caller is thus free to modify the
//     * returned array.
//     *
//     * @return an array containing all of the elements in this list in
//     * proper sequence.
//     */
//    public V[] toArray() {
//        V g[];
//        ArrayList<V> vl = new ArrayList<>();
//        l.forEach((t) -> {vl.add(t.v);});
//        return (V[]) vl.toArray();
//    }
//
//    @Override
//    public Object clone() {
//        return super.clone();
//    }
//
    /**
     * Returns the index of the last occurrence of the specified
     * element in this list, or -1 if this list does not contain the
     * element. More formally, returns the highest index i such that
     * (o==null ? get(i)==null : o.equals(get(i))), or -1 if there is
     * no such index.
     *
     * @param o element to search for.
     * @return the index of the last occurrence of the specified
     * element in this list, or -1 if this list does not contain the
     * element.
     */
    public int lastIndexOf(Object o) {
        for(int i = l.size() -1; i > 0; i--){
            if(l.get(i).v == o){return i;}
        }
        return -1;     
    }

    /**
     * Returns the index of the first occurrence of the specified
     * element in this list, or -1 if this list does not contain the
     * element. More formally, returns the lowest index i such that
     * (o==null ? get(i)==null : o.equals(get(i))), or -1 if there is
     * no such index.
     *
     * @param o element to search for.
     * @return the index of the first occurrence of the specified
     * element in this list, or -1 if this list does not contain the
     * element.
     */
    public int indexOf(Object o) {
        for(int i = 0; i < l.size(); i++){
            if(l.get(i).v == o){return i;}
        }
        return -1;
    }

    /**
     * Returns true if this list contains the specified element.
     * ore formally, returns true if and only if this list contains at
     * least one element e such that (o==null ? e==null : o.equals(e)).
     *
     * @param o element whose presence in this list is to be tested.
     * @return true if this list contains the specified element.
     * False otherwise.
     */
    public boolean contains(V o) {
        for(Tupel t : l){
            if(t.v == o){return true;}
        }
        return false;
    }

    /**
     * Returns true if this list contains no elements.
     *
     * @return true if this list contains no elements.
     */
    public boolean isEmpty() {
        return l.isEmpty();
    }

    /**
     * Returns the number of elements in this list.
     *
     * @return the number of elements in this list
     */
    public int size() {
        return l.size();
    }
//
//    @Override
//    public void ensureCapacity(int minCapacity) {
//        super.ensureCapacity(minCapacity);
//    }
//
//    @Override
//    public void trimToSize() {
//        super.trimToSize();
//    }
}

Nachtrag: Hier noch ein JUnittest. Sorry für den Boilerplatecode, ich habs gestern abend recht lieblos dahingeschissen.

Java:
import static components.library.tableset.SortedHashmapListTest.Order.FIRST;
import static components.library.tableset.SortedHashmapListTest.Order.SECCOND;
import org.junit.Test;
import static org.junit.Assert.*;

public class SortedHashmapListTest {
    
    public SortedHashmapListTest() {
    }
    
    enum Order{
        FIRST,
        SECCOND
    }
    
    class ComparableItem implements Comparable<ComparableItem>{
        public final Order order;

        public ComparableItem(Order order) {
            this.order = order;
        }
        
        @Override
        public int compareTo(ComparableItem o) {
            if(order == FIRST && o.order == Order.SECCOND){return -1;}
            if(order == Order.SECCOND && o.order == Order.FIRST){return 1;}
            return 0;
        }
    }

    /**
     * Test of sort method, of class SortedHashmapList.
     */
    @Test
    public void testSort() {
        SortedHashmapList<String, ComparableItem> instance;
        String s1, s2, s3;
        ComparableItem i1, i2, i3, result, expResult;
        
        System.out.println("sort");
        
        instance = new SortedHashmapList<>();
        s1 = "1";
        s2 = "2";
        s3 = "3";
        
        i1 = new ComparableItem(SECCOND);
        i2 = new ComparableItem(SECCOND);
        i3 = new ComparableItem(FIRST);
        
        instance.add(s1, i1);
        instance.add(s2, i2);
        instance.add(s3, i3);
        
        instance.sort();
        
        expResult = i3;
        result = instance.getValue(0);
        assertSame(expResult, result);
    }

    /**
     * Test of remove method, of class SortedHashmapList.
     */
    @Test
    public void testRemove_GenericType() {
        SortedHashmapList<String, ComparableItem> instance;
        String s1, s2, s3;
        ComparableItem i1, i2, i3, result, expResult;
        
        System.out.println("remove");
        
        instance = new SortedHashmapList<>();
        s1 = "1";
        s2 = "2";
        s3 = "3";
        
        i1 = new ComparableItem(SECCOND);
        i2 = new ComparableItem(SECCOND);
        i3 = new ComparableItem(FIRST);
        
        instance.add(s1, i1);
        instance.add(s2, i2);
        instance.add(s3, i3);
        
        expResult = i2;
        result = instance.remove(s2);
        assertSame(expResult, result);
    }

    /**
     * Test of remove method, of class SortedHashmapList.
     */
    @Test
    public void testRemove_int() {
        SortedHashmapList<String, ComparableItem> instance;
        String s1, s2, s3;
        ComparableItem i1, i2, i3, result, expResult;
        
        System.out.println("remove");
        
        instance = new SortedHashmapList<>();
        s1 = "1";
        s2 = "2";
        s3 = "3";
        
        i1 = new ComparableItem(SECCOND);
        i2 = new ComparableItem(SECCOND);
        i3 = new ComparableItem(FIRST);
        
        instance.add(s1, i1);
        instance.add(s2, i2);
        instance.add(s3, i3);
        
        expResult = i2;
        result = instance.remove(1);
        assertSame(expResult, result);
    }

    /**
     * Test of add method, of class SortedHashmapList.
     */
    @Test
    public void testAdd() {
        SortedHashmapList<String, ComparableItem> instance;
        String s1, s2, s3;
        ComparableItem i1, i2, i3;
        
        System.out.println("add");
        
        instance = new SortedHashmapList<>();
        s1 = "1";
        s2 = "2";
        s3 = "3";
        
        i1 = new ComparableItem(SECCOND);
        i2 = new ComparableItem(SECCOND);
        i3 = new ComparableItem(FIRST);
        
        assertTrue(instance.add(s1, i1));
        assertTrue(instance.add(s2, i2));
        assertTrue(instance.add(s3, i3));
        assertFalse(instance.add(s2, i2));
    }

    /**
     * Test of getValue method, of class SortedHashmapList.
     */
    @Test
    public void testGetValue() {
        SortedHashmapList<String, ComparableItem> instance;
        String s1, s2, s3;
        ComparableItem i1, i2, i3, result, expResult;
        
        System.out.println("getValue");
        
        instance = new SortedHashmapList<>();
        s1 = "1";
        s2 = "2";
        s3 = "3";
        
        i1 = new ComparableItem(SECCOND);
        i2 = new ComparableItem(SECCOND);
        i3 = new ComparableItem(FIRST);
        
        instance.add(s1, i1);
        instance.add(s2, i2);
        instance.add(s3, i3);
        
        expResult = i2;
        result = instance.getValue(1);
        assertSame(expResult, result);
    }

//    /**
//     * Test of toArray method, of class SortedHashmapList.
//     */
//    @Test
//    public void testToArray() {
//        SortedHashmapList<String, ComparableItem> instance;
//        String s1, s2, s3;
//        ComparableItem i1, i2, i3;
//        ComparableItem result[], expResult[];
//       
//        System.out.println("toArray");
//       
//        instance = new SortedHashmapList<>();
//        s1 = "1";
//        s2 = "2";
//        s3 = "3";
//       
//        i1 = new ComparableItem(SECCOND);
//        i2 = new ComparableItem(SECCOND);
//        i3 = new ComparableItem(FIRST);
//       
//        instance.add(s1, i1);
//        instance.add(s2, i2);
//        instance.add(s3, i3);
//       
//        expResult = new ComparableItem[]{i3, i1, i2};
//        result = instance.toArray();
//        assertArrayEquals(expResult, result);
//    }

    /**
     * Test of lastIndexOf method, of class SortedHashmapList.
     */
    @Test
    public void testLastIndexOf() {
        SortedHashmapList<String, ComparableItem> instance;
        String s1, s2, s3, s4, s5;
        ComparableItem i1, i2, i3;
        int result, expResult;
        
        System.out.println("lastIndexOf");
        
        instance = new SortedHashmapList<>();
        s1 = "1";
        s2 = "2";
        s3 = "3";
        s4 = "4";
        s5 = "5";
        
        i1 = new ComparableItem(SECCOND);
        i2 = new ComparableItem(SECCOND);
        i3 = new ComparableItem(FIRST);
        
        instance.add(s1, i1);
        instance.add(s2, i2);
        instance.add(s3, i3);
        instance.add(s4, i2);
        instance.add(s5, i3);
        
        expResult = 3;
        result = instance.lastIndexOf(i2);
        assertEquals(expResult, result);
    }

    /**
     * Test of indexOf method, of class SortedHashmapList.
     */
    @Test
    public void testIndexOf() {
        SortedHashmapList<String, ComparableItem> instance;
        String s1, s2, s3, s4, s5;
        ComparableItem i1, i2, i3;
        int result, expResult;
        
        System.out.println("indexOf");
        
        instance = new SortedHashmapList<>();
        s1 = "1";
        s2 = "2";
        s3 = "3";
        s4 = "4";
        s5 = "5";
        
        i1 = new ComparableItem(SECCOND);
        i2 = new ComparableItem(SECCOND);
        i3 = new ComparableItem(FIRST);
        
        instance.add(s1, i1);
        instance.add(s2, i2);
        instance.add(s3, i3);
        instance.add(s4, i2);
        instance.add(s5, i3);
        
        expResult = 1;
        result = instance.indexOf(i2);
        assertEquals(expResult, result);
    }

    /**
     * Test of contains method, of class SortedHashmapList.
     */
    @Test
    public void testContains() {
        SortedHashmapList<String, ComparableItem> instance;
        String s1, s2;
        ComparableItem i1, i2, i3;
        
        System.out.println("contains");
        
        instance = new SortedHashmapList<>();
        s1 = "1";
        s2 = "2";
        
        i1 = new ComparableItem(SECCOND);
        i2 = new ComparableItem(SECCOND);
        i3 = new ComparableItem(FIRST);
        
        instance.add(s1, i1);
        instance.add(s2, i2);
        
        assertTrue(instance.contains(i2));
        assertFalse(instance.contains(i3));
    }

    /**
     * Test of isEmpty method, of class SortedHashmapList.
     */
    @Test
    public void testIsEmpty() {
        SortedHashmapList<String, ComparableItem> instance;
        String s1;
        ComparableItem i1;
        
        System.out.println("isEmpty");
        
        instance = new SortedHashmapList<>();
        s1 = "1";
        
        i1 = new ComparableItem(SECCOND);
        
        assertTrue(instance.isEmpty());
        instance.add(s1, i1);
        assertFalse(instance.isEmpty());
    }

    /**
     * Test of size method, of class SortedHashmapList.
     */
    @Test
    public void testSize() {
        SortedHashmapList<String, ComparableItem> instance;
        String s1, s2, s3;
        ComparableItem i1, i2, i3;
        int result, expResult;
        
        System.out.println("size");
        
        instance = new SortedHashmapList<>();
        s1 = "1";
        s2 = "2";
        s3 = "3";
        
        i1 = new ComparableItem(SECCOND);
        i2 = new ComparableItem(SECCOND);
        i3 = new ComparableItem(FIRST);
        
        instance.add(s1, i1);
        instance.add(s2, i2);
        instance.add(s3, i3);
        
        expResult = 3;
        result = instance.size();
        assertEquals(expResult, result);
    }
}
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben