Sortowanie pól w obiektach będących w liście.

Cześć

Staram się zrobić uniwersalną metodę, która będzie określać czy posortowane są pola w obiektach będących w liście.
Mam obiekt A mający kilka pól a,b,c... obiekt B mający jakieś inne pola f,g,h,i itp.
Obiekty A i B są to wiersze z tabel gdzie pola a, b, c to po prostu wartości kolumn. Obiekt A to wiersz z tabeli załóżmy lekarz a B pacjent itp.

Cała tabel to List tych obiektów.

Teraz sortuję w GUI tą tabelę po załóżmy pierwszej kolumnie i poprzez selenium mam obiekt : lista obiektów A
No i staram siię teraz określić czy w liście, w obiektach A , pola a są posortowane.
Pola mogą być stringiem lub Integer lub ewentualnie LocalDate ale przy tym ostatnim chyba nie zadziała moja metoda bo nie implementuje Comperable.

Na chwilę obecną mam taki prototyp:
Każda listę obiektów castuję:

 List<A> r = getSearchResults();
 List<Object> objectList = (List)r;   

i wsadzam:

metoda by była taka:

private boolean isColumnSorted(List<Object> gridResult, int column, boolean reverse) {
        List<Object> columnValues = new ArrayList<>();
        for (Object x : gridResult) {
            Class<?> clazz = x.getClass();
            Field[] fields = clazz.getFields();
            Object field = fields[column];
            columnValues.add(field);
        }

        List tmp = new ArrayList(columnValues);
        Collections.sort(tmp);
        boolean sorted = tmp.equals(columnValues);
        return sorted;
    }

Jest lepszy sposób - bardziej uniwersalny - pozdrawiam

o_O to są jaja jakieś?

    public <T, V extends Comparable<V>> boolean isColumnSorted(List<T> gridResult, Function<T, V> extractor) {
        List<T> sortedList = new ArrayList<>(gridResult);
        sortedList.sort(Comparator.comparing(extractor));
        return sortedList.equals(gridResult);
    }

Przykładowo:

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;

class A {
    private final int x;
    private final String y;

    A(int x, String y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public String getY() {
        return y;
    }
}

public class Sortowanie {

    private <T, V extends Comparable<V>> boolean isColumnSorted(List<T> gridResult, Function<T, V> extractor) {
        List<T> sortedList = new ArrayList<>(gridResult);
        sortedList.sort(Comparator.comparing(extractor));
        return sortedList.equals(gridResult);
    }

    public static void main(String[] args) {
        Sortowanie sortowanie = new Sortowanie();
        List<A> lista = new ArrayList<>();
        lista.add(new A(10, "aaa"));
        lista.add(new A(1, "bbb"));
        System.out.println(sortowanie.isColumnSorted(lista, A::getX));
        System.out.println(sortowanie.isColumnSorted(lista, A::getY));
    }
}

// edit: pomysł z sortowaniem wziąłem od ciebie, ale generalnie można by liniowo sprawdzić czy kolejność elementów jest dobra ;)

@OP Musisz sam sortować? Nie możesz przeiterować po elementach listy i sprawdzić czy dla każdej pary elementów spełniony jest warunek z Comparable?

A w takim razie jak w tej metodzie zrobić by sortował malejąco? Z góry dziękuję.

A w twoim kodzie jak? Bo też tego nie miałeś... Anyway Comparator.comparing(extractor).reversed()