Java로 정렬된 컬렉션
저는 자바어 초보입니다.Java에서 정렬된 목록을 유지하기 위해 사용할 수 있는 컬렉션을 제안하십시오.는 ★★★★★★★★★★★★★★★★★★★★★★.Map ★★★★★★★★★★★★★★★★★」Set하지만 그건 내가 찾던 게 아니었어
이것은 매우 늦게 도착하지만 JDK에는 정렬된 목록을 얻기 위한 클래스가 있습니다.과 다소 있다)라는 이름이 붙여졌다.Sorted* "interfaces"(인터페이스)java.util.PriorityQueue . . 둘 either either either either either either either either either either either either either either either either " " " " 。Comparable<?> 「」를 합니다.Comparator.
「 」와의 Listusing using Collections.sort(...)구조를 하여 O를 통해 하고 정렬된 O(log(n) 삽입 퍼포먼스는 O(n)에 입니다.ArrayListO(n)(오,오,오,오,오,오,오,오,오,오,오,오,오,오,오,오,오,오,오,오,오,오,오,오,오,오,오)입니다.
단, ''와 '''는List,PriorityQueue 액세스를 (「인덱스 액세스get(5)), 힙 내의 아이템에 액세스하는 유일한 방법은 아이템을 한 번에 하나씩 꺼내는 것입니다(이름 추가).PriorityQueue를 참조해 주세요.
TreeMap과 TreeSet은 소트된 순서로 콘텐츠를 반복합니다.또는 ArrayList를 사용하여 Collections.sort()를 사용하여 정렬할 수 있습니다.이러한 클래스는 모두 java.util로 되어 있습니다.
자주 변경할 정렬된 목록(즉, 정렬과 더불어 중복이 허용되고 인덱스에 의해 요소를 효율적으로 참조할 수 있는 구조)을 유지하려면 ArrayList를 사용합니다.단, 요소를 삽입해야 할 때는 항상 Collections.binarySearch()를 사용하여 지정된 인덱스를 추가합니다.요소.후자의 방법은 목록을 정렬된 순서로 유지하기 위해 삽입해야 하는 색인을 나타냅니다.
Google Guava의 TreeMultiset 클래스를 사용합니다.Guava는 화려한 컬렉션 API를 가지고 있습니다.
중 입니다.add()★★★★★★ 。
SortedSet 구현, 즉 TreeSet이 필요합니다.
몇 가지 옵션이 있습니다.중복되지 않고 삽입하는 오브젝트가 비슷하다면 Tree Set을 추천합니다.
이를 위해 Collections 클래스의 정적 메서드를 사용할 수도 있습니다.
Collections #sort(java.util)를 참조하십시오.목록) 및 TreeSet을 참조하십시오.
목록만 정렬하는 경우 모든 종류의 목록을 사용하고 Collections.sort()를 사용합니다.목록의 요소가 고유하고 항상 정렬되도록 하려면 SortedSet을 사용합니다.
모든 메서드가 위임된 내부 인스턴스를 가진 List를 구현했습니다.
public class ContactList implements List<Contact>, Serializable {
private static final long serialVersionUID = -1862666454644475565L;
private final List<Contact> list;
public ContactList() {
super();
this.list = new ArrayList<Contact>();
}
public ContactList(List<Contact> list) {
super();
//copy and order list
List<Contact>aux= new ArrayList(list);
Collections.sort(aux);
this.list = aux;
}
public void clear() {
list.clear();
}
public boolean contains(Object object) {
return list.contains(object);
}
그 후, 요소가 존재하지 않으면 올바른 위치에 삽입하거나, 존재하지 않으면 교체하는 새로운 메서드 「put Ordered」를 실장했습니다.
public void putOrdered(Contact contact) {
int index=Collections.binarySearch(this.list,contact);
if(index<0){
index= -(index+1);
list.add(index, contact);
}else{
list.set(index, contact);
}
}
반복 요소를 허용하려면 대신(또는 둘 다) addOrder를 구현하십시오.
public void addOrdered(Contact contact) {
int index=Collections.binarySearch(this.list,contact);
if(index<0){
index= -(index+1);
}
list.add(index, contact);
}
삽입을 방지하려면 "추가" 및 "설정" 메서드에 지원되지 않는 작업 예외를 발생시킬 수도 있습니다.
public boolean add(Contact object) {
throw new UnsupportedOperationException("Use putOrdered instead");
}
ListIterator 메서드는 내부 목록을 변경할 수 있으므로 주의해야 합니다.이 경우 내부 목록의 복사본을 반환하거나 다시 예외를 발생시킬 수 있습니다.
public ListIterator<Contact> listIterator() {
return (new ArrayList<Contact>(list)).listIterator();
}
원하는 대로 정렬 목록을 구현하는 가장 효율적인 방법은 다음과 같은 색인 가능한 스키플리스트를 구현하는 것입니다: Wikipedia: 색인 가능한 스키리스트.O(log(n)에 삽입/삭제를 허용하고 인덱스 액세스를 동시에 허용합니다.그리고 중복도 허용됩니다.
스키플리스트는 꽤 흥미롭고 데이터 구조도 과소평가되어 있습니다.유감스럽게도 Java 기반 라이브러리에는 인덱스 스키플리스트 구현이 없지만 오픈소스 구현 중 하나를 사용하거나 직접 구현할 수 있습니다.ConcurrentSkipListSet 및 ConcurrentSkipListMap과 같은 정기적인 스키플리스트 구현이 있습니다.
Tree Set은 중복을 허용하지 않으며 특정 위치에서 요소를 가져오는 메서드를 제공하지 않기 때문에 작동하지 않습니다.우선 순위.큐는 목록의 기본 요건인 특정 위치에서 요소를 가져올 수 없기 때문에 작동하지 않습니다.중복이 필요 없는 한 O(logn) insert time으로 Java에서 정렬된 목록을 유지하려면 자체 알고리즘을 구현해야 한다고 생각합니다.솔루션이 TreeMap을 사용할 수 있습니다.TreeMap에서는 키가 항목의 서브클래스이며 중복이 허용되도록 equal 메서드를 덮어씁니다.
LambdaJ 사용
Java 8 이전 버전을 사용하는 경우 LambdaJ를 사용하여 이러한 작업을 해결할 수 있습니다.다음 URL에서 찾을 수 있습니다.http://code.google.com/p/lambdaj/
다음은 예를 제시하겠습니다.
반복 정렬
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());
}
});
LambdaJ로 정렬
List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge());
물론 이런 아름다움은 퍼포먼스에 영향을 미치지만(평균 2회), 좀 더 읽기 쉬운 코드를 찾을 수 있을까요?
람다 식을 사용하여 Java 8로 정렬
Collections.sort(persons, (p1, p2) -> p1.getAge().compareTo(p2.getAge()));
//or
persons.sort((p1, p2) -> p1.getAge().compareTo(p2.getAge()));
priority의 문제큐는 단순한 어레이에 의해 백업되며 요소를 순서대로 가져오는 논리는 "queue [2*n+1] 및 queue [2*(n+1)]"로 이루어집니다.머리에서 꺼내는 것만으로 매우 효과적이지만, 어느 시점에서 .toArray를 호출하려고 하면 사용할 수 없게 됩니다.
com.google.common.collect를 사용하여 이 문제를 해결합니다.TreeMultimap. 단, 0을 반환하지 않는 값의 커스텀 컴퍼레이터를 Order로 감싸고 있습니다.
예: 더블의 경우:
private static final Ordering<Double> NoEqualOrder = Ordering.from(new Comparator<Double>() {
@Override
public int compare(Double d1, Double d2)
{
if (d1 < d2) {
return -1;
}
else {
return 1;
}
}
});
이렇게 하면 .toArray()를 호출했을 때 값이 순서대로 표시되며 중복도 발생합니다.
Set의 경우 TreeSet을 사용할 수 있습니다.TreeSet은 해당 특정 객체에 대해 Comparable에 전달된 자연스러운 순서 또는 정렬 순서에 따라 요소를 정렬합니다.맵에는 TreeMap을 사용합니다.TreeMap은 키를 기준으로 정렬합니다.오브젝트를 TreeMap에 키로서 추가하려면 해당 클래스는 동등한 인터페이스를 구현해야 합니다.이 인터페이스는 정렬 순서의 정의를 포함하는 compare to() 메서드를 구현하도록 강제합니다.http://techmastertutorial.in/java-collection-impl.html
원하는 것은 바이너리 검색 트리입니다.정렬된 순서를 유지하면서 검색, 제거 및 삽입에 대한 로그 액세스를 제공합니다(변화된 트리가 없는 한 선형입니다).구현이 매우 쉽고 List 인터페이스를 구현시킬 수도 있지만 인덱스 액세스는 복잡해집니다.
두 번째 접근법은 Array List를 사용한 후 버블 정렬을 구현하는 것입니다.한 번에 1개의 요소를 삽입 또는 삭제하기 때문에 삽입 및 삭제 접근 시간은 선형적입니다.검색은 로그 및 인덱스 액세스 상수입니다(LinkedList의 경우 시간이 다를 수 있습니다).필요한 유일한 코드는 5, 6줄의 버블 정렬입니다.
Arraylist와 Treemap을 사용할 수 있습니다.반복값도 필요하지만 TreeSet도 사용할 수 없습니다.단, TreeSet도 정렬되어 있지만 비교기를 정의해야 합니다.
sort() 메서드를 사용하여 다음과 같이 목록을 정렬합니다.
List list = new ArrayList();
//add elements to the list
Comparator comparator = new SomeComparator();
Collections.sort(list, comparator);
상세한 것에 대하여는, http://tutorials.jenkov.com/java-collections/sorting.html 의 링크를 참조해 주세요.
사용하다TreeSet요소를 정렬된 순서로 제공합니다.또는 사용Collection.sort()외부 분류용Comparator().
import java.util.TreeSet;
public class Ass3 {
TreeSet<String>str=new TreeSet<String>();
str.add("dog");
str.add("doonkey");
str.add("rat");
str.add("rabbit");
str.add("elephant");
System.out.println(str);
}
Java 8 Comparator에서 목록을 정렬하고 싶다면, 여기 세계에서 가장 인구가 많은 10개의 도시가 있으며, 타임지가 보도한 바와 같이 이름을 기준으로 정렬하고 싶습니다.일본 오사카...멕시코시티, 멕시코...베이징, 중국...상파울루, 브라질...인도 뭄바이...중국 상하이...인도 델리...일본 도쿄
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class SortCityList {
/*
* Here are the 10 most populated cities in the world and we want to sort it by
* name, as reported by Time. Osaka, Japan. ... Mexico City, Mexico. ...
* Beijing, China. ... São Paulo, Brazil. ... Mumbai, India. ... Shanghai,
* China. ... Delhi, India. ... Tokyo, Japan.
*/
public static void main(String[] args) {
List<String> cities = Arrays.asList("Osaka", "Mexico City", "São Paulo", "Mumbai", "Shanghai", "Delhi",
"Tokyo");
System.out.println("Before Sorting List is:-");
System.out.println(cities);
System.out.println("--------------------------------");
System.out.println("After Use of List sort(String.CASE_INSENSITIVE_ORDER) & Sorting List is:-");
cities.sort(String.CASE_INSENSITIVE_ORDER);
System.out.println(cities);
System.out.println("--------------------------------");
System.out.println("After Use of List sort(Comparator.naturalOrder()) & Sorting List is:-");
cities.sort(Comparator.naturalOrder());
System.out.println(cities);
}
}
사용자 정의 기준에 따라 ArrayList 정렬
모델 클래스
class Student
{
int rollno;
String name, address;
public Student(int rollno, String name, String address)
{
this.rollno = rollno;
this.name = name;
this.address = address;
}
public String toString()
{
return this.rollno + " " + this.name + " " + this.address;
}
}
클래스 정렬
class Sortbyroll implements Comparator<Student>
{
public int compare(Student a, Student b)
{
return a.rollno - b.rollno;
}
}
메인 클래스
class Main
{
public static void main (String[] args)
{
ArrayList<Student> ar = new ArrayList<Student>();
ar.add(new Student(111, "bbbb", "london"));
ar.add(new Student(131, "aaaa", "nyc"));
ar.add(new Student(121, "cccc", "jaipur"));
System.out.println("Unsorted");
for (int i=0; i<ar.size(); i++)
System.out.println(ar.get(i));
Collections.sort(ar, new Sortbyroll());
System.out.println("\nSorted by rollno");
for (int i=0; i<ar.size(); i++)
System.out.println(ar.get(i));
}
}
산출량
Unsorted
111 bbbb london
131 aaaa nyc
121 cccc jaipur
Sorted by rollno
111 bbbb london
121 cccc jaipur
131 aaaa nyc
직접 만들어 보는 게 어때요?
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
class SortedList<E extends Comparable<E>> extends ArrayList<E> {
@Override
public boolean add(E e) {
int i = Collections.binarySearch(this, e);
if (i < 0) i = ~i;
super.add(i, e);
return true;
} // add(E e)
@Override
public void add(int index, E element) {
this.add(element);
} // add(int, E)
@Override
public boolean addAll(Collection<? extends E> c) {
int oldSize = this.size();
for (E element : c) this.add(element);
return oldSize != this.size();
} // addAll(Collection<? extends E>)
@Override
public boolean addAll(int index, Collection<? extends E> c) {
int oldSize = this.size();
Iterator<? extends E> it = c.iterator();
for (int i = 0; i < index; ++i) it.next();
while (it.hasNext()) this.add(it.next());
return oldSize != this.size();
} // addAll(Collection<? extends E>)
@Override
public E set(int index, E element) {
E ret = this.get(index);
this.remove(index);
this.add(element);
return ret;
} // set(int, E)
} // SortedList<E> Class
public class Solution {
public static void main(String[] args) {
Random r = new Random(1);
List<Integer> sortedList = new SortedList<>();
List<Integer> unsortedList = new ArrayList<>();
for (int i = 0; i < 50; ++i) {
int next = r.nextInt(1000);
sortedList.add(next);
unsortedList.add(next);
} // for (int i = 0; i < 50; ++i)
System.out.println("unsortedList:");
System.out.println(unsortedList);
System.out.println("\nsortedList:");
System.out.println(sortedList);
sortedList.clear();
sortedList.addAll(unsortedList);
System.out.println("\ntest for addAll(Collection) method:");
System.out.println(sortedList);
sortedList.clear();
sortedList.addAll(30, unsortedList);
System.out.println("\ntest for addAll(int, Collection) method:");
System.out.println(sortedList);
sortedList.set(0, 999);
System.out.println("\ntest for set(int, E) method:");
System.out.println(sortedList);
} // main(String[])
} // Solution Class
출력:
unsortedList:
[985, 588, 847, 313, 254, 904, 434, 606, 978, 748, 569, 473, 317, 263, 562, 234, 592, 262, 596, 189, 376, 332, 310, 99, 674, 959, 298, 153, 437, 302, 205, 854, 800, 6, 363, 955, 689, 820, 75, 834, 415, 660, 477, 737, 477, 592, 220, 888, 500, 357]
sortedList:
[6, 75, 99, 153, 189, 205, 220, 234, 254, 262, 263, 298, 302, 310, 313, 317, 332, 357, 363, 376, 415, 434, 437, 473, 477, 477, 500, 562, 569, 588, 592, 592, 596, 606, 660, 674, 689, 737, 748, 800, 820, 834, 847, 854, 888, 904, 955, 959, 978, 985]
test for addAll(Collection) method:
[6, 75, 99, 153, 189, 205, 220, 234, 254, 262, 263, 298, 302, 310, 313, 317, 332, 357, 363, 376, 415, 434, 437, 473, 477, 477, 500, 562, 569, 588, 592, 592, 596, 606, 660, 674, 689, 737, 748, 800, 820, 834, 847, 854, 888, 904, 955, 959, 978, 985]
test for addAll(int, Collection) method:
[6, 75, 205, 220, 357, 363, 415, 477, 477, 500, 592, 660, 689, 737, 800, 820, 834, 854, 888, 955]
test for set(int, E) method:
[75, 205, 220, 357, 363, 415, 477, 477, 500, 592, 660, 689, 737, 800, 820, 834, 854, 888, 955, 999]
언급URL : https://stackoverflow.com/questions/416266/sorted-collection-in-java
'programing' 카테고리의 다른 글
| 'vue'에서 'createApp' 내보내기를 찾을 수 없습니다. (0) | 2022.08.10 |
|---|---|
| JPA OneToMany가 하위 항목을 삭제하지 않음 (0) | 2022.08.10 |
| C, C++에서 Windows 또는 Linux 검출 (0) | 2022.08.10 |
| Java 8의 map() 메서드와 platMap() 메서드의 차이점은 무엇입니까? (0) | 2022.08.10 |
| 0x 표기법을 사용한 숫자는 무엇을 의미합니까? (0) | 2022.08.10 |