Если вы хотите использовать if, else, следующие следующие решения:
myList = []
aList = [0,1,3]
for l in aList:
if l==0:myList.append('c')
elif l==1:myList.append('d')
elif l==2:myList.append('e')
elif l==3:myList.append('f')
print(myList)
Как уже упоминалось, вы можете сортировать по:
Comparable
Comparator
в Collections.sort
Если вы сделаете оба, Comparable
будет проигнорирован, а Comparator
будет использоваться. Это помогает тем, что объекты с ценными объектами имеют свой собственный логический Comparable
, который является наиболее разумным типом для вашего объекта значения, в то время как каждый индивидуальный вариант использования имеет свою собственную реализацию.
public class ActiveAlarm implements Comparable<ActiveAlarm> {
public long timeStarted;
public long timeEnded;
private String name = "";
private String description = "";
private String event;
private boolean live = false;
public int compareTo(ActiveAlarm a) {
if ( this.timeStarted > a.timeStarted )
return 1;
else if ( this.timeStarted < a.timeStarted )
return -1;
else {
if ( this.timeEnded > a.timeEnded )
return 1;
else
return -1;
}
}
Это должно дать вам приблизительную идею. Как только это будет сделано, вы можете вызвать Collections.sort()
в списке.
Мы можем отсортировать список одним из двух способов:
1. Использование компаратора: когда требуется использовать логику сортировки в нескольких местах. Если вы хотите использовать логику сортировки в одном месте, вы можете написать анонимный внутренний класс следующим образом или извлечь из компаратора и использовать его в нескольких местах
Collections.sort(arrayList, new Comparator<ActiveAlarm>() {
public int compare(ActiveAlarm o1, ActiveAlarm o2) {
//Sorts by 'TimeStarted' property
return o1.getTimeStarted()<o2.getTimeStarted()?-1:o1.getTimeStarted()>o2.getTimeStarted()?1:doSecodaryOrderSort(o1,o2);
}
//If 'TimeStarted' property is equal sorts by 'TimeEnded' property
public int doSecodaryOrderSort(ActiveAlarm o1,ActiveAlarm o2) {
return o1.getTimeEnded()<o2.getTimeEnded()?-1:o1.getTimeEnded()>o2.getTimeEnded()?1:0;
}
});
Мы можем иметь нулевую проверку свойств, если бы мы могли использовать «Long» вместо «long».
2. Использование Comparable (естественный порядок): если алгоритм сортировки всегда придерживается одного свойства: напишите класс, который реализует метод «Comparable» и переопределяет метод «compareTo», как определено ниже
class ActiveAlarm implements Comparable<ActiveAlarm>{
public long timeStarted;
public long timeEnded;
private String name = "";
private String description = "";
private String event;
private boolean live = false;
public ActiveAlarm(long timeStarted,long timeEnded) {
this.timeStarted=timeStarted;
this.timeEnded=timeEnded;
}
public long getTimeStarted() {
return timeStarted;
}
public long getTimeEnded() {
return timeEnded;
}
public int compareTo(ActiveAlarm o) {
return timeStarted<o.getTimeStarted()?-1:timeStarted>o.getTimeStarted()?1:doSecodaryOrderSort(o);
}
public int doSecodaryOrderSort(ActiveAlarm o) {
return timeEnded<o.getTimeEnded()?-1:timeEnded>o.getTimeEnded()?1:0;
}
}
метод сортировки вызовов для сортировки на основе естественного упорядочения
Collections.sort(list);
Guava ComparisonChain :
Collections.sort(list, new Comparator<ActiveAlarm>(){
@Override
public int compare(ActiveAlarm a1, ActiveAlarm a2) {
return ComparisonChain.start()
.compare(a1.timestarted, a2.timestarted)
//...
.compare(a1.timeEnded, a1.timeEnded).result();
}});
В java8 + это можно записать в одну строку следующим образом:
collectionObjec.sort (comparator_lamda) или comparator.comparing (CollectionType :: getterOfProperty)
код:
ListOfActiveAlarmObj.sort((a,b->a.getTimeStarted().compareTo(b.getTimeStarted())))
или
ListOfActiveAlarmObj.sort(Comparator.comparing(ActiveAlarm::getTimeStarted))
Вы можете вызвать Collections.sort () и передать в Comparator, который вам нужно написать, чтобы сравнить различные свойства объекта.
Использование Comparator
Пример:
class Score {
private String name;
private List<Integer> scores;
// +accessor methods
}
Collections.sort(scores, new Comparator<Score>() {
public int compare(Score o1, Score o2) {
// compare two instance of `Score` and return `int` as result.
return o2.getScores().get(0).compareTo(o1.getScores().get(0));
}
});
С Java 8 и далее вы можете просто использовать лямбда выражение для представления экземпляра компаратора.
Collections.sort(scores, (s1, s2) -> { /* compute and return int */ });
Вы можете использовать Collections.sort
и передать свой собственный Comparator<ActiveAlarm>
С Java8 это можно сделать еще более чистым, используя комбинацию Comparator
и Lambda expressions
Пример:
class Student{
private String name;
private List<Score> scores;
// +accessor methods
}
class Score {
private int grade;
// +accessor methods
}
Collections.sort(student.getScores(), Comparator.comparing(Score::getGrade);
В java вам нужно использовать статический метод Collections.sort
. Ниже приведен пример списка объектов CompanyRole, отсортированных сначала, а затем и до конца. Вы можете легко адаптироваться к своему собственному объекту.
private static void order(List<TextComponent> roles) {
Collections.sort(roles, new Comparator() {
public int compare(Object o1, Object o2) {
int x1 = ((CompanyRole) o1).getBegin();
int x2 = ((CompanyRole) o2).getBegin();
if (x1 != x2) {
return x1 - x2;
} else {
int y1 = ((CompanyRole) o1).getEnd();
int y2 = ((CompanyRole) o2).getEnd();
return y2 - y1;
}
}
});
}
Теперь список будет отсортирован:)
Либо сделать ActiveAlarm
реализовать Comparable<ActiveAlarm>
, либо реализовать Comparator<ActiveAlarm>
в отдельном классе. Затем вызовите:
Collections.sort(list);
или
Collections.sort(list, comparator);
В общем, рекомендуется реализовать Comparable<T>
, если есть один «естественный», порядок сортировки ... в противном случае (если вы имеете , чтобы сортировать в определенном порядке, но могли бы также легко хотеть другое), лучше реализовать Comparator<T>
. Эта конкретная ситуация может пойти в любом случае, если честно ... но я бы , вероятно, придерживался более гибкой опции Comparator<T>
.
EDIT: Пример реализации:
public class AlarmByTimesComparer implements Comparator<ActiveAlarm> {
@Override
public int compare(ActiveAlarm x, ActiveAlarm y) {
// TODO: Handle null x or y values
int startComparison = compare(x.timeStarted, y.timeStarted);
return startComparison != 0 ? startComparison
: compare(x.timeEnded, y.timeEnded);
}
// I don't know why this isn't in Long...
private static int compare(long a, long b) {
return a < b ? -1
: a > b ? 1
: 0;
}
}