Objekt-Arrays

public class Person {
    private String name;
    private LocalDate gebDatum = null;
    private int ranking;
    private String info;

    // ...

    @Override                                                        (1)
    public boolean equals(Object obj) {                              (2)
        if (obj == this) return true;  // identity!                  (3)
        if (obj == null || !(obj instanceof Person)) return false;   (4)
        Person other = (Person) obj;                                 (5)
        if (this.name.equals(other.name)
                && this.gebDatum.equals(other.gebDatum)              (6)
                && this.ranking == other.ranking) {                  (7)
            return true;                                             (8)
        }
        return false;                                                (9)
    }
}

import java.time.LocalDate;

/**
 * Einfache Person-Klasse mit equals, compareTo, LocalDate, etc..
 *
 * @author renkin@spengergasse.at
 * @version 2022-06-06
 */
public class Person
{
    private String name;
    private LocalDate gebDatum = null;
    private int ranking;
    private String info;

    public Person(String name, LocalDate gebDatum) {
        this.setName(name);
        setGebDatum(gebDatum);
    }

    public Person(String name, int jahr, int monat, int tag) {
        setName(name);
        LocalDate gebDatum = LocalDate.of(jahr, monat, tag);
        //or: gebDatum = LocalDate.parse("2002-12-31");  //11.12.2002
        // for calc of age: LocalDate now = LocalDate.now();
        // int alter = now.getYear() - gebDatum.getYear();
        setGebDatum(gebDatum);
    }

    public void setName(String name) {
        this.name = name;
    }

    // Aufruf z.B. mit: ...setGebDatum(new LocalDate.of(2002, 12, 31))
    public void setGebDatum(LocalDate gebDatum) {
        if (gebDatum.isAfter(LocalDate.now())) {
            System.out.format("liegt in Zukunft!");
        } else {
            this.gebDatum = gebDatum;
        }
    }

    public void setInfo(String info) {
        this.info = info;
    }

    public String getName() {
        return this.name;
    }

    public LocalDate getGebDatum() {
        return this.gebDatum;
    }

    public String getInfo() {
        return this.info;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) return true;  // identity!
        if (obj == null || !(obj instanceof Person)) return false;
        Person other = (Person) obj;
        // usually makes sense to have consistent equals, compareTo, so we could use:
        // return this.compareTo(other) == 0;
        // or separate implementation:
        if (this.name.equals(other.name)
                && this.gebDatum.equals(other.gebDatum)
                && this.ranking == other.ranking) {
                    return true;
                }
        return false;
    }

    public int compareTo(Person other) {
        int cmp = this.getName().compareTo(other.getName());
        if (cmp == 0) {
            cmp = this.getGebDatum().compareTo(other.getGebDatum());
        }
        if (cmp == 0) {
            cmp = this.ranking - other.ranking;
        }
        return cmp;
    }

    @Override
    public String toString() {
        String infoTxt = "---";
        if (info != null) {
            infoTxt = "'" + info + "'";
        }
        return "Person name=" + name + ", gebDatum=" + gebDatum + ", ranking=" + ranking
        + ", info: " + infoTxt;
    }

    public void printInfo() {
        System.out.println(this);
        //System.out.println(this.toString());
    }

    public static void testCompareTo() {
        Person ada = new Person("Ada", 1987, 06, 05);
        Person evi = new Person("Evi", LocalDate.parse("1999-12-24"));
        Person udo = new Person("Udo", LocalDate.of(2002, 12, 31));
        System.out.format("ada: %s%n", ada);
        System.out.format("evi: %s%n", evi);
        System.out.format("udo: %s%n", udo);
        System.out.format("ada.compareTo(evi)=%s%n", ada.compareTo(evi));
        System.out.format("evi.compareTo(ada)=%s%n", evi.compareTo(ada));
        System.out.format("evi.compareTo(evi)=%s%n", evi.compareTo(evi));
        System.out.format("evi.compareTo(udo)=%s%n", evi.compareTo(udo));
    }
}

import java.time.LocalDate;
import java.util.Random;

/**
 * Array als lückenlos gefüllter Werte-Container, dazu Sortieren,
 * wieder "durcheinanderbringen (unsort)", etc..
 *
 * @author renkin@spengergasse.at
 * @version 2022-06-06
 */
public class PersonenContainer
{
    private Person[] personen = { new Person("Evi", 2001, 11, 30), null };
    private int freeIdx = 1;

