Android ArrayList sortieren mit 2 Werten ohne thencomparing , Wie?

[tollewurst]

Hallo,

da ich sehr stark abwärts kompatibel bleiben will mit der Api, hätte ich mal eine Frage, wie man eine ArrayList mit 2 Werten sortiert.
Also er soll erst nach id sortieren und dann nach Namen. z.b.

0 A
1 Aa
2 Ab
3 B
4 Ba
...

Wie ich nach ID sortiere weiß und nach Name auch, aber wie geht das gleichzeitig.

static class UebungenSort {
int mid;
String mname;

UebungenSort(int id, String name) {
mid = id;
mname = name;
}

String getName() {
return mname;
}

int getID() {
return mid;
}

public static Comparator<UebungenSort> UebungComparator = new Comparator<UebungenSort>() {
public int compare(UebungenSort s1, UebungenSort s2) {
String Uebungname1 = s1.getName().toUpperCase();
String Uebungname2 = s2.getName().toUpperCase();

//ascending order
return Uebungname1.compareTo(Uebungname2);

//descending order
//return StudentName2.compareTo(StudentName1);
}
};

public static Comparator<UebungenSort> IDComperator = new Comparator<UebungenSort>() {
public int compare(UebungenSort s1, UebungenSort s2) {
int id1 = s1.getID();
int id2 = s2.getID();

/*For ascending order*/
return id1 - id2;

/*For descending order*/
//rollno2-rollno1;
}
};
}

....

Collections.sort(uebungsort, UebungenSort.UebungComparator);
Collections.sort(uebungsort, UebungenSort.IDComperator );

 

[krgewb]

Bitte immer in Code-Tags posten.

static class UebungenSort {
    int mid;
    String mname;

    UebungenSort(int id, String name) {
        mid = id; 
        mname = name;
    }

    String getName() {
        return mname;
    }

    int getID() {
        return mid;
    }

    public static Comparator<UebungenSort> UebungComparator = new Comparator<UebungenSort>() {
        public int compare(UebungenSort s1, UebungenSort s2) {
            String Uebungname1 = s1.getName().toUpperCase();
            String Uebungname2 = s2.getName().toUpperCase();

            //ascending order
            return Uebungname1.compareTo(Uebungname2);

            //descending order
            //return StudentName2.compareTo(StudentName1);
        }
    };

    public static Comparator<UebungenSort> IDComperator = new Comparator<UebungenSort>() {
        public int compare(UebungenSort s1, UebungenSort s2) {
            int id1 = s1.getID();
            int id2 = s2.getID();

            /*For ascending order*/
            return id1 - id2;

            /*For descending order*/
            //rollno2-rollno1;
        }
    };
}

....

Collections.sort(uebungsort, UebungenSort.UebungComparator);
Collections.sort(uebungsort, UebungenSort.IDComperator );

 

[httpdigest]

Wenn du nach mehreren Kriterien sortieren willst, musst du dir erstmal vor Augen führen, was genau das denn heisst. Wenn du nach Kriterium C1 und C2 (in dieser Reihenfolge) sortieren willst, dann heisst das nichts anderes als dass Kriterium C2 nur dann herangezogen wird, wenn für C1 "unentschieden" bzw. "sind gleich" herauskommt. Z.B.: {id=0, name="a"} und {id=0, name="b"} sind für den ID-Vergleich ja "gleich", da beide id=0 besitzen. Somit entscheidet das nächste Kriterium über den Vergleich.
Mit diesem Wissen kannst du dann auch ganz einfach eine eigene "comparingBy"-Methode implementieren, die beliebig viele Comparatoren entgegennehmen kann und danach sortiert:

public static <T> Comparator<T> comparingBy(Comparator<T>... comparators) {
  return new Comparator<T>() {
    public int compare(T o1, T o2) {
      for (int i = 0, r = 0; i < comparators.length; i++)
        if ((r = comparators[i].compare(o1, o2)) != 0)
          return r;
      return 0;
    }
  };
}

 

[tollewurst]

na eigentlich will ich sowas
Comparator<Employee> compareByName = Comparator
.comparing(Employee::getFirstName)
.thenComparing(Employee::getLastName);

ohne Java 8 bzw. in Android API 24+ gelöst haben.

 

[httpdigest]

