public static <T> Ordering<T> from(Comparator<T> comparator) {
    return (Ordering)(comparator instanceof Ordering?(Ordering)comparator:new ComparatorOrdering(comparator));
}

Ordering.from(new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
})

//Ordering.java
public static <C extends Comparable> Ordering<C> natural() {
    return NaturalOrdering.INSTANCE;
}
 
//NaturalOrdering.java
final class NaturalOrdering extends Ordering<Comparable> implements Serializable {
    static final NaturalOrdering INSTANCE = new NaturalOrdering();
    private transient Ordering<Comparable> nullsFirst;
    private transient Ordering<Comparable> nullsLast;
    private static final long serialVersionUID = 0L;

    public int compare(Comparable left, Comparable right) {
        Preconditions.checkNotNull(left);
        Preconditions.checkNotNull(right);
        return left.compareTo(right);
    }
	......
}

List<String> list = Ordering.natural().nullsFirst().sortedCopy(Lists.<String>newArrayList("1", "afc", "aed"));
System.out.println(list);//输出[1, aed, afc]

public int compare(Object left, Object right) {
    return left.toString().compareTo(right.toString());
}

List<Integer> list = Ordering.usingToString().sortedCopy(Lists.newArrayList(1, 12, 112, 23));
System.out.println(list);
//输出
[1, 112, 12, 23]

public int compare(@Nullable Object left, @Nullable Object right) {
    return 0;
}

List<Integer> list = Ordering.allEqual().nullsLast().sortedCopy(Lists.newArrayList(1, 12, null, 112, 23));
System.out.println(list);
//输出
[1, 12, 112, 23, null]

static class ArbitraryOrdering extends Ordering<Object> {
    private final AtomicInteger counter = new AtomicInteger(0);
    private final ConcurrentMap<Object, Integer> uids = Platform.tryWeakKeys(new MapMaker()).makeMap();

    ArbitraryOrdering() {
    }

    private Integer getUid(Object obj) {
        Integer uid = (Integer)this.uids.get(obj);
        if(uid == null) {
            uid = Integer.valueOf(this.counter.getAndIncrement());
            Integer alreadySet = (Integer)this.uids.putIfAbsent(obj, uid);
            if(alreadySet != null) {
                uid = alreadySet;
            }
        }

        return uid;
    }

    public int compare(Object left, Object right) {
        if(left == right) {
            return 0;
        } else if(left == null) {
            return -1;
        } else if(right == null) {
            return 1;
        } else {
            int leftCode = this.identityHashCode(left);
            int rightCode = this.identityHashCode(right);
            if(leftCode != rightCode) {
                return leftCode < rightCode?-1:1;
            } else {
                int result = this.getUid(left).compareTo(this.getUid(right));
                if(result == 0) {
                    throw new AssertionError();
                } else {
                    return result;
                }
            }
        }
    }

    public String toString() {
        return "Ordering.arbitrary()";
    }

    int identityHashCode(Object object) {
        return System.identityHashCode(object);
    }
}

final class ExplicitOrdering<T> extends Ordering<T> implements Serializable {
    final ImmutableMap<T, Integer> rankMap;
    private static final long serialVersionUID = 0L;

    ExplicitOrdering(List<T> valuesInOrder) {
        this(Maps.indexMap(valuesInOrder));
    }

    ExplicitOrdering(ImmutableMap<T, Integer> rankMap) {
        this.rankMap = rankMap;
    }

    public int compare(T left, T right) {
        return this.rank(left) - this.rank(right);
    }

    private int rank(T value) {
        Integer rank = (Integer)this.rankMap.get(value);
        if(rank == null) {
            throw new IncomparableValueException(value);
        } else {
            return rank.intValue();
        }
    }

    public boolean equals(@Nullable Object object) {
        if(object instanceof ExplicitOrdering) {
            ExplicitOrdering that = (ExplicitOrdering)object;
            return this.rankMap.equals(that.rankMap);
        } else {
            return false;
        }
    }

    public int hashCode() {
        return this.rankMap.hashCode();
    }

    public String toString() {
        return "Ordering.explicit(" + this.rankMap.keySet() + ")";
    }
}

//有序的id
List<Integer> orderedList = Arrays.asList(23, 1, 12, 112);
//无序的model
List<Record> nonOrderedList = Lists.newArrayList(new Record(1), new Record(12), new Record(23), new Record(112));
//排序
List<Record> list = Ordering.explicit(orderedList)
        .onResultOf(new Function<Record, Integer>() {
            @Nullable
            @Override
            public Integer apply(@Nullable Record record) {
                return record.getId();
            }
        }).sortedCopy(nonOrderedList);
System.out.println(list);//输出[[id:23], [id:1], [id:12], [id:112]]

public int compare(T left, T right) {
    int size = this.comparators.size();

    for(int i = 0; i < size; ++i) {
        int result = ((Comparator)this.comparators.get(i)).compare(left, right);
		//不相等就直接返回，不进行后面的比较
        if(result != 0) {
            return result;
        }
    }

    return 0;
}

