그러나 내가 사용하는 사람들이 이용하는 모든 정렬 라일리츠 검토완료 비교자 참조용이므로 콩파레토 있는 일부 연구 '에 따르면' 는 써줬지 방법
내가 원하는 건 중 하나로 충족되었으며 라일리스트 정렬하려면 맞춤형 객체에는 그들의 속성: 날짜 객체에는 ('제스타르데 ()'). 보통 나는 ' () 로 그들을 비교하십시오 item1.getStartDate 스베포리 (item2.getStartDate ())' 저 그래서 내가 표시할지를 다음과 같은 항목을 기록할 수 있습니다
public class CustomComparator {
public boolean compare(Object object1, Object object2) {
return object1.getStartDate().before(object2.getStartDate());
}
}
public class RandomName {
...
Collections.sort(Database.arrayList, new CustomComparator);
...
}
이후 '날짜' 는 '비교' ',' 에서 '처럼' 문자열 콩파레토 방법을 가지고 있다.
그래서 사용자 정의 '비교자' 이렇게 보일 수 있다.
public class CustomComparator implements Comparator<MyObject> {
@Override
public int compare(MyObject o1, MyObject o2) {
return o1.getStartDate().compareTo(o2.getStartDate());
}
}
이 방법을 '비교' 한 'int', 그러니까 couldn& 반품해야 합니다 (), 'a' t # 39 복귀하십시오 부울을 직접 조교하실 계획 같은 겁니다.
너 같은 단순한 너회의 분류 코드 약간만이라도 다음과 같이 썼다.
Collections.sort(Database.arrayList, new CustomComparator());
이 모든 방법을 쓸 경우, 약간 짧은 don& # 39 는 인라인 익명 클래스를 너회의 비교자 재사용합니다 표시됨과 쓸 필요가 없다.
Collections.sort(Database.arrayList, new Comparator<MyObject>() {
@Override
public int compare(MyObject o1, MyObject o2) {
return o1.getStartDate().compareTo(o2.getStartDate());
}
});
이제 마지막 예에서는 기록하십시오 짧은 양식을 람다 표현식 를 사용하여 '비교자':
Collections.sort(Database.arrayList,
(o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));
목록 '와' 는 ['정렬 (비교자)'] [5] 이 방법, 그래서 더욱 줄일 수 있습니다.
Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));
이것은 흔히 볼 수 있는 등 관용구 there& # 39 의 [내장현 방법] [6] '와' '비교자 생성하려면 클래스에 대한 비슷한' 키:
Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));
이러한 문제는 모두 avamer 말한다.
[5]: # sort-java.util.Comparator //docs.oracle.com/javase/8/docs/api/java/util/list.html - [6]: # comparing-java.util.function.Function //docs.oracle.com/javase/8/docs/api/java/util/comparator.html -
클래스 (class Number, 예를 들어) 할 수 있는 자연스러운 정렬 순서, 반면 비슷한 인터페이스를 구현하는 클래스를 주님으로부터그에게 자연 정렬 순서 (클래스 의자, 예를 들어) 와 함께 제공되어야 하는 비교자 (또는 익명의 비교자 클래스).
두 가지 예입니다.
public class Number implements Comparable<Number> {
private int value;
public Number(int value) { this.value = value; }
public int compareTo(Number anotherInstance) {
return this.value - anotherInstance.value;
}
}
public class Chair {
private int weight;
private int height;
public Chair(int weight, int height) {
this.weight = weight;
this.height = height;
}
/* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
public int compare(Chair chair1, Chair chair2) {
return chair1.getWeight() - chair2.getWeight();
}
}
class ChairHeightComparator implements Comparator<Chair> {
public int compare(Chair chair1, Chair chair2) {
return chair1.getHeight() - chair2.getHeight();
}
}
사용법:
List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);
List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());
// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
public int compare(Chair chair1, Chair chair2) {
...
}
});
그래, 넌 할 수 있습니다. 이 두 가지 옵션 품목을 비교한 인터페이스입니다 Comparable< T>; 및 T> Comparator<; 인터페이스입니다.
이 두 가지 다른 비헤이비어를 인터페이스를 사용할 수 있습니다. 방금 설명됨 문장열 처럼 행동하는 객체에는 비교 할 수 있습니다 (실제 구체화하십시오 는 동급). 둘째, 일을 할 수 있도록 해주는 비교자 틀렸다니까 다음과 같은 것을 할 수 있습니다.
Collections.sort(myArrayList, new MyComparator());
Collections.sort(myArrayList);
컬렉션 이 포함되어 있는 여러 가지 유용한 도구, common class.
< h2> expression< /h2>, 람다, JAVA, 8.
Collections.sort(studList, (Student s1, Student s2) ->{
return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
});
< h3> OR< /h3>;;;
Comparator<Student> c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)
매일 이 시간 이후 나타날 기술이은 오토메이티드 변화는 없을 것이라고 전망했다. 내가 봐도 매우 흥미로운 램다제 및 걸린 것 같다.
여기 있을 경우 (예:
List<Person> sortedByAgePersons = new ArrayList<Person>(persons);
Collections.sort(sortedByAgePersons, new Comparator<Person>() {
public int compare(Person p1, Person p2) {
return Integer.valueOf(p1.getAge()).compareTo(p2.getAge());
}
});
List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge());
물론 이 같은 성능을 가진 아름다움에 영향을 미치게 됩니다 (평균 2 배) 보다 쉽게 읽을 수 있지만, 찾을 수 있는 코드?
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
public class test {
public static class Person {
public String name;
public int id;
public Date hireDate;
public Person(String iname, int iid, Date ihireDate) {
name = iname;
id = iid;
hireDate = ihireDate;
}
public String toString() {
return name + " " + id + " " + hireDate.toString();
}
// Comparator
public static class CompId implements Comparator<Person> {
@Override
public int compare(Person arg0, Person arg1) {
return arg0.id - arg1.id;
}
}
public static class CompDate implements Comparator<Person> {
private int mod = 1;
public CompDate(boolean desc) {
if (desc) mod =-1;
}
@Override
public int compare(Person arg0, Person arg1) {
return mod*arg0.hireDate.compareTo(arg1.hireDate);
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
SimpleDateFormat df = new SimpleDateFormat("mm-dd-yyyy");
ArrayList<Person> people;
people = new ArrayList<Person>();
try {
people.add(new Person("Joe", 92422, df.parse("12-12-2010")));
people.add(new Person("Joef", 24122, df.parse("1-12-2010")));
people.add(new Person("Joee", 24922, df.parse("12-2-2010")));
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Collections.sort(people, new Person.CompId());
System.out.println("BY ID");
for (Person p : people) {
System.out.println(p.toString());
}
Collections.sort(people, new Person.CompDate(false));
System.out.println("BY Date asc");
for (Person p : people) {
System.out.println(p.toString());
}
Collections.sort(people, new Person.CompDate(true));
System.out.println("BY Date desc");
for (Person p : people) {
System.out.println(p.toString());
}
}
}
가장 손쉬운 방법으로 영어 알파벳 정렬하려면 캐비닛용입니다 jave 8
public class NewspaperClass implements Comparable<NewspaperClass>{
public String name;
@Override
public int compareTo(NewspaperClass another) {
return name.compareTo(another.name);
}
}
Collections.sort(Your List);
스케쳐내 위한 영어 알파벳 문자가 포함된 정렬하려면 비사양 로케일에 사용할 수 있습니다. 아래 코드를 사용하여 터키 문자 정렬.
public class NewspaperClass implements Comparator<NewspaperClass> {
public String name;
public Boolean isUserNewspaper=false;
private Collator trCollator = Collator.getInstance(new Locale("tr_TR"));
@Override
public int compare(NewspaperClass lhs, NewspaperClass rhs) {
trCollator.setStrength(Collator.PRIMARY);
return trCollator.compare(lhs.name,rhs.name);
}
}
Collections.sort(your array list,new NewspaperClass());
['콜레스티온s.소르'] [1] 정렬할 수 있는 방법을 사용하여 '목록' '비교자' '를 사용하여 구현할 수 있는' 비교자 전달합니다. ['콩파라토리콤파링'] [4] 메서드입니다 참조 을 통과시킬 수 있는 방법을 필요한 '함수'. 다행히 실제 코드는 이 보다 훨씬 짧은 간단해진다는 설명.
Java 의 8:
Collections.sort(list, comparing(ClassName::getName));
또는
Collections.sort(list, comparing(ClassName::getName).reversed());
다른 방법은
Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));
[1]: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collections.html # 정렬함으로써 (제바스티라자리스트, 제바스티라자콤프라토르)
[4]: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Comparator.html # 비교 (제바스티라자풍크션지풍크션)
List<User> users = Arrays.asList(user1,user2,user3);
users.sort( (u1, u2) -> {
return u1.getFirstName.compareTo(u2.getFirstName());});
Http://visvv.blogspot.in/2016/01/sorting-objects-in-java-8.html. 참조
Jave 8 람다 빠른 정렬.
Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));
오더할 구아바 시도해 볼 수 있습니다.
Function<Item, Date> getStartDate = new Function<Item, Date>() {
public Date apply(Item item) {
return item.getStartDate();
}
};
List<Item> orderedItems = Ordering.natural().onResultOf(getStartDate).
sortedCopy(items);
예, 예를 들어, s 의 가능한 that& # 39 에서 [이 질문에] [1] 내가 '속성' v '클래스' 이네스발루 정렬하려면
// Sorting by property v using a custom comparator.
Arrays.sort( array, new Comparator<IndexValue>(){
public int compare( IndexValue a, IndexValue b ){
return a.v - b.v;
}
});
여기서 m , # 39 I& 판단될 경우 익명 클래스를 만드는 내부 (Java 로 이는 closures) 와 '클래스' 를 바로 이 '정렬' 방법을 어레이에는 반군지역
또한 해당 객체를 구현하십시오 '비교' (that& # 39 의 가장 핵심적인 Java 는 문자열 라이브러리 사용) 하지만, 그렇게 되면 자연 정렬하려면 " 정의하십시오 order". # 39, t let it 자체 및 doesn& 클래스의 새로운 수준들과 꽂으십시오 있습니다.
[1]: # 2784353 https://stackoverflow.com/questions/2784218/get-indexes-of-n-smallest-elements-in-an-array/2784353
이러한 모든 답을 찾을 수 없는 경우 내가 가장 신뢰할 수 있는 기본 클래스 (객체) 를 구현할 수 있는 도우미 비슷하거나 비슷한 인터페이스입니다.
내 솔루션을 함께 있지! # 39 에 의해 그들의 다음 코드를 문자열 이름 필드 vmnet object& 비교할 수 있습니다. 쉽게 수정할 수 있습니다, 그런데 이 이름을 사용하지 않도록 필요한 정보기술 (it) 또는 객체 중 노출시킵니다 chunghwa 운영까지도 비교할.
Collections.sort(anArrayListOfSomeObjectPerhapsUsersOrSomething, new ReflectiveComparator(). new ListComparator("name"));
public class ReflectiveComparator {
public class FieldComparator implements Comparator<Object> {
private String fieldName;
public FieldComparator(String fieldName){
this.fieldName = fieldName;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public int compare(Object object1, Object object2) {
try {
Field field = object1.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
Comparable object1FieldValue = (Comparable) field.get(object1);
Comparable object2FieldValue = (Comparable) field.get(object2);
return object1FieldValue.compareTo(object2FieldValue);
}catch (Exception e){}
return 0;
}
}
public class ListComparator implements Comparator<Object> {
private String fieldName;
public ListComparator(String fieldName) {
this.fieldName = fieldName;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public int compare(Object object1, Object object2) {
try {
Field field = object1.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
Comparable o1FieldValue = (Comparable) field.get(object1);
Comparable o2FieldValue = (Comparable) field.get(object2);
if (o1FieldValue == null){ return -1;}
if (o2FieldValue == null){ return 1;}
return o1FieldValue.compareTo(o2FieldValue);
} catch (NoSuchFieldException e) {
throw new IllegalStateException("Field doesn't exist", e);
} catch (IllegalAccessException e) {
throw new IllegalStateException("Field inaccessible", e);
}
}
}
}
이 코드는 스니핏 유용할 수 있습니다. 스케쳐내 객체를 정렬하려면 내 경우 난 로렌아줌마가 정렬하려면 보루메나미:
public List<Volume> getSortedVolumes() throws SystemException {
List<Volume> volumes = VolumeLocalServiceUtil.getAllVolumes();
Collections.sort(volumes, new Comparator<Volume>() {
public int compare(Volume o1, Volume o2) {
Volume p1 = (Volume) o1;
Volume p2 = (Volume) o2;
return p1.getVolumeName().compareToIgnoreCase(
p2.getVolumeName());
}
});
return volumes;
}
이 작품. 내가 써도 내 jsp.
이후 리스트리소르타 () 메서드를 사용하여 새 대신 콜레스티온.소르 () 는 1.8 그러니까 직접 매입옵션 미리스트콘텐리소르타 ()
여기 있는 리스트리소르타 () 는 코드 스니핏 보여주는 기능:
List<Fruit> fruits = new ArrayList<Fruit>();
fruits.add(new Fruit("Kiwi","green",40));
fruits.add(new Fruit("Banana","yellow",100));
fruits.add(new Fruit("Apple","mixed green,red",120));
fruits.add(new Fruit("Cherry","red",10));
// a) using an existing compareto() method
fruits.sort((Fruit f1,Fruit f2) -> f1.getFruitName().compareTo(f2.getFruitName()));
System.out.println("Using String.compareTo(): " + fruits);
//Using String.compareTo(): [Apple is: mixed green,red, Banana is: yellow, Cherry is: red, Kiwi is: green]
// b) Using a comparable class
fruits.sort((Fruit f1,Fruit f2) -> f1.compareTo(f2));
System.out.println("Using a Comparable Fruit class (sort by color): " + fruits);
// Using a Comparable Fruit class (sort by color): [Kiwi is green, Apple is: mixed green,red, Cherry is: red, Banana is: yellow]
매 클래스 입니다.
public class Fruit implements Comparable<Fruit>
{
private String name;
private String color;
private int quantity;
public Fruit(String name,String color,int quantity)
{ this.name = name; this.color = color; this.quantity = quantity; }
public String getFruitName() { return name; }
public String getColor() { return color; }
public int getQuantity() { return quantity; }
@Override public final int compareTo(Fruit f) // sorting the color
{
return this.color.compareTo(f.color);
}
@Override public String toString()
{
return (name + " is: " + color);
}
} // end of Fruit class
들여다 볼 수 있을 수 있습니다 이 프레젠테이션입니다 2016년 독일 슈투트가르트에서 열린 jave 포럼을 연다.
불과 99%, 영어, 독일어 사용 슬라이드에서는 내용이 " based". Java 소스 코드를. 같은
someCollection.sort(
OurCustomComparator
.comparing(Person::getName)
.thenComparing(Person::getId)
);
사용하고 있는 '기본' 루커스톰콤프라토르 서버리스 (및 기타 흥미로운 아이디어를). 그림과 같이 매우 간단한 코드를 getter 방법 등 일부 강조표시할 정렬. 와 슈퍼 단순해졌습니다 체인식으로 연결 (또는 반전합니다) 의 정렬 기준은 다음과 같다.
Java8 분할합니다 경우 쉽게 시작할 수 있도록 많은 자료를 찾아볼 수 없다.