Objektorientierte Programmierung OOP

Die Elemente sollten nicht mit ==, sonder mit Hilfe der Methode equals() verglichen werden.

    boolean istEnthalten(String wert, String[] feld) {        if (feld == null) {            return false;        }        for (String s : feld) {            // Wert gefunden?            if (s.equals(wert)) {                return true;            }        }        return false;    }

    int bestimmeAnzahl(int wert, int[] feld) {        if (feld == null) {            return 0;        }        int anzahl = 0;        for (int i : feld) {            // Wert gefunden?            if (i == wert) {                anzahl++;            }        }        return anzahl;    }

    int bestimmeGesamtbetragAllerRechnungenVon(Kunde k) {        // wenn kein Kunde oder keine Rechnungen vorhanden        if (k == null || rechnungen == null) {            return 0;        }        int betrag = 0;        // alle Rechnungen betrachten        for (Rechnung r : rechnungen) {            // wenn gesuchter Kunde            if (r.liefereRechnungsempfaenger() == k) {                // Betrag dazuaddieren                betrag += r.bestimmeBetragInCent();            }        }        return betrag;    }

Rechnung findeTeuersteRechnung() {   // wenn keine Rechnungen vorhanden    if (rechnungen == null) {        return null;    }    Rechnung max = null;    // alle Rechnungen betrachten    for (Rechnung r : rechnungen) {        // wenn noch kein Maximum gefunden        // oder aktuelle Rechnung teurer        if (max == null || max.bestimmeBetragInCent()                            < r.bestimmeBetragInCent()) {            // Maximum anpassen            max = r;        }    }    return max;}

Man beginnt damit, den ersten Wert des Feldes mit dem ersten Wert der Zahlenfolge zu vergleichen. Stimmen die Werte überein, vergleicht man anschließend die zweiten Werte und so weiter. Stimmen die Werte nicht überein, so weiß man lediglich, dass die Zahlenfolge nicht beim ersten Element des Feldes beginnend gefunden werden kann. Man beginnt dann mit dem zweiten Element des Feldes und vergleicht es mit dem ersten der gesuchten Folge. Stimmen diese überein, so vergleicht man anschließend das dritte mit dem zweiten und so weiter. Wurde die gesamte Teilfolge gefunden, so kann die Methode beendet werden. Bei der Implementierung müssen wir aufpassen, dass wir nicht auf ungültige Feldelemente zugreifen.

boolean istTeilfolge(int[] feld, int[] gesuchteFolge) {        // es muss nicht bis zum letzten Element gesucht werden,        // da dort die Folge nicht mehr vollständig vorkommen kann        for (int i = 0; i < feld.length                             - gesuchteFolge.length + 1; i++) {            for (int j = 0; j < gesuchteFolge.length; j++) {                // Vergleiche entsprechende Einträge                if (feld[i + j] != gesuchteFolge[j]) {                    // Zahl an Position j stimmt nicht überein                    // suche bei i+1 weiter                    break;                } else if (j == gesuchteFolge.length - 1) {                    // gesamte Folge wurde gefunden                    return true;                }            }        }        // Teilfolge konnte nicht vollständig gefunden werden        return false;    }

    int bestimmeAnfangdesWorts(char[] feld, String wort) {        for (int i = 0; i < feld.length - wort.length() + 1; i++) {            for (int j = 0; j < wort.length(); j++) {                // Vergleiche entsprechende Buchstaben                if (feld[i + j] != wort.charAt(j)) {                    // Buchstabe an Position j stimmt nicht überein                    // suche bei i+1 weiter                    break;                } else if (j == wort.length() - 1) {                    // gesamtes Wort wurde gefunden                    return i;                }            }        }        // Wort konnte nicht vollständig gefunden werden        return -1;    }

Wenn die Datenelemente gemäß einer Ordnungsrelation sortiert werden. Der Suchalgorithmus kann diese Eigenschaft nutzen, um ein bestimmtes Element in der sortierten Menge zu finden.