Java-Class Library-Guava-Ordering Comparator-javaTutorial-php.cn

Ordering is a sharp and powerful comparator tool provided by the Guava class library. Guava's Ordering is more powerful than JDK Comparator. It is very easy to extend, and complex comparators can be easily constructed and then used in container comparison, sorting and other operations.

Essentially, an Ordering instance is nothing more than a special Comparator instance. Ordering simply takes a method that depends on a comparator (for example, Collections.max) and makes it available as an instance method. In addition, Ordering provides chaining of method calls and enhancement of existing comparators.

Let’s take a look at some specific methods and simple usage examples in Ordering.

Common static methods:

natural(): Use the natural order of the Comparable type, for example: integers are from small to large, and strings are in dictionary order;

usingToString( ): Use the string returned by toString() to sort it in dictionary order;

arbitrary(): Return an arbitrary order of all objects, that is, compare(a, b) == 0 is a == b ( identity equality). The ordering itself has no meaning, but is a constant during the lifetime of the 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));
    }
}

Copy after login

[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]

Copy after login

reverse(): Returns the reverse ordering of the current Ordering:

nullsFirst(): Returns an Ordering that places null before non-null elements, and the rest is the same as the original Ordering ;

NullsLast(): Returns an Ordering that places null after the non-null element, and the rest is the same as the original Ordering;

compound(Comparator): Returns an Ordering using Comparator , Comparator as the second sorting element, for example, sorting the bug list, first according to the level of the bug, and then according to the priority;

lexicographical(): Returns an Ordering iterated according to the dictionary elements;

　onResultOf(Function): After applying function to each element, sort using original ordering;

greatestOf(Iterable iterable, int k): Returns the largest of the specified k-th iterable Elements, in this order from largest to smallest. is unstable.

leastOf(Iterable iterable,int k): Returns the smallest element of the specified k-th iterable, in order from smallest to largest. is unstable.

isOrdered(Iterable): Whether it is ordered, Iterable cannot be less than 2 elements.

　isStrictlyOrdered(Iterable): Whether it is strictly ordered. Note that an Iterable cannot have less than two elements.

sortedCopy(Iterable): Returns the specified element as a sorted copy of the list.

[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]

Copy after login

The above is the content of Java-Class Library-Guava-Ordering Comparator. For more related content, please pay attention to the PHP Chinese website (m.sbmmt.com)!