    public PersonenContainer() {
        Person p1 = new Person("Evi", 2002, 12, 31);
        personen = new Person[]{   //personen = new Person[8];
            p1,
            new Person("Nina", 2000, 11, 11),
            new Person("Evi", 1985, 02, 12),
            new Person("Udo", 1999, 01, 01),
            new Person("Ede", LocalDate.of(1987, 06, 05)),
            new Person("BabyTom", LocalDate.now()),
            null, null, null};
        freeIdx = 6;
    }

    public PersonenContainer(int kapazitaet) {
        personen = new Person[kapazitaet];
        freeIdx = 0;
    }

    public PersonenContainer(Person[] personen, int freeIdx) {
        this.personen = personen;
        this.freeIdx = freeIdx;
    }

    public boolean isFull() {
        return freeIdx == personen.length;
    }

    public boolean isEmpty() {
        return freeIdx == 0;
    }

    public int usedSize() {
        return freeIdx;
    }

    public int freeSpace() {
        return personen.length - usedSize();
    }

    public boolean add(Person person) {
        if (person == null) {
            System.out.format("person to add is null");
            return false;
        }
        if (isFull()) {
            System.out.format("Container full (capacity=%d)", personen.length);
            return false;
        }
        personen[freeIdx] = person;
        freeIdx++;
        return true;
    }

    public boolean contains(Person person) {
        for (int i = 0; i < freeIdx; i++) {
            if (personen[i].equals(person)) {   // use of equals !!!
                return true;
            }
        }
        return false;
    }

    public int indexOf(Person person) {
        for (int i = 0; i < freeIdx; i++) {
            if (personen[i].equals(person)) {   // use of equals !!!
                return i;
            }
        }
        return -1;
    }

    public boolean addUnique(Person person) {
        if (contains(person)) {
            System.out.format("already in container: %s", person);
            return false;
        }
        return add(person);
    }

    public boolean remove(int idx) {
        if (idx < 0 || idx >= freeIdx) {
            System.out.format("ERR remove: idx=%d not in 0..%d-1 (%<d items)", idx, freeIdx);
            return false;
        }
        freeIdx--;
        for (int i = idx; i < freeIdx; i++) {
            personen[i] = personen[i+1];
        }
        return true;
    }

    public boolean remove(Person person) {
        int idx = indexOf(person);  // use indexOf(..) from above
        if (idx < 0) {
            System.out.format("remove Person: not in container: %s", person);
            return false;
        }
        return remove(idx);         // use remove(..) from above
    }

    public void exchange(int i, int k) {
        if (i != k) {
            Person tmp = personen[i];
            personen[i] = personen[k];
            personen[k] = tmp;
        }
    }

    public void unsort() {
        Random randGen = new Random();
        for (int i = 0; i < freeIdx; i++) {
            exchange(i, randGen.nextInt(freeIdx));
        }
    }

    public void reverse() {
        for (int i = 0; i < freeIdx/2; i++) {
            exchange(i, freeIdx - i - 1);
        }
    }

    public void bubbleSort() {
        boolean more = true;
        while (more) {
            more = oneBubble();
        }
    }

    public boolean oneBubble() {
        boolean changed = false;
        for (int i = 1; i < freeIdx; i++) {
            if (personen[i-1].compareTo(personen[i]) > 0) {
                exchange(i-1, i);
                changed = true;
            }
        }
        return changed;
    }

    public void selectionSort() {
        for (int i = 0; i < freeIdx; i++) {
            exchange(i, findMinValIdx(i, freeIdx));
        }
    }

    public int findMinValIdx(int startIdx, int endIdxExcl) {
        if (startIdx < 0 || startIdx >= endIdxExcl) {
            return -1;  // will cause ArrayIndexOutOfBoundsException above if occuring
        }
        int currMinValIdx = startIdx;
        for (int i = startIdx+1; i < endIdxExcl; i++) {
            if (personen[i].compareTo(personen[currMinValIdx]) < 0) { // <0 .. 1st person "smaller"
                currMinValIdx = i;
            }
        }
        return currMinValIdx;
    }

    public void printList(String title) {
        System.out.format("==== %s ====%n", title);
        for (int i = 0; i < freeIdx; i++) {
            System.out.format("idx=%2d: %s%n", i, personen[i]);
        }
    }

}