Comparable接口和Comparator接口
目录
- 前言
- `Comparable` 接口
-
- `Comparable` 接口使用场景
- `Comparable` 接口源码
- 实现 `Comparable` 接口示例
- `Comparator` 接口
-
- `Comparator` 接口使用场景
- `Comparator` 接口源码
- 实现 `Comparator` 接口示例
- `Comparable` 接口与 `Comparator` 接口对比
-
- `Comparable` 接口
- `Comparator` 接口
前言
在实际应用中，我们往往有需要 比较两个自定义对象 大小的地方。而这些自定义对象的比较，就不像简单的整型数据那么简单，它们往往包含有许多的属性，我们一般都是根据这些属性对自定义对象进行比较的。所以 Java 中要 比较对象的大小 或者要 对对象的集合 进行排序，需要通过比较这些对象的某些属性的大小来确定它们之间的大小关系
一般 Java 中通过接口来实现两个对象的比较，比较常用就是 Comparable 接口和Comparator 接口
Comparable 接口
Comparable 接口使用场景
- 一个类实现了
Comparable接口，就意味着该类支持排序，如果存在实现Comparable接口的类的List集合或Array数组，则该List集合或Array数组可以通过Collections.sort或Arrays.sort来进行排序 - 一个类实现了
Comparable接口，就意味着该类支持两个对象比较大小
Comparable 接口源码
public interface Comparable<T> {
public int compareTo(T o);
}
Comparable可以让实现它的类的对象进行比较，具体的比较规则是按照compareT()o方法中的规则进行的，该方法的返回值有三种情况e1.compareTo(e2) > 0即e1 > e2e1.compareTo(e2) = 0即e1 = e2e1.compareTo(e2) < 0即e1 < e2
实现 Comparable 接口示例
- 自定义类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ConsumInfo implements Comparable<ConsumInfo> {
private int uid;
private double price;
@Override
public int compareTo(@NotNull ConsumInfo o) {
if (price < o.price) {
return -1;
} else if (price > o.price) {
return 1;
} else {
return 0;
}
}
}
- 测试类：这里以对象的集合进行排序为例，当然也可以进行两个对象的大小比较
@Slf4j
public class ComparableTest {
public static void main(String[] args) {
ConsumInfo consumInfo1 = new ConsumInfo(100, 400.0);
ConsumInfo consumInfo2 = new ConsumInfo(200, 200.0);
ConsumInfo consumInfo3 = new ConsumInfo(300, 100.0);
ConsumInfo consumInfo4 = new ConsumInfo(400, 700.0);
ConsumInfo consumInfo5 = new ConsumInfo(500, 800.0);
ConsumInfo consumInfo6 = new ConsumInfo(600, 300.0);
ConsumInfo consumInfo7 = new ConsumInfo(700, 900.0);
ConsumInfo consumInfo8 = new ConsumInfo(800, 400.0);
List<ConsumInfo> list = new ArrayList<>();
list.add(consumInfo1);
list.add(consumInfo2);
list.add(consumInfo3);
list.add(consumInfo4);
list.add(consumInfo5);
list.add(consumInfo6);
list.add(consumInfo7);
list.add(consumInfo8);
log.info("排序前：------");
for (ConsumInfo consumInfo : list) {
log.info("consumInfo为：" + consumInfo);
}
// 排序
Collections.sort(list);
log.info("排序后：------");
for (ConsumInfo consumInfo : list) {
log.info("consumInfo为：" + consumInfo);
}
}
}
- 结果
00:16:09.316 [main] INFO org.example.test.ComparableTest - 排序前：------
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=100, price=400.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=200, price=200.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=300, price=100.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=400, price=700.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=500, price=800.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=600, price=300.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=700, price=900.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=800, price=400.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - 排序后：------
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=300, price=100.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=200, price=200.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=600, price=300.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=100, price=400.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=800, price=400.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=400, price=700.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=500, price=800.0)
00:16:09.332 [main] INFO org.example.test.ComparableTest - consumInfo为：ConsumInfo(uid=700, price=900.0)
Comparator 接口
Comparator 接口使用场景
- 如果需要对某个
类的集合进行排序或类对象比较大小，而该类本身又不能实现Comparable接口；那么，这时只需要实现Comparator接口即可
Comparator 接口源码
public interface Comparator<T> {
int compare(T o1, T o2);
boolean equals(Object obj);
default Comparator<T> reversed() {
return Collections.reverseOrder(this);
}
default Comparator<T> thenComparing(Comparator<? super T> other) {
Objects.requireNonNull(other);
return (Comparator<T> & Serializable) (c1, c2) -> {
int res = compare(c1, c2);
return (res != 0) ? res : other.compare(c1, c2);
};
}
default <U> Comparator<T> thenComparing(
Function<? super T, ? extends U> keyExtractor,
Comparator<? super U> keyComparator)
{
return thenComparing(comparing(keyExtractor, keyComparator));
}
default <U extends Comparable<? super U>> Comparator<T> thenComparing(
Function<? super T, ? extends U> keyExtractor)
{
return thenComparing(comparing(keyExtractor));
}
default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
return thenComparing(comparingInt(keyExtractor));
}
default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
return thenComparing(comparingLong(keyExtractor));
}
default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
return thenComparing(comparingDouble(keyExtractor));
}
public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
return Collections.reverseOrder();
}
public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
}
public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
return new Comparators.NullComparator<>(true, comparator);
}
public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
return new Comparators.NullComparator<>(false, comparator);
}
public static <T, U> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor,
Comparator<? super U> keyComparator)
{
Objects.requireNonNull(keyExtractor);
Objects.requireNonNull(keyComparator);
return (Comparator<T> & Serializable)
(c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
keyExtractor.apply(c2));
}
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor)
{
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}
public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
}
public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
}
public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
}
}
实现 Comparator 接口示例
- 自定义类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ConsumInfo implements Comparable<ConsumInfo> {
private int uid;
private double price;
@Override
public int compareTo(@NotNull ConsumInfo o) {
// 首先比较price，如果price相同，则比较uid
if (price < o.price) {
return -1;
} else if (price > o.price) {
return 1;
} else {
return 0;
}
}
}
- 具体的比较类（比较器），实现
Comparator接口
public class ComparatorConsumInfo implements Comparator<ConsumInfo> {
@Override
public int compare(ConsumInfo o1, ConsumInfo o2) {
// 首先比较price，如果price相同，则比较uid
if (o1.getPrice() > o2.getPrice()) {
return 1;
}
if (o1.getPrice() < o2.getPrice()) {
return -1;
}
if (o1.getPrice() == o2.getPrice()) {
if (o1.getUid() > o2.getUid()) {
return 1;
}
if (o1.getUid() < o2.getUid()) {
return -1;
}
}
return 0;
}
}
- 测试类：这里以对象的集合进行排序为例，当然也可以进行两个对象的大小比较
@Slf4j
public class ComparatorTest {
public static void main(String[] args) {
ConsumInfo consumInfo1 = new ConsumInfo(100, 400.0);
ConsumInfo consumInfo2 = new ConsumInfo(200, 200.0);
ConsumInfo consumInfo3 = new ConsumInfo(300, 100.0);
ConsumInfo consumInfo4 = new ConsumInfo(400, 700.0);
ConsumInfo consumInfo5 = new ConsumInfo(500, 800.0);
ConsumInfo consumInfo6 = new ConsumInfo(600, 300.0);
ConsumInfo consumInfo7 = new ConsumInfo(700, 900.0);
ConsumInfo consumInfo8 = new ConsumInfo(800, 400.0);
List<ConsumInfo> list = new ArrayList<>();
list.add(consumInfo1);
list.add(consumInfo2);
list.add(consumInfo3);
list.add(consumInfo4);
list.add(consumInfo5);
list.add(consumInfo6);
list.add(consumInfo7);
list.add(consumInfo8);
log.info("排序前：------");
for (ConsumInfo consumInfo : list) {
log.info("consumInfo为：" + consumInfo);
}
ComparatorConsumInfo comparatorConsumInfo = new ComparatorConsumInfo();
Collections.sort(list, comparatorConsumInfo);
log.info("排序后：------");
for (ConsumInfo consumInfo : list) {
log.info("consumInfo为：" + consumInfo);
}
}
}
- 结果：如下图
Comparable 接口与 Comparator 接口对比
Comparable 接口
Comparable位于包java.lang下Comparable接口将比较代码嵌入需要进行比较的类的自身中Comparable接口强制进行自然排序
Comparator 接口
Comparator位于包java.util下Comparator接口在一个独立的类中实现比较，排序- 如果前期没有实现
Comparable接口，后期可以通过Comparator接口来实现比较算法进行排序 Comparator接口不强制进行自然排序，可以指定排序顺序，比如：升序、降序