深入浅出讲解Java比较器及数学常用类

Java比较器

Java中的比较器是用于比较两个对象的大小关系的接口，它定义了一个compare()方法用于比较大小。常用于排序、查找等场景中。

自然排序

自然排序是Java中默认的排序方式，即根据对象所属类型的大小关系进行排序。例如，整数类型按照数值大小进行排序，字符串类型按照字典序进行排序。

public class Person implements Comparable<Person> {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public int compareTo(Person o) {
        return this.name.compareTo(o.getName());
    }
}

// 使用自然排序对Person对象数组进行排序
Person[] persons = new Person[] { new Person("Tom"), new Person("Jerry"), new Person("Alice") };
Arrays.sort(persons);
System.out.println(Arrays.toString(persons)); // [Alice, Jerry, Tom]

上例中，Person类实现了Comparable<Person>接口，并重写了其中的compareTo()方法。该方法根据name属性的大小关系进行比较，从而实现了以name属性进行自然排序。

定制排序

定制排序是指根据自定义的规则进行对象大小关系的比较。在Java中，我们可以通过实现Comparator<T>接口来实现定制排序。

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

// 根据Person对象的age属性进行定制排序
Comparator<Person> byAge = new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return Integer.compare(o1.getAge(), o2.getAge());
    }
};

// 使用定制排序对Person对象数组进行排序
Person[] persons = new Person[] { new Person("Tom", 20), new Person("Jerry", 18), new Person("Alice", 25) };
Arrays.sort(persons, byAge);
System.out.println(Arrays.toString(persons)); // [Jerry, Tom, Alice]

上例中，我们定义了一个匿名内部类实现了Comparator<Person>接口，并实现了compare()方法。该方法根据age属性的大小关系进行比较，从而实现了以age属性进行定制排序。

数学常用类

Java中提供了一些常用的数学类，用于完成数学计算，比如计算绝对值、幂、三角函数值等。这些常用的数学类主要包括以下几个：

Math类

Math类是Java中提供的数学类，它包含了各种数学计算方法，如取绝对值、幂、三角函数值等。

System.out.println(Math.abs(-5)); // 5

System.out.println(Math.pow(2, 3)); // 8.0

System.out.println(Math.sin(30)); // -0.9880316240928618

BigDecimal类

BigDecimal类是用于高精度计算的类，它可以避免精度丢失等问题。

BigDecimal bigDecimal1 = new BigDecimal("0.1");
BigDecimal bigDecimal2 = new BigDecimal("0.2");
BigDecimal result = bigDecimal1.add(bigDecimal2);
System.out.println(result); // 0.3

Random类

Random类用于生成伪随机数。它提供了两个构造方法：一个默认构造方法和一个接受种子的构造方法。

Random random = new Random();
System.out.println(random.nextInt(10)); //生成0到10之间的一个随机整数

Random random1 = new Random(100);
System.out.println(random1.nextInt(10)); //生成0到10之间的一个随机整数，其中的种子为100

示例说明

示例1

我们定义了一个表示学生的Student类，其中有学生姓名和学生成绩两个属性。我们需要对学生按照成绩进行排序，如果成绩相同，则按照姓名进行排序。

public class Student implements Comparable<Student> {
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }

    // 实现Comparable接口，自然排序
    @Override
    public int compareTo(Student o) {
        if (this.score != o.getScore()) {
            return this.score - o.getScore();
        }
        return this.name.compareTo(o.getName());
    }
}

// 对学生数组进行自然排序
Student[] students = new Student[] { new Student("Tom", 80), new Student("Jerry", 70),
            new Student("Alice", 80), new Student("Bob", 90) };
Arrays.sort(students);
System.out.println(Arrays.toString(students));

上例中，我们定义了一个Student类，其中实现了Comparable<Student>接口，重写了其中的compareTo()方法。该方法首先按照score属性的大小进行比较，如果相同，则继续按照name属性进行比较，从而实现了对学生对象的自然排序。

示例2

我们需要生成一个1到10之间的随机整数。

Random random = new Random();
int num = random.nextInt(10) + 1;
System.out.println(num);

上例中，我们使用Random类生成一个随机整数，并加1后输出。这样我们就得到了一个1到10之间的随机整数。