java 如何比对一个类中的静态变量的值

转载

mob6454cc67e023 2024-09-13 21:37:09

文章标签 对象的比较 System java ide 文章分类 Java 后端开发

本篇博客介绍一下Java中对象的比较。

==和equals

我们知道Java中，对于引用类型来说，==比较的是两个对象的身份，使用equals才能比较两个对象的值。

public class Test {
    public static void main(String[] args) {
        String str1 = new String("hello, world!");
        String str2 = new String("hello, world!");

        System.out.println("str1 == str2: " + (str1 == str2));
        System.out.println("str1.equals(str2): " + str1.equals(str2));
    }
}

java 如何比对一个类中的静态变量的值_java

我们定义一个自定义类型，我们使用equals进行比较来观察一下：

class Fruit {
    public String name;
    public int price;

    public Fruit(String name, int price) {
        this.name = name;
        this.price = price;
    }
}

public class Test {
    public static void main(String[] args) {
        Fruit apple1 = new Fruit("apple", 10);
        Fruit apple2 = new Fruit("apple", 10);

        System.out.println("apple1 == apple2: " + (apple1 == apple2));
        System.out.println("apple1.equals(apple2): " + apple1.equals(apple2));
    }
}

java 如何比对一个类中的静态变量的值_java_02

可以看到，这里的==和equals结果都是false，不是说equals比较的是指，而apple1和apple2的值是相同的，为什么这里返回的还是false。

这是因为equals方法是Object的方法，equals默认的比较方式就是对象身份的比较。

java 如何比对一个类中的静态变量的值_java_03

如果我们想要实现值的比较，我们需要去覆写该方法：

public class Test {
    public static void main(String[] args) {
        Fruit apple1 = new Fruit("apple", 10);
        Fruit apple2 = new Fruit("apple", 10);

        System.out.println("apple1 == apple2: " + (apple1 == apple2));
        System.out.println("apple1.equals(apple2): " + apple1.equals(apple2));
    }
}

class Fruit {
    public String name;
    public int price;

    public Fruit(String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public boolean equals(Object o) {
        // 是同一个对象
        if (this == o) {
            return true;
        }

        // o为空或者o不是Fruit的实例
        if (o == null || !(o instanceof Fruit)) {
            return false;
        }

        Fruit fruit = (Fruit)o;
        return this.name.equals(fruit.name) && this.price == fruit.price;
    }
}

java 如何比对一个类中的静态变量的值_java_04

一般覆写equals的步骤大致如下：

如果两个引用指向同一个对象，返回true；
如果传入的引用为null，返回false；
如果传入的对象不是目标类型的实例，返回false；
按照类的实现目标完成比较。

Comparable和Comparator

Comparable和Comparator都是用于比较数据的大小的，实现Comparable接口需要重写compareTo方法，实现Comparator需要重写compare方法，这两个方法的返回值都是int，用int类型的值来确定比较结果。

我们来看一下Collections工具类中的两个sort方法，来简单理解一下二者的区别：

java 如何比对一个类中的静态变量的值_java_05

两个sort方法，一个是只需要传入集合，但是要求集合中的元素实现了Comparable接口；另一个不仅要传入一个集合，还需要传入一个Comparator对象，这里集合中的元素不需要实现Comparable接口。

所以，我们可以大概能够想到二者的使用场景：

一个类在设计之初就有排序的需求，我们就可以选择实现Comparable接口；
如果是一个类在后期需要扩展或增加排序需求时，我们可以增加一个比较器Comparator。

Comparable

我们来看一下使用Comparable实现水果按价钱排序：

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        Fruit[] fruits = {
                new Fruit("peach", 30),
                new Fruit("apple", 10),
                new Fruit("banana", 50),
                new Fruit("pear", 20),
                new Fruit("berry", 40)
        };

        List<Fruit> fruitList = Arrays.asList(fruits);

        System.out.println(fruitList);
        Collections.sort(fruitList);
        System.out.println(fruitList);
    }
}

class Fruit implements Comparable<Fruit> {
    public String name;
    public int price;

    public Fruit(String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public int compareTo(Fruit o) {
        return this.price - o.price;
    }

    @Override
    public String toString() {
        return "(" + this.name +
                ":" + this.price + ")";
    }
}

java 如何比对一个类中的静态变量的值_ide_06

Comparator

我们来看一下使用Comparator实现水果按价钱排序：

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        Fruit[] fruits = {
                new Fruit("peach", 30),
                new Fruit("apple", 10),
                new Fruit("banana", 50),
                new Fruit("pear", 20),
                new Fruit("berry", 40)
        };

        List<Fruit> fruitList = Arrays.asList(fruits);

        System.out.println(fruitList);
        Collections.sort(fruitList, new FruitComparator());
        System.out.println(fruitList);
    }
}

class Fruit {
    public String name;
    public int price;

    public Fruit(String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "(" + this.name +
                ":" + this.price + ")";
    }
}

class FruitComparator implements Comparator<Fruit> {
    @Override
    public int compare(Fruit o1, Fruit o2) {
        return o1.price - o2.price;
    }
}

java 如何比对一个类中的静态变量的值_对象的比较_07

我们还有一种更简单的写法，如下：

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        Fruit[] fruits = {
                new Fruit("peach", 30),
                new Fruit("apple", 10),
                new Fruit("banana", 50),
                new Fruit("pear", 20),
                new Fruit("berry", 40)
        };

        List<Fruit> fruitList = Arrays.asList(fruits);

        System.out.println(fruitList);
        Collections.sort(fruitList, new Comparator<Fruit>() {
            @Override
            public int compare(Fruit o1, Fruit o2) {
                return o1.price - o2.price;
            }
        });
        System.out.println(fruitList);
    }
}

class Fruit {
    public String name;
    public int price;

    public Fruit(String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "(" + this.name +
                ":" + this.price + ")";
    }
}

java 如何比对一个类中的静态变量的值_对象的比较_08