Na, und genau das hab ich dir geschrieben. Du kannst (offensichtlich) ja nicht die eingebaute Comparator-Klasse selbst anpassen (also comparing() oder thenComparing() hinzufügen).

Vielleicht nochmal die Benutzung zur Verdeutlichung:

// Die neue Methode von oben
public static <T> Comparator<T> comparingBy(final Comparator<T>... comparators) {
  return new Comparator<T>() {
    public int compare(T o1, T o2) {
      for (int i = 0, r = 0; i < comparators.length; i++)
        if ((r = comparators[i].compare(o1, o2)) != 0)
          return r;
      return 0;
    }
  };
}
// nur byId
private static final Comparator<UebungenSort> byId = new Comparator<UebungenSort>() {
  public int compare(UebungenSort o1, UebungenSort o2) {
    return Integer.compare(o1.id, o2.id);
  }
};
// nur byName
private static final Comparator<UebungenSort> byName = new Comparator<UebungenSort>() {
  public int compare(UebungenSort o1, UebungenSort o2) {
    return o1.name.compareToIgnoreCase(o2.name);
  }
};
// by Id und dann by Name
private static final Comparator<UebungenSort> byIdAndByName = comparingBy(byId, byName);

 

[tollewurst]

Okay danke, muss ich morgen mal ausprobieren, aber ich habe das Gefühl ich muss noch mal was umstellen, da ich irgendwo einen Denkfehler habe.
Weil eigentlich ist es so. z.b.
0-50 bilden eine Gruppe, die sollen nach Name sortiert werden
50-100 nächste Gruppe nach Name sortieren
usw.
Also
0 A
1 Aa
50 A
51 Aa
usw. soll raus kommen

 

[httpdigest]

Das ist ja jetzt nun etwas völlig anderes. Das wäre auch nicht das gewesen, was du mit dem Java 8 Comparator.thenComparing() erreicht hättest...
Vielleicht überlegst du erstmal, was genau du willst.

 

[MoxxiManagarm]

0-50 bilden eine Gruppe, die sollen nach Name sortiert werden
50-100 nächste Gruppe nach Name sortieren

Heißt das, das wäre auch eine korrekte Sortierung?

1 A
0 B
50 A
51 B

Falls ja, sei hier das Beispiel von @httpdigest erweitert:

// Die neue Methode von oben
public static <T> Comparator<T> comparingBy(final Comparator<T>... comparators) {
  return new Comparator<T>() {
    public int compare(T o1, T o2) {
      for (int i = 0, r = 0; i < comparators.length; i++)
        if ((r = comparators[i].compare(o1, o2)) != 0)
          return r;
      return 0;
    }
  };
}
// nur byId
private static final Comparator<UebungenSort> byId = new Comparator<UebungenSort>() {
  public int compare(UebungenSort o1, UebungenSort o2) {
    return Integer.compare(o1.id, o2.id);
  }
};
// nur byIdGroup
private static final Comparator<UebungenSort> byIdGroup = new Comparator<UebungenSort>() {
  public int compare(UebungenSort o1, UebungenSort o2) {
    return Integer.compare(o1.id % 50, o2.id % 50);
  }
};
// nur byName
private static final Comparator<UebungenSort> byName = new Comparator<UebungenSort>() {
  public int compare(UebungenSort o1, UebungenSort o2) {
    return o1.name.compareToIgnoreCase(o2.name);
  }
};
// by IdGroup und dann by Name
private static final Comparator<UebungenSort> byIdGroupAndByName = comparingBy(byIdGroup, byName);

 

[tollewurst]

Hallo, dass es sowas

public static <T> Comparator<T> comparingBy(final Comparator<T>... comparators) {

gibt wusste ich bisher nicht. Musste aber in meine class noch eine fakevariable einbauen und dann die ids/50, dann geht es und es kommt sowas raus
0 A
0 Aa
0 Ab
0 B
...
1 A
1 Aa
1 Ab
1 B
...

kann ich nur sagen, danke und wieder was dazu gelernt

 

[tollewurst]

Da fällt mir gerade ein, da ich das mit dem " ... " noch nie gesehen habe, wo kann man das nachlesen ?
Hat mal einer einen link ?

 

[LimDul]

Stichwort: Varargs

Beispiel: https://www.baeldung.com/java-varargs