Bearbeiten von „StringList:Javakurs“

Zur Navigation springen Zur Suche springen

Warnung: Du bist nicht angemeldet. Deine IP-Adresse wird bei Bearbeitungen öffentlich sichtbar. Melde dich an oder erstelle ein Benutzerkonto, damit Bearbeitungen deinem Benutzernamen zugeordnet werden.

Die Bearbeitung kann rückgängig gemacht werden. Bitte prüfe den Vergleich unten, um sicherzustellen, dass du dies tun möchtest, und veröffentliche dann unten deine Änderungen, um die Bearbeitung rückgängig zu machen.

Aktuelle Version Dein Text
Zeile 24: Zeile 24:
     Element succ = null;
     Element succ = null;
}
}
/**
/**
  * Implements a doubled linked list of strings.
  * Implements a doubled linked list of strings.
Zeile 41: Zeile 42:
     private Element last = null;
     private Element last = null;
     private int count = 0;
     private int count = 0;
     /**
     /**
     * Adds a text to the end of the list.
     * Adds a text to the end of the list.
Zeile 47: Zeile 49:
     *            text to append
     *            text to append
     */
     */
     public void add(final String text) {
     void add(final String text) {
         final Element element = new Element();
         final Element element = new Element();
         element.text = text;
         element.text = text;
Zeile 55: Zeile 57:
             element.pred = this.last;
             element.pred = this.last;
             this.last.succ = element;
             this.last.succ = element;
            this.last = element;
         }
         }
         this.count++;
         this.count++;
     }
     }
     /**
     /**
     * Returns the text of the n-th element.
     * Gets the text of the n-th element of the list.
     *
     *
     * @param index
     * @param index
     *            index of the wanted element
     *            index of the wanted element
     * @return null: wrong index<br>
     * @return <code>null</code>: wrong index<br>
     *        otherwise: the text of the element with index <code>index</code>
     *        otherwise: the text of the element with index <code>index</code>
     */
     */
     public String get(final int index) {
     String get(final int index) {
         final Element element = getElement(index);
         Element element = this.first;
         final String rc = element == null ? null : element.text;
        for (int ix = 0; element != null && ix < index - 1; ix++)
        return rc;
            element = element.succ;
         return element == null ? null : element.text;
     }
     }
     /**
     /**
     * @return the count
     * @return the count
Zeile 78: Zeile 82:
         return this.count;
         return this.count;
     }
     }
    /**
 
    * Gets the the n-th element of the list.
    *
    * @param index
    *            index of the wanted element
    * @return <code>null</code>: wrong index<br>
    *        otherwise: the text of the element with index <code>index</code>
    */
    Element getElement(final int index) {
        Element rc = null;
        if (index >= 0 && index < this.count) {
            rc = this.first;
            int ix = 0;
            while (rc != null && ix++ < index)
                rc = rc.succ;
        }
        return rc;
    }
     /**
     /**
     * @return the first
     * @return the first
Zeile 102: Zeile 89:
         return this.first;
         return this.first;
     }
     }
     /**
     /**
     * @return the last
     * @return the last
Zeile 108: Zeile 96:
         return this.last;
         return this.last;
     }
     }
    /**
    * Searches for matching a regular expression
    *
    * @param start
    *            first index to search
    * @param regExpr
    *            the regular expression to search
    * @return -1: not found<br>
    *        otherwise: the lowest index of the element greater or equal
    *        <code>start</code> where the regular expression match
    */
    public int search(final int start, final String regExpr) {
        int rc = -1;
        Element element = getElement(start);
        if (element != null) {
            int index = start;
            final Pattern pattern = Pattern.compile(regExpr);
            do {
                if (pattern.matcher(element.text).find()) {
                    rc = index;
                    break;
                }
                index++;
                element = element.succ;
            } while (element != null);
        }
        return rc;
    }
}</pre>
= Anmerkungen =
Die Klasse Element wird nur innerhalb von StringList verwendet und kommt in keiner der public-Methoden als Ergebnis oder Parameter vor.
Daher kann die Klasse in der gleichen Datei wie StringList verwendet definiert werden.
Der Unterschied ist, dass StringList public ist, während Element nicht public ist.


