Ordering est un outil de comparaison pointu et puissant fourni par la bibliothèque de classes Guava. Ordering de Guava est plus puissant que JDK Comparator. Il est très facile à étendre et des comparateurs complexes peuvent être facilement construits puis utilisés dans la comparaison, le tri et d’autres opérations de conteneurs.

Essentiellement, une instance Ordering n'est rien de plus qu'une instance Comparator spéciale. La commande prend simplement une méthode qui dépend d'un comparateur (par exemple, Collections.max) et la rend disponible en tant que méthode d'instance. De plus, Ordering permet le cha?nage des appels de méthodes et l’amélioration des comparateurs existants.

Jetons un coup d'?il à quelques méthodes spécifiques et à des exemples d'utilisation simples dans Ordering.

Méthodes statiques courantes?:

natural()?: utilisez l'ordre naturel des types comparables, par exemple?: les entiers vont de petit à grand, les cha?nes sont dans l'ordre du dictionnaire

usingToString()?: utilise la cha?ne renvoyée par toString() pour la trier dans l'ordre du dictionnaire?;

　arbitrary()?: renvoie un ordre arbitraire de tous les objets, c'est-à-dire compare(a, b) == 0 est a == b (égalité d'identité). L'ordre lui-même n'a aucune signification, mais est une constante tout au long de la vie de la VM.

[code]import java.util.List;
import org.junit.Test;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;

public class OrderingTest {

    @Test
    public void testStaticOrdering(){
        List<String> list = Lists.newArrayList();
        list.add("peida");
        list.add("jerry");
        list.add("harry");
        list.add("eva");
        list.add("jhon");
        list.add("neron");

        System.out.println("list:"+ list);

        Ordering<String> naturalOrdering = Ordering.natural();        
        Ordering<Object> usingToStringOrdering = Ordering.usingToString();
        Ordering<Object> arbitraryOrdering = Ordering.arbitrary();

        System.out.println("naturalOrdering:"+ naturalOrdering.sortedCopy(list));     
        System.out.println("usingToStringOrdering:"+ usingToStringOrdering.sortedCopy(list));        
        System.out.println("arbitraryOrdering:"+ arbitraryOrdering.sortedCopy(list));
    }
}

[code]list:[peida, jerry, harry, eva, jhon, neron]
naturalOrdering:[eva, harry, jerry, jhon, neron, peida]
usingToStringOrdering:[eva, harry, jerry, jhon, neron, peida]
arbitraryOrdering:[neron, harry, eva, jerry, peida, jhon]

reverse()?: renvoie l'ordre inverse de la commande actuelle?:

nullsFirst()?: renvoie une commande qui place null avant les éléments non nuls, les autres identiques à le Ordering d'origine?;

nullsLast()?: renvoie un Ordering qui place null après l'élément non nul, et le reste est le même que le Ordering d'origine

?comparator?; Un tri utilisant Comparator, Comparator comme deuxième élément de tri, par exemple, triant la liste des bugs, d'abord selon le niveau du bug, puis selon la priorité

lexicographical()?: renvoie une liste itérée?; par éléments du dictionnaire Ordre;

onResultOf(Function): Après avoir appliqué la fonction à chaque élément, utilisez l'ordre d'origine pour le tri

GreatestOf(Iterable iterable, int k): Renvoie le kth spécifié; le plus grand élément de l'itérable, dans cet ordre du plus grand au plus petit. est instable.

lessOf(Iterable iterable,int k)?: renvoie le plus petit élément du k-ième itérable spécifié, du plus petit au plus grand. est instable.

isOrdered(Iterable) : Qu'il soit ordonné ou non, il ne peut pas contenir moins de 2 éléments.

isStrictlyOrdered(Iterable) : indique s'il est strictement ordonné. Notez qu'un Iterable ne peut pas avoir moins de deux éléments.

sortedCopy(Iterable)?: renvoie l'élément spécifié sous forme de copie triée de la liste.

[code]import java.util.List;

import org.junit.Test;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;

public class OrderingTest {