Comparator<Record> comparator1 = new Comparator<Record>() {
    @Override
    public int compare(Record o1, Record o2) {
        return o1.getScore().compareTo(o2.getScore());
    }
};
Comparator<Record> comparator2 = new Comparator<Record>() {
    @Override
    public int compare(Record o1, Record o2) {
        return o1.getDistance().compareTo(o2.getDistance());
    }
};
List<Record> nonOrderedList = Lists.newArrayList(new Record(2, 1.0), new Record(2, 100.0), new Record(1, 130.0), new Record(3, 1.0));
List<Record> list = Ordering.compound(Arrays.asList(comparator1, comparator2)).sortedCopy(nonOrderedList);
System.out.println(list);//输出[Record{id=0, score=1, distance=130.0}, Record{id=0, score=2, distance=1.0}, Record{id=0, score=2, distance=100.0}, Record{id=0, score=3, distance=1.0}]

public int compare(T a, T b) {
    return this.forwardOrder.compare(b, a);
}

List<Integer> nonOrderedList = Arrays.asList(1,4,2,6,9);
List<Integer> list = Ordering.natural().reverse().sortedCopy(nonOrderedList);
System.out.println(list);
//输出
[9, 6, 4, 2, 1]

public int compare(@Nullable T left, @Nullable T right) {
    return left == right?0:(left == null?-1:(right == null?1:this.ordering.compare(left, right)));
}public int compare(@Nullable T left, @Nullable T right) {
 return left == right?0:(left == null?1:(right == null?-1:this.ordering.compare(left, right)));
}

List<Integer> nonOrderedList = Arrays.asList(1, 4, 2, 6, 9, null);
List<Integer> list = Ordering.natural().nullsFirst().sortedCopy(nonOrderedList);
System.out.println(list);
 
//输出
[null, 1, 2, 4, 6, 9]

final Function<F, ? extends T> function;
final Ordering<T> ordering;
private static final long serialVersionUID = 0L;

ByFunctionOrdering(Function<F, ? extends T> function, Ordering<T> ordering) {
    this.function = (Function)Preconditions.checkNotNull(function);
    this.ordering = (Ordering)Preconditions.checkNotNull(ordering);
}
public int compare(F left, F right) {
    return this.ordering.compare(this.function.apply(left), this.function.apply(right));
}

List<Record> nonOrderedList = Lists.newArrayList(new Record(2, 1.0), new Record(2, 100.0), new Record(1, 130.0), new Record(3, 1.0));
List<Record> list = Ordering.natural().onResultOf(new Function<Record, Integer>() {
    @Nullable
    @Override
    public Integer apply(@Nullable Record record) {
        return record.getScore();
    }
}).sortedCopy(nonOrderedList);
System.out.println(list);
 
//输出
[Record{id=0, score=1, distance=130.0}, Record{id=0, score=2, distance=1.0}, Record{id=0, score=2, distance=100.0}, Record{id=0, score=3, distance=1.0}]

public <U extends T> Ordering<U> compound(Comparator<? super U> secondaryComparator) {
    return new CompoundOrdering(this, (Comparator)Preconditions.checkNotNull(secondaryComparator));
}
 
 
CompoundOrdering(Comparator<? super T> primary, Comparator<? super T> secondary) {
    this.comparators = ImmutableList.of(primary, secondary);
}

CompoundOrdering(Iterable<? extends Comparator<? super T>> comparators) {
    this.comparators = ImmutableList.copyOf(comparators);
}

List<Record> nonOrderedList = Lists.newArrayList(new Record(2, 200.0), new Record(2, 100.0), new Record(1, 130.0), new Record(2, 1.0));
Comparator<Record> comparator2 = new Comparator<Record>() {
    @Override
    public int compare(Record o1, Record o2) {
        return o1.getDistance().compareTo(o2.getDistance());
    }
};
List<Record> list = Ordering.natural().compound(comparator2).sortedCopy(nonOrderedList);
System.out.println(list);//Record.compareTo只比较了score//输出[Record{id=0, score=1, distance=130.0}, Record{id=0, score=2, distance=1.0}, Record{id=0, score=2, distance=100.0}, Record{id=0, score=2, distance=200.0}]

public boolean isOrdered(Iterable<? extends T> iterable) {
    Iterator it = iterable.iterator();
    Object next;
    if(it.hasNext()) {
        for(Object prev = it.next(); it.hasNext(); prev = next) {
            next = it.next();
            if(this.compare(prev, next) > 0) {
                return false;
            }
        }
    }

    return true;
}

public boolean isStrictlyOrdered(Iterable<? extends T> iterable) {
    Iterator it = iterable.iterator();
    Object next;
    if(it.hasNext()) {
        for(Object prev = it.next(); it.hasNext(); prev = next) {
            next = it.next();
            if(this.compare(prev, next) >= 0) {
                return false;
            }
        }
    }

    return true;
}