Guava - Classe di ordinazione
L'ordinamento può essere visto come un comparatore arricchito con funzionalità di concatenamento potenziate, metodi di utilità multipli, capacità di ordinamento multi-tipo, ecc.
Dichiarazione di classe
Di seguito è riportata la dichiarazione per com.google.common.collect.Ordering<T> classe -
@GwtCompatible
public abstract class Ordering<T>
extends Object
implements Comparator<T>
Metodi di classe
Suor n | Metodo e descrizione |
---|---|
1 | static Ordering<Object> allEqual() Restituisce un ordine che considera tutti i valori uguali, indicando "nessun ordine". Il passaggio di questo ordinamento a qualsiasi algoritmo di ordinamento stabile non comporta alcuna modifica dell'ordine degli elementi. |
2 | static Ordering<Object> arbitrary() Restituisce un ordinamento arbitrario su tutti gli oggetti, per il quale compare (a, b) == 0 implica a == b (uguaglianza di identità). |
3 | int binarySearch(List<? extends T> sortedList, T key) Cerca la chiave in SortList utilizzando l'algoritmo di ricerca binaria. |
4 | abstract int compare(T left, T right) Confronta i suoi due argomenti per l'ordine. |
5 | <U extends T> Ordering<U> compound(Comparator<? super U> secondaryComparator) Restituisce un ordinamento che prima usa l'ordinamento this, ma che in caso di "pareggio", delega poi a secondaryComparator. |
6 | static <T> Ordering<T> compound(Iterable<? extends Comparator<? super T>> comparators) Restituisce un ordine che prova ogni dato comparatore in ordine finché non viene trovato un risultato diverso da zero, restituendo quel risultato e restituendo zero solo se tutti i comparatori restituiscono zero. |
7 | static <T> Ordering<T> explicit(List<T> valuesInOrder) Restituisce un ordine che confronta gli oggetti in base all'ordine in cui compaiono nell'elenco fornito. |
8 | static <T> Ordering<T> explicit(T leastValue, T... remainingValuesInOrder) Restituisce un ordinamento che confronta gli oggetti in base all'ordine in cui sono assegnati a questo metodo. |
9 | static <T> Ordering<T> from(Comparator<T> comparator) Restituisce un ordine basato su un'istanza di confronto esistente. |
10 | <E extends T> List<E> greatestOf(Iterable<E> iterable, int k) Restituisce i k elementi più grandi dell'iterabile dato in base a questo ordine, in ordine dal maggiore al minimo. |
11 | <E extends T> List<E> greatestOf(Iterator<E> iterator, int k) Restituisce i k elementi più grandi dall'iteratore dato in base a questo ordine, in ordine dal maggiore al minimo. |
12 | <E extends T> ImmutableList<E> immutableSortedCopy(Iterable<E> elements) Restituisce un elenco immutabile contenente elementi ordinati in base a questo ordine. |
13 | boolean isOrdered(Iterable<? extends T> iterable) Restituisce vero se ogni elemento in iterabile dopo il primo è maggiore o uguale all'elemento che lo ha preceduto, in base a questo ordine. |
14 | boolean isStrictlyOrdered(Iterable<? extends T> iterable) Restituisce vero se ogni elemento in iterabile dopo il primo è strettamente maggiore dell'elemento che lo ha preceduto, secondo questo ordine |
15 | <E extends T> List<E> leastOf(Iterable<E> iterable, int k) Restituisce i k elementi minimi dell'iterabile dato in base a questo ordine, in ordine dal minimo al maggiore. |
16 | <E extends T> List<E> leastOf(Iterator<E> elements, int k) Restituisce i k elementi minimi dell'iteratore dato in base a questo ordine, dal minimo al massimo. |
17 | <S extends T> Ordering<Iterable<S>> lexicographical() Restituisce un nuovo ordinamento che ordina gli iterabili confrontando gli elementi corrispondenti a coppie finché non viene trovato un risultato diverso da zero; impone "l'ordine del dizionario". |
18 | <E extends T> E max(E a, E b) Restituisce il maggiore dei due valori in base a questo ordine. |
19 | <E extends T> E max(E a, E b, E c, E... rest) Restituisce il massimo dei valori specificati in base a questo ordine. |
20 | <E extends T> E max(Iterable<E> iterable) Restituisce il massimo dei valori specificati in base a questo ordine. |
21 | <E extends T> E max(Iterator<E> iterator) Restituisce il massimo dei valori specificati in base a questo ordine. |
22 | <E extends T> E min(E a, E b) Restituisce il minore dei due valori in base a questo ordine. |
23 | <E extends T> E min(E a, E b, E c, E... rest) Restituisce il minimo dei valori specificati in base a questo ordine. |
24 | <E extends T> E min(Iterable<E> iterable) Restituisce il minimo dei valori specificati in base a questo ordine. |
25 | <E extends T> E min(Iterator<E> iterator) Restituisce il minimo dei valori specificati in base a questo ordine. |
26 | static <C extends Comparable> Ordering<C> natural() Restituisce un ordinamento serializzabile che utilizza l'ordine naturale dei valori. |
27 | <S extends T> Ordering<S> nullsFirst() Restituisce un ordinamento che considera null come inferiore a tutti gli altri valori e lo utilizza per confrontare valori non null. |
28 | <S extends T> Ordering<S> nullsLast() Restituisce un ordine che considera null come maggiore di tutti gli altri valori e utilizza questo ordinamento per confrontare valori non null. |
29 | <F> Ordering<F> onResultOf(Function<F,? extends T> function) Restituisce un nuovo ordinamento su F che ordina gli elementi applicando prima una funzione ad essi, quindi confrontando i risultati usando questo. |
30 | <S extends T> Ordering<S> reverse() Restituisce il contrario di questo ordine; Ordering equivalente a Collections.reverseOrder (Comparator). |
31 | <E extends T> List<E> sortedCopy(Iterable<E> elements) Restituisce un elenco modificabile contenente elementi ordinati in base a questo ordine; usalo solo quando l'elenco risultante potrebbe richiedere ulteriori modifiche o potrebbe contenere null. |
32 | static Ordering<Object> usingToString() Restituisce un ordinamento che confronta gli oggetti in base all'ordinamento naturale delle loro rappresentazioni di stringa come restituito da toString (). |
Metodi ereditati
Questa classe eredita i metodi dalla classe seguente:
- java.lang.Object
Esempio di classe di ordinazione
Crea il seguente programma java usando qualsiasi editor di tua scelta, diciamo C:/> Guava.
GuavaTester.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import com.google.common.collect.Ordering;
public class GuavaTester {
public static void main(String args[]) {
List<Integer> numbers = new ArrayList<Integer>();
numbers.add(new Integer(5));
numbers.add(new Integer(2));
numbers.add(new Integer(15));
numbers.add(new Integer(51));
numbers.add(new Integer(53));
numbers.add(new Integer(35));
numbers.add(new Integer(45));
numbers.add(new Integer(32));
numbers.add(new Integer(43));
numbers.add(new Integer(16));
Ordering ordering = Ordering.natural();
System.out.println("Input List: ");
System.out.println(numbers);
Collections.sort(numbers,ordering );
System.out.println("Sorted List: ");
System.out.println(numbers);
System.out.println("======================");
System.out.println("List is sorted: " + ordering.isOrdered(numbers));
System.out.println("Minimum: " + ordering.min(numbers));
System.out.println("Maximum: " + ordering.max(numbers));
Collections.sort(numbers,ordering.reverse());
System.out.println("Reverse: " + numbers);
numbers.add(null);
System.out.println("Null added to Sorted List: ");
System.out.println(numbers);
Collections.sort(numbers,ordering.nullsFirst());
System.out.println("Null first Sorted List: ");
System.out.println(numbers);
System.out.println("======================");
List<String> names = new ArrayList<String>();
names.add("Ram");
names.add("Shyam");
names.add("Mohan");
names.add("Sohan");
names.add("Ramesh");
names.add("Suresh");
names.add("Naresh");
names.add("Mahesh");
names.add(null);
names.add("Vikas");
names.add("Deepak");
System.out.println("Another List: ");
System.out.println(names);
Collections.sort(names,ordering.nullsFirst().reverse());
System.out.println("Null first then reverse sorted list: ");
System.out.println(names);
}
}
Verifica il risultato
Compila la classe usando javac compilatore come segue -
C:\Guava>javac GuavaTester.java
Ora esegui il GuavaTester per vedere il risultato.
C:\Guava>java GuavaTester
Guarda il risultato.
Input List:
[5, 2, 15, 51, 53, 35, 45, 32, 43, 16]
Sorted List:
[2, 5, 15, 16, 32, 35, 43, 45, 51, 53]
======================
List is sorted: true
Minimum: 2
Maximum: 53
Reverse: [53, 51, 45, 43, 35, 32, 16, 15, 5, 2]
Null added to Sorted List:
[53, 51, 45, 43, 35, 32, 16, 15, 5, 2, null]
Null first Sorted List:
[null, 2, 5, 15, 16, 32, 35, 43, 45, 51, 53]
======================
Another List:
[Ram, Shyam, Mohan, Sohan, Ramesh, Suresh, Naresh, Mahesh, null, Vikas, Deepak]
Null first then reverse sorted list:
[Vikas, Suresh, Sohan, Shyam, Ramesh, Ram, Naresh, Mohan, Mahesh, Deepak, null]