    @Test
    public void testOrdering(){
        List<String> list = Lists.newArrayList();
        list.add("peida");
        list.add("jerry");
        list.add("harry");
        list.add("eva");
        list.add("jhon");
        list.add("neron");

        System.out.println("list:"+ list);

        Ordering<String> naturalOrdering = Ordering.natural();
        System.out.println("naturalOrdering:"+ naturalOrdering.sortedCopy(list));    

        List<Integer> listReduce= Lists.newArrayList();
        for(int i=9;i>0;i--){
            listReduce.add(i);
        }

        List<Integer> listtest= Lists.newArrayList();
        listtest.add(1);
        listtest.add(1);
        listtest.add(1);
        listtest.add(2);

        Ordering<Integer> naturalIntReduceOrdering = Ordering.natural();

        System.out.println("listtest:"+ listtest);
        System.out.println(naturalIntReduceOrdering.isOrdered(listtest));
        System.out.println(naturalIntReduceOrdering.isStrictlyOrdered(listtest));

        System.out.println("naturalIntReduceOrdering:"+ naturalIntReduceOrdering.sortedCopy(listReduce));
        System.out.println("listReduce:"+ listReduce);

        System.out.println(naturalIntReduceOrdering.isOrdered(naturalIntReduceOrdering.sortedCopy(listReduce)));
        System.out.println(naturalIntReduceOrdering.isStrictlyOrdered(naturalIntReduceOrdering.sortedCopy(listReduce)));

        Ordering<String> natural = Ordering.natural();

        List<String> abc = ImmutableList.of("a", "b", "c");
        System.out.println(natural.isOrdered(abc));
        System.out.println(natural.isStrictlyOrdered(abc));

        System.out.println("isOrdered reverse :"+ natural.reverse().isOrdered(abc));

        List<String> cba = ImmutableList.of("c", "b", "a");
        System.out.println(natural.isOrdered(cba));
        System.out.println(natural.isStrictlyOrdered(cba));
        System.out.println(cba = natural.sortedCopy(cba));

        System.out.println("max:"+natural.max(cba));
        System.out.println("min:"+natural.min(cba));

        System.out.println("leastOf:"+natural.leastOf(cba, 2));
        System.out.println("naturalOrdering:"+ naturalOrdering.sortedCopy(list));    
        System.out.println("leastOf list:"+naturalOrdering.leastOf(list, 3));
        System.out.println("greatestOf:"+naturalOrdering.greatestOf(list, 3));
        System.out.println("reverse list :"+ naturalOrdering.reverse().sortedCopy(list));    
        System.out.println("isOrdered list :"+ naturalOrdering.isOrdered(list));
        System.out.println("isOrdered list :"+ naturalOrdering.reverse().isOrdered(list));
        list.add(null);
        System.out.println(" add null list:"+list);
        System.out.println("nullsFirst list :"+ naturalOrdering.nullsFirst().sortedCopy(list));
        System.out.println("nullsLast list :"+ naturalOrdering.nullsLast().sortedCopy(list));
    }

}

//============輸出==============
list:[peida, jerry, harry, eva, jhon, neron]
naturalOrdering:[eva, harry, jerry, jhon, neron, peida]
listtest:[1, 1, 1, 2]
true
false
naturalIntReduceOrdering:[1, 2, 3, 4, 5, 6, 7, 8, 9]
listReduce:[9, 8, 7, 6, 5, 4, 3, 2, 1]
true
true
true
true
isOrdered reverse :false
false
false
[a, b, c]
max:c
min:a
leastOf:[a, b]
naturalOrdering:[eva, harry, jerry, jhon, neron, peida]
leastOf list:[eva, harry, jerry]
greatestOf:[peida, neron, jhon]
reverse list :[peida, neron, jhon, jerry, harry, eva]
isOrdered list :false
isOrdered list :false
 add null list:[peida, jerry, harry, eva, jhon, neron, null]
nullsFirst list :[null, eva, harry, jerry, jhon, neron, peida]
nullsLast list :[eva, harry, jerry, jhon, neron, peida, null]

Ce qui précède est le contenu de Java-Class Library-Guava-Ordering Comparator. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.miracleart.cn)?!