我们知道基本数据类型的数据（除boolean类型外）需要比较大小的话，之间使用比较运算符即可，但是引用数据类型是不能直接使用比较运算符来比较大小的。那么，如何解决这个问题呢？
我们一直比较的都是基本数据类型的比较用==或equals()的方式来比较,但是如果要比较引用数据类型需要什么方法呢,不能比较地址值吧?所以今天学习了java比较器来实现引用数据类型的比较
为了更好的理解放出一个图片仅供参考:
我们可以把这是四商品理解成为四个对象,他们的排序和比较方式
- 在Java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题。
- Java实现对象排序的方式有两种：
- 自然排序：java.lang.Comparable
- 定制排序：java.util.Comparator
1.自然排序：java.lang.Comparable
- Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。
- 实现 Comparable 的类必须实现
compareTo(Object obj)方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。如果当前对象this大于形参对象obj，则返回正整数，如果当前对象this小于形参对象obj，则返回负整数，如果当前对象this等于形参对象obj，则返回零。
```java
package java.lang;
public interface Comparable{
int compareTo(Object obj);
}
- 实现Comparable接口的对象列表（和数组）可以通过 Collections.sort 或 Arrays.sort进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
- 对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2) == 0 与 e1.equals(e2) 具有相同的 boolean 值时，类 C 的自然排序才叫做与 equals 一致。建议（虽然不是必需的）
最好使自然排序与 equals 一致。 - Comparable 的典型实现：(
默认都是从小到大排列的)- String：按照字符串中字符的Unicode值进行比较
- Character：按照字符的Unicode值来进行比较
- 数值类型对应的包装类以及BigInteger、BigDecimal：按照它们对应的数值大小进行比较
- Boolean：true 对应的包装类实例大于 false 对应的包装类实例
- Date、Time等：后面的日期时间比前面的日期时间大
1.1简单示例
1.自己创建一个类,实现接口Comparable重写Comparable中的compareTo(Object o)方法
这里重写的方法里面的内容是自己怎么实现他们的排序和比较,比如:是用他们的价格还是他们的名称还是都使用,这个自己定义
package com.huige04.compare比较器;
/**
* @author shkstart
* @create 11:45
*/
public class Product implements Comparable{ //商品类
private String name;//商品名称
private double price;//价格
public Product(String name, double price) {
this.name = name;
this.price = price;
}
public Product() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Product{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
/**
* 当前的类需要实现Comparable中的抽象方法:compareTo(Object o)
* 在此方法中,指明如何判断当前类的对象的大小。比如:按照价格的高低进行大小的比较。(价格从低到高排序)
*
* 如果返回值是正数:当前对象大。
* 如果返回值是负数:当前对象小。
* 如果返回值是0：一样大。
* @param o the object to be compared.
* @return
*/
// @Override
// public int compareTo(Object o) {
// if (o == this) {
// return 0;
// }
//
// if (o instanceof Product) {
// Product p = (Product) o;
//
// return Double.compare(this.price, p.price);
// }
//
// //手动抛出一个异常类的对象
// throw new RuntimeException("类型不匹配");
// }
//比较的标准:先比较价格,价格相同,进行名字的比较(从小到大)
@Override
public int compareTo(Object o) {
if (o == this) {
return 0;
}
if (o instanceof Product) {
Product p = (Product) o;
int value = Double.compare(this.price, p.price);
if (value != 0) {
return value;
}
return this.name.compareTo(p.name);
}
//手动抛出一个异常类的对象
throw new RuntimeException("类型不匹配");
}
}
2.测试类
创建自定义类的实例对象,使用Arrays.sort(xxx)方法进行排序
package com.huige04.compare比较器.comparable;
import com.huige04.compare比较器.Product;
import org.junit.Test;
import java.util.Arrays;
/**
* ClassName: ComparableTest
* Package: com.huige04.compare比较器.comparable
* Description:
*
* @Author 朱志辉
* @Create 2023/9/27 21:16
* @Version 1.0
*/
public class ComparableTest {
@Test
public void test1(){
String[] arr = new String[]{"Tom", "Jerry", "Tony", "Rose", "Jack", "Lucy"};
//排序方法
Arrays.sort(arr);
//排序完以后,遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
@Test
public void test2(){
Product[] arr = new Product[5];
arr[0] = new Product("HuaweiMate60pro", 6999);
arr[1] = new Product("Xiaomi13Pro", 4999);
arr[2] = new Product("VivoX99", 5999);
arr[3] = new Product("Iphone15Pro", 9999);
arr[4] = new Product("OPPO", 6399);
Arrays.sort(arr);
//排序完以后,遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
如果需要比较对象的大小,在自定义类中重写CompareTo(Object o)如下:
- 当前的类需要实现Comparable中的抽象方法:compareTo(Object o)
在此方法中,指明如何判断当前类的对象的大小。比如:按照价格的高低进行大小的比较。(价格从低到高排序)
如果返回值是正数:当前对象大。
如果返回值是负数:当前对象小。
如果返回值是0：一样大。
//比较的标准:先比较价格,价格相同,进行名字的比较(从小到大)
@Override
public int compareTo(Object o) {
if (o == this) {
return 0;
}
if (o instanceof Product) {
Product p = (Product) o;
int value = Double.compare(this.price, p.price);
if (value != 0) {
return value;
}
return this.name.compareTo(p.name);
}
//手动抛出一个异常类的对象
throw new RuntimeException("类型不匹配");
}
@Test
public void test3(){
Product p1 = new Product("HuaweiMate60pro", 6999);
Product p2 = new Product("Xiaomi13Pro", 4999);
int comapre = p1.compareTo(p2);
if (comapre > 0) {
System.out.println("p1大");
} else if (comapre < 0) {
System.out.println("p2大");
} else {
System.out.println("p1和p2一样大");
}
}
2.定制排序：java.util.Comparator
- 思考
- 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码（例如：一些第三方的类，你只有.class文件，没有源文件）
- 如果一个类，实现了Comparable接口，也指定了两个对象的比较大小的规则，但是此时此刻我不想按照它预定义的方法比较大小，但是我又不能随意修改，因为会影响其他地方的使用，怎么办？
- JDK在设计类库之初，也考虑到这种情况，所以又增加了一个java.util.Comparator接口。强行对多个对象进行整体排序的比较。
- 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
- 可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。
可理解为可插拔式排序
2.1简单示例
代码如下:
这个是自定义的类,虽然这个类实现了Comparable接口也重写了方法
但是Comparator可以直接在 Arrays.sort(arr, comparator);中用Comparator重写的方法,同时也不影响Comparable的使用
package com.huige04.compare比较器;
/**
* @author shkstart
* @create 11:45
*/
public class Product implements Comparable{ //商品类
private String name;//商品名称
private double price;//价格
public Product(String name, double price) {
this.name = name;
this.price = price;
}
public Product() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Product{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
//比较的标准:先比较价格(从大到小),价格相同,进行名字的比较(从小到大)
@Override
public int compareTo(Object o) {
if (o == this) {
return 0;
}
if (o instanceof Product) {
Product p = (Product) o;
int value = Double.compare(this.price, p.price);
if (value != 0) {
return -value;
}
return this.name.compareTo(p.name);
}
//手动抛出一个异常类的对象
throw new RuntimeException("类型不匹配");
}
}
测试类
import org.junit.Test;
import java.util.Arrays;
import java.util.Comparator;
/**
* ClassName: ComparatorTest
* Package: com.huige04.compare比较器.comparator
* Description:
*
* @Author 朱志辉
* @Create 2023/9/28 13:36
* @Version 1.0
*/
public class ComparatorTest {
@Test
public void test1(){
Product[] arr = new Product[5];
arr[0] = new Product("HuaweiMate60pro", 6999);
arr[1] = new Product("Xiaomi13Pro", 4999);
arr[2] = new Product("VivoX99", 5999);
arr[3] = new Product("Iphone15Pro", 9999);
arr[4] = new Product("OPPO", 6399);
//创建一个实现了Comparator接口的实现类的对象
Comparator comparator = new Comparator() {
//如何判断两个对象o1,o2的大小,其标准就是此方法的方法体要编写的逻辑
//比如:按照价格从低到高
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Product && o2 instanceof Product) {
Product p1 = (Product) o1;
Product p2 = (Product) o2;
return Double.compare(p1.getPrice(), p2.getPrice());
}
throw new RuntimeException("类型不匹配");
}
};
Arrays.sort(arr, comparator);
//排序完以后,遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
同时也可以直接在Arrays.sort()方法内部实现一个匿名的Comparator的实例代码我们用String为例代码如下:
@Test
public void test2() {
String[] arr = new String[]{"Tom", "Jerry", "Tony", "Rose", "Jack", "Lucy"};
//排序方法
Arrays.sort(arr, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
if (o1 instanceof String && o2 instanceof String) {
String s1 =(String) o1;
String s2 = (String) o2;
return -s1.compareTo(s2);
}
throw new RuntimeException("类型不匹配");
}
});
//排序完以后,遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
3.总结
1.实现对象的排序，可以考虑两种方法：自然排序、定制排序
方式一：实现Comparable接口的方式 实现步骤： ①具体的类A需要实现Comparable接口 ②重写Comparable接口中的compareTo(Object o)方法,在此方法中指明比较类A的对象的大小标准
③创建类A的多个实例对象,进行大小的比较或者排序方式二：实现Comparator接口的方式 实现步骤： ①创建一个实现了Comparator接口的实现类A ②实现类A要求重写Comparator接口中的抽象方法compare(Object o1,Object o2),在此方法中指明要
比较大小的对象的大小关系,(比如说:String类、Product类)
③创建此实现类A的对象,并将此对象传入到相关此方法的参数位置即可,(比如:Arrays.sort(…,类A的实例)😉对比两种方式： 角度一:
自然排序:单一的,唯一的
定制排序:灵活的,多样的角度二:
自然排序:一劳永逸的
定制排序:临时的角度三:细节
自然排序:对应的接口是Comparable,对应的抽象方法是compareTo(Object o)
定制排序:对应的接口是Comparator,对应的抽象方法是compare(Object o1,Object o2)
注:以上内容都是自己在网上找的课程,然后总结便于以后得学习所记录和分享的,未经过允许不能转载
2224
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
