Goyave - Classe de commande

La commande peut être considérée comme un comparateur enrichi avec une fonctionnalité de chaînage améliorée, plusieurs méthodes utilitaires, une capacité de tri multi-type, etc.

Déclaration de classe

Voici la déclaration pour com.google.common.collect.Ordering<T> classe -

@GwtCompatible
public abstract class Ordering<T>
   extends Object
      implements Comparator<T>

Méthodes de classe

Sr.Non	Méthode et description
1	static Ordering<Object> allEqual() Renvoie un ordre qui traite toutes les valeurs comme égales, indiquant «aucun ordre». Le passage de cet ordre à un algorithme de tri stable n'entraîne aucun changement dans l'ordre des éléments.
2	static Ordering<Object> arbitrary() Renvoie un ordre arbitraire sur tous les objets, pour lesquels compare (a, b) == 0 implique a == b (égalité d'identité).
3	int binarySearch(List<? extends T> sortedList, T key) Recherche sortedList la clé à l'aide de l'algorithme de recherche binaire.
4	abstract int compare(T left, T right) Compare ses deux arguments pour l'ordre.
5	<U extends T> Ordering<U> compound(Comparator<? super U> secondaryComparator) Renvoie un ordre qui utilise d'abord l'ordre this, mais qui en cas de "cravate", délègue ensuite à secondaryComparator.
6	static <T> Ordering<T> compound(Iterable<? extends Comparator<? super T>> comparators) Renvoie un ordre qui essaie chaque comparateur donné dans l'ordre jusqu'à ce qu'un résultat différent de zéro soit trouvé, renvoyant ce résultat et ne renvoyant zéro que si tous les comparateurs retournent zéro.
sept	static <T> Ordering<T> explicit(List<T> valuesInOrder) Renvoie un ordre qui compare les objets selon l'ordre dans lequel ils apparaissent dans la liste donnée.
8	static <T> Ordering<T> explicit(T leastValue, T... remainingValuesInOrder) Renvoie un ordre qui compare les objets selon l'ordre dans lequel ils sont donnés à cette méthode.
9	static <T> Ordering<T> from(Comparator<T> comparator) Renvoie un ordre basé sur une instance de comparateur existante.
dix	<E extends T> List<E> greatestOf(Iterable<E> iterable, int k) Renvoie les k plus grands éléments de l'itérable donné selon cet ordre, du plus grand au moins.
11	<E extends T> List<E> greatestOf(Iterator<E> iterator, int k) Renvoie les k plus grands éléments de l'itérateur donné selon cet ordre, du plus grand au plus petit.
12	<E extends T> ImmutableList<E> immutableSortedCopy(Iterable<E> elements) Renvoie une liste immuable contenant des éléments triés par cet ordre.
13	boolean isOrdered(Iterable<? extends T> iterable) Renvoie true si chaque élément de l'itérable après le premier est supérieur ou égal à l'élément qui l'a précédé, selon cet ordre.
14	boolean isStrictlyOrdered(Iterable<? extends T> iterable) Renvoie true si chaque élément dans itérable après le premier est strictement supérieur à l'élément qui l'a précédé, selon cet ordre
15	<E extends T> List<E> leastOf(Iterable<E> iterable, int k) Renvoie les k moindres éléments de l'itérable donné selon cet ordre, du plus petit au plus grand.
16	<E extends T> List<E> leastOf(Iterator<E> elements, int k) Renvoie les k moindres éléments de l'itérateur donné selon cet ordre, du plus petit au plus grand.
17	<S extends T> Ordering<Iterable<S>> lexicographical() Renvoie un nouvel ordre qui trie les itérables en comparant les éléments correspondants par paires jusqu'à ce qu'un résultat différent de zéro soit trouvé; impose "l'ordre du dictionnaire".
18	<E extends T> E max(E a, E b) Renvoie la plus grande des deux valeurs selon cet ordre.
19	<E extends T> E max(E a, E b, E c, E... rest) Renvoie la plus grande des valeurs spécifiées selon cet ordre.
20	<E extends T> E max(Iterable<E> iterable) Renvoie la plus grande des valeurs spécifiées selon cet ordre.
21	<E extends T> E max(Iterator<E> iterator) Renvoie la plus grande des valeurs spécifiées selon cet ordre.
22	<E extends T> E min(E a, E b) Renvoie la plus petite des deux valeurs selon cet ordre.
23	<E extends T> E min(E a, E b, E c, E... rest) Renvoie la plus petite des valeurs spécifiées selon cet ordre.
24	<E extends T> E min(Iterable<E> iterable) Renvoie la plus petite des valeurs spécifiées selon cet ordre.
25	<E extends T> E min(Iterator<E> iterator) Renvoie la plus petite des valeurs spécifiées selon cet ordre.
26	static <C extends Comparable> Ordering<C> natural() Renvoie un ordre sérialisable qui utilise l'ordre naturel des valeurs.
27	<S extends T> Ordering<S> nullsFirst() Renvoie un ordre qui traite null comme inférieur à toutes les autres valeurs et l'utilise pour comparer les valeurs non nulles.
28	<S extends T> Ordering<S> nullsLast() Renvoie un ordre qui traite null comme supérieur à toutes les autres valeurs et utilise cet ordre pour comparer les valeurs non nulles.
29	<F> Ordering<F> onResultOf(Function<F,? extends T> function) Renvoie un nouvel ordre sur F qui ordonne les éléments en leur appliquant d'abord une fonction, puis en comparant ces résultats à l'aide de this.
30	<S extends T> Ordering<S> reverse() Renvoie l'inverse de cet ordre; l'ordre équivalent à Collections.reverseOrder (comparateur).
31	<E extends T> List<E> sortedCopy(Iterable<E> elements) Renvoie une liste modifiable contenant des éléments triés par cet ordre; utilisez ceci uniquement lorsque la liste résultante peut nécessiter des modifications supplémentaires ou peut contenir null.
32	static Ordering<Object> usingToString() Renvoie un ordre qui compare les objets par l'ordre naturel de leurs représentations sous forme de chaîne tel que renvoyé par toString ().

Méthodes héritées

Cette classe hérite des méthodes de la classe suivante -

java.lang.Object

Exemple de classe de commande

Créez le programme Java suivant en utilisant n'importe quel éditeur de votre choix dans say 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);
   }
}

Vérifiez le résultat

Compilez la classe en utilisant javac compilateur comme suit -

C:\Guava>javac GuavaTester.java

Exécutez maintenant le GuavaTester pour voir le résultat.

C:\Guava>java GuavaTester

Voyez le résultat.

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]