Die Klassenvariablen von Element sind ohne Zugriffsprädikat. Daher kann von jeder Klasse innerhalb der Datei darauf zugegriffen werden.
Die Klassenvariablen first, last und count dürfen von anderen Klassen nur gelesen, nicht geändert werden.
Daher sind sogenannte Getter-Funktionen zum Lesen der Variablen definiert. Der Name einer Getter-Funktion besteht aus dem Präfix "get" und
dem Namen der Variablen (beginnend mit einem Großbuchstaben, also z.B. getCount().
Eclipse kann Getter- (und Setter-)Funktionen automatisch erstellen: entsprechende Variable(n) auswählen und im Menü "Source - Generate Getters and Setters" aufrufen.
Die Methode add() hängt eine neues Element ans Ende der bestehenden Liste.
Die Methode search() sucht das erste Element, das hinter einem gegebenen Index liegt und mit einem Suchmuster übereinstimmt.
Als Suchmuster werden [[Reguläre Ausdrücke:Javakurs|reguläre Ausdrücke]] verwendet.
= JUnit Tests =
Eine gängige Vorgehensweise beim Programmieren ist das "test driven development":
* Definiere vor der Implementierung Testfälle.
* Die Testfälle sollen alle oder wenigstens alle gängigen Möglichkeiten abdecken.
* Kommen bei Parametern Intervalle vor, so sind die 3 Möglichkeiten "vor der Grenze", "auf der Grenze" und "nach der Grenze" zu testen.
Java bietet unter anderem für solche Tests die "JUnit"s an:
<pre>
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import org.junit.Test;
import de.hamatoma.jkurs.StringList;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
public class StringListTest {
    @Test
    public void testBasics() {
        final StringList list = new StringList();
        assertEquals(0, list.getCount());
        list.add("Hello");
        list.add("my");
        list.add("world");
        assertEquals(3, list.getCount());
        assertEquals("Hello", list.get(0));
        assertEquals("my", list.get(1));
        assertEquals("world", list.get(2));
        assertNull(list.get(-1));
        assertNull(list.get(3));
    }
    @Test
    public void testSearch() {
        final StringList list = new StringList();
        assertEquals(-1, list.search(0, "e"));
        list.add("Hello");
        list.add("my");
        list.add("world");
        assertEquals(0, list.search(0, "He"));
        assertEquals(-1, list.search(1, "He"));
        assertEquals(1, list.search(1, "y"));
        assertEquals(1, list.search(0, "y"));
        assertEquals(-1, list.search(2, "y"));
        assertEquals(2, list.search(0, "ld"));
        assertEquals(2, list.search(1, "ld"));
        assertEquals(2, list.search(2, "ld"));
        assertEquals(-1, list.search(3, "ld"));
    }
}
}
</pre>
</pre>
== Anmerkungen ==
* Es gibt keine Methode main(): Die zu testenden Funktionen werden mit "@Test" gekennzeichnet. Der Aufruf der Testfunktionen erfolgt automatisch mit "Run as JUnit Test" bzw. "Debug as JUnit Test"
* Das Programm verwendet die zu testende Klasse und prüft danach, ob das Gewünschte passiert ist:
** Es werden 3 Strings angehängt
** Danach wird geprüft, ob die Anzahl 3 ist und ob die Werte wieder gelesen werden können.
* Auch werden die Fehlerzustände geprüft: Verwenden von undefinierten Indexwerten (z.B. -1).
= Aufgaben =
* Programmiere eine Methode insert(int index, String text), die ein Element beim angegebenen Index einfügt:
<pre>
A ----- B ------ C
insert(1, "X")
A ----- X ------ B -------- C
</pre>
* Erstelle eine Methode remove(int index), die ein Element an einer bestimmten Position entfernt.
* Optimiere die Methode get(): Wenn es günstiger ist, finde das Element von hinten (vom letzten Element aus).

Bitte kopiere keine Webseiten, die nicht deine eigenen sind, benutze keine urheberrechtlich geschützten Werke ohne Erlaubnis des Urhebers!
Du gibst uns hiermit deine Zusage, dass du den Text selbst verfasst hast, dass der Text Allgemeingut (public domain) ist, oder dass der Urheber seine Zustimmung gegeben hat. Falls dieser Text bereits woanders veröffentlicht wurde, weise bitte auf der Diskussionsseite darauf hin. Bitte beachte, dass alle Info-Theke-Beiträge automatisch unter der „Gemeinfreiheit“ stehen (siehe Info-Theke:Urheberrechte für Einzelheiten). Falls du nicht möchtest, dass deine Arbeit hier von anderen verändert und verbreitet wird, dann klicke nicht auf „Seite speichern“.

Abbrechen Bearbeitungshilfe (wird in einem neuen Fenster geöffnet)
Abgerufen von „https://wiki.hamatoma.de/index.php?title=StringList:Javakurs“