Java基础(十八)：java比较器、系统相关类、数学相关类

Java微观世界

发布于 2025-01-21 09:08:14

2230

Java基础系列文章

Java基础(一)：语言概述	Java基础(二)：原码、反码、补码及进制之间的运算	Java基础(三)：数据类型与进制	Java基础(四)：逻辑运算符和位运算符
Java基础(五)：流程控制语句	Java基础(六)：数组	Java基础(七)：面向对象编程	Java基础(八)：封装、继承、多态性
Java基础(九)：Object 类的使用	Java基础(十)：关键字static、代码块、关键字final	Java基础(十一)：抽象类、接口、内部类	Java基础(十二)：枚举类
Java基础(十三)：注解(Annotation)	Java基础(十四)：包装类	Java基础(十五)：异常处理	Java基础(十六)：String的常用API
Java基础(十七)：日期时间API	Java基础(十八)：java比较器、系统相关类、数学相关类	Java基础(十九)：集合框架	Java基础(二十)：泛型
Java基础(二十一)：集合源码	Java基础(二十二)：File类与IO流	Java基础(二十三)：反射机制	Java基础(二十四)：网络编程
Java基础(二十五)：Lambda表达式、方法引用、构造器引用	Java基础(二十六)：Java8 Stream流及Optional类

一、Java比较器

1、自然排序：java.lang.Comparable

Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序
实现Comparable的类必须实现compareTo(Object obj)方法
- 两个对象即通过compareTo(Object obj)方法的返回值来比较大小
- 如果当前对象this大于形参对象obj，则返回正整数
- 如果当前对象this小于形参对象obj，则返回负整数
- 如果当前对象this等于形参对象obj，则返回零

public interface Comparable<T> {
    int compareTo(Object obj);
}

实现Comparable接口的对象列表可以通过 Collections.sort进行自动排序
实现Comparable接口的对象数组可以通过 Arrays.sort进行自动排序

@Test
public void test1() {
    String[] arr = new String[]{"C", "E", "D", "A", "J", "F"};
    // 数组排序
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr)); // [A, C, D, E, F, J]

    List<String> list = Arrays.asList("C", "E", "D", "A", "J", "F");
    // 集合排序
    Collections.sort(list);
    System.out.println(list);// [A, C, D, E, F, J]
}

自定义对象实现Comparable接口做比较

@Test
public void test2() {
    List<Product> productList = Lists.newArrayList();
    productList.add(new Product("A", 200));
    productList.add(new Product("B", 100));
    productList.add(new Product("C", 100));
	// 自定义类实现Comparable接口
    Collections.sort(productList);
    System.out.println(productList); 
    //输出结果：[Product(name=B, price=100.0), Product(name=C, price=100.0), Product(name=A, price=200.0)]
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Product implements Comparable<Product> {
    private String name;// 商品名称
    private double price;// 价格

    @Override
    public int compareTo(Product o) {
        return Double.compare(this.price, o.price);
    }
}

Comparable 的典型实现：(默认都是从小到大排列的)
- String：按照字符串中字符的Unicode值进行比较
- Character：按照字符的Unicode值来进行比较
- 数值类型对应的包装类以及BigInteger、BigDecimal：按照它们对应的数值大小进行比较
- Boolean：true 对应的包装类实例大于 false 对应的包装类实例
- Date、Time等：后面的日期时间比前面的日期时间大

@Test
public void test3(){
    System.out.println("A".compareTo("B")); // -1

    Character c1 = '1';
    Character c2 = '2';
    System.out.println(c2.compareTo(c1)); // 1

    BigInteger b1 = new BigInteger("100");
    BigInteger b2 = new BigInteger("100");
    System.out.println(b1.compareTo(b2)); // 0

    Boolean bl1 = true;
    Boolean bl2 = false;
    System.out.println(bl1.compareTo(bl2));// 1
}

2、定制排序：java.util.Comparator

使用Comparator接口的场景

一个对象没有实现java.lang.Comparable接口而又不方便修改代码（例如：一些第三方的类，你只有.class文件，没有源文件）
一个对象实现了Comparable接口，但认为compareTo方法中的比较方式并不是自己想要的那种比较方式（想要自定义排序方式）

2.1、compare方法

Comparator用于比较来对象与对象之间的，两个对象进行比较，多用于集合排序
重写compare(Object o1,Object o2)方法，比较o1和o2的大小
- 如果方法返回正整数，则表示o1大于o2
- 如果返回0，表示相等
- 返回负整数，表示o1小于o2

public interface Comparator<T>{
    int compare(Object o1,Object o2);
}

可以将Comparator传入Collections.sort或Arrays.sort的排序方法的第二个参数

@Test
public void test4() {
    String[] arr = new String[]{"T", "J", "A", "R", "B", "L"};
    // String默认Unicode升序，这里通过自定义Comparator改为降序
    Arrays.sort(arr, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return -o1.compareTo(o2);
        }
    });
    System.out.println(Arrays.toString(arr)); // [T, R, L, J, B, A]
}

自定义对象不需要实现接口，即可通过Comparator实现对象间的比较

@Test
public void test5() {
    List<Product> productList = new ArrayList<>();
    productList.add(new Product("A", 200));
    productList.add(new Product("B", 100));
    productList.add(new Product("C", 100));
    // 不需要实现接口，通过Comparator即可比较对象
    Collections.sort(productList, new Comparator<Product>() {
        @Override
        public int compare(Product o1, Product o2) {
            return Double.compare(o1.getPrice(), o2.getPrice());
        }
    });
    System.out.println(productList);
    // 输出结果：[Product(name=B, price=100.0), Product(name=C, price=100.0), Product(name=A, price=200.0)]
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Product {
    private String name;// 商品名称
    private double price;// 价格
}

2.2、reversed方法

该方法返回一个与原Comparator对象相反的Comparator对象

@Test
public void test6() {
    String[] arr = new String[]{"T", "J", "A", "R", "B", "L"};
    // Comparator实现类，重写compare方法
    Comparator<String> comparator = new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
    };
    Arrays.sort(arr, comparator);
    System.out.println(Arrays.toString(arr)); // 升序：[A, B, J, L, R, T]

    Arrays.sort(arr, comparator.reversed());
    System.out.println(Arrays.toString(arr)); // 降序：[T, R, L, J, B, A]
}

2.3、thenComparing方法

该方法用于将两个Comparator对象进行级联比较
当两个对象比较结果相同时，会使用第二个Comparator对象进行比较

@Test
public void test7() {
    List<Product> productList = new ArrayList<>();
    productList.add(new Product("A", 200));
    productList.add(new Product("A", 100));
    productList.add(new Product("C", 100));

    // 价格升序比较器
    Comparator<Product> priceComparator = new Comparator<Product>() {
        @Override
        public int compare(Product o1, Product o2) {
            return Double.compare(o1.getPrice(), o2.getPrice());
        }
    };
    
    // 姓名升序比较器
    Comparator<Product> nameComparator = new Comparator<Product>() {
        @Override
        public int compare(Product o1, Product o2) {
            return o1.getName().compareTo(o2.getName());
        }
    };

    priceComparator.thenComparing(nameComparator);
    
    // 先根据价格升序，价格相同，ze根据名称升序
    Collections.sort(productList, priceComparator);
}

2.4、nullsFirst方法

如果对象中出现null，则排在最前面

@Test
public void test8() {
    List<String> stringList = Arrays.asList("apple", null, "banana", null, "cherry");

    Comparator<String> comp = Comparator.nullsFirst(new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
    });
    Collections.sort(stringList, comp);

    System.out.println(stringList); // [null, null, apple, banana, cherry]
}

2.5、nullsLast方法

如果对象中出现null，则排在最后面

@Test
public void test9() {
    List<String> stringList = Arrays.asList("apple", null, "banana", null, "cherry");

    Comparator<String> comp = Comparator.nullsLast(new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
    });
    Collections.sort(stringList, comp);

    System.out.println(stringList); // [apple, banana, cherry, null, null]
}

2.6、comparing方法

该函数从给定类型中提取一个可比较排序方式，并返回一个通过该排序方式进行比较的比较器
comparingInt、comparingDouble、comparingLong它们的工作方式和 comparing 类似，但接受的函数特别针对某些基本数据类型

@Test
public void test7() {
    List<Product> productList = new ArrayList<>();
    productList.add(new Product("A", 200));
    productList.add(new Product("A", 100));
    productList.add(new Product("C", 100));

    // 根据姓名排序-升序
    productList.stream()
            .sorted(Comparator.comparing(Product::getName))
            .forEach(System.out::println);
    // 自定义排序方式-降序
    productList.stream()
            .sorted(Comparator.comparing(Product::getName, (o1, o2) -> -o1.compareTo(o2)))
            .forEach(System.out::println);
    // 根据价格升序
    productList.stream()
            .sorted(Comparator.comparingDouble(Product::getPrice))
            .forEach(System.out::println);
}

2.7、reverseOrder方法

返回一个与自然排序相反的比较器

@Test
public void test8() {
    List<String> list = Arrays.asList("T", "J", "A", "R", "B", "L");
    // 默认升序排序
    list.stream().sorted().forEach(System.out::println);
    // 降序排序
    list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);
}

二、系统相关类

1、java.lang.System类

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包
由于该类的构造器是private的，所以无法创建该类的对象
其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用

静态方法

native long currentTimeMillis()：
- 该方法的作用是返回当前的计算机时间
- 时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数
void exit(int status)：
- 该方法的作用是退出程序
- 其中status的值为0代表正常退出，非零代表异常退出
- 使用该方法可以在图形界面编程中实现程序的退出功能等
void gc()：
- 该方法的作用是请求系统进行垃圾回收
- 至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况
String getProperty(String key)：
- 该方法的作用是获得系统中属性名为key的属性对应的值
- 系统中常见的属性名以及属性的作用如下表所示

举例：

@Test
public void test1() {
    String javaVersion = System.getProperty("java.version");
    System.out.println("java版本号:" + javaVersion);

    String javaHome = System.getProperty("java.home");
    System.out.println("java安装目录:" + javaHome);

    String osName = System.getProperty("os.name");
    System.out.println("操作系统名称:" + osName);

    String osVersion = System.getProperty("os.version");
    System.out.println("操作系统版本:" + osVersion);

    String userName = System.getProperty("user.name");
    System.out.println("用户的账户名称:" + userName);

    String userHome = System.getProperty("user.home");
    System.out.println("用户的主目录:" + userHome);

    String userDir = System.getProperty("user.dir");
    System.out.println("当前工作目录:" + userDir);
}

输出结果：

java版本号:1.8.0_333
java安装目录:/Library/Java/JavaVirtualMachines/jdk1.8.0_333.jdk/Contents/Home/jre
操作系统名称:Mac OS X
操作系统版本:12.6.3
用户的账户名称:xuchang
用户的主目录:/Users/xuchang
当前工作目录:/Users/xuchang/Documents/javaCode/study/code-collection/small-projects

2、java.lang.Runtime类

每个Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接
public static Runtime getRuntime()
- 返回与当前Java应用程序相关的运行时对象
- 应用程序不能创建自己的Runtime类实例
public long totalMemory()
- 返回Java虚拟机中初始化时的内存总量
- 此方法返回的值可能随时间的推移而变化，这取决于主机环境
- 默认为物理电脑内存的1/64
public long maxMemory()
- 返回Java虚拟机中最大程度能使用的内存总量
- 默认为物理电脑内存的1/4
public long freeMemory()
- 返回回Java虚拟机中的空闲内存量
- 调用gc方法可能导致freeMemory返回值的增加

举例：

@Test
public void test2() {
    Runtime runtime = Runtime.getRuntime();
    long initialMemory = runtime.totalMemory(); //获取虚拟机初始化时堆内存总量
    long maxMemory = runtime.maxMemory(); //获取虚拟机最大堆内存总量
    String str = "";
    //模拟占用内存
    for (int i = 0; i < 10000; i++) {
        str += i;
    }
    long freeMemory = runtime.freeMemory(); //获取空闲堆内存总量

    System.out.println("总内存：" + initialMemory / 1024 / 1024 * 64 + "MB");
    System.out.println("总内存：" + maxMemory / 1024 / 1024 * 4 + "MB");
    System.out.println("空闲内存：" + freeMemory / 1024 / 1024 + "MB") ;
    System.out.println("已用内存：" + (initialMemory-freeMemory) / 1024 / 1024 + "MB");
}

输出结果：

总内存：16640MB
总内存：16384MB
空闲内存：139MB
已用内存：120MB

三、数学相关的类

1、java.lang.Math

java.lang.Math 类包含用于执行基本数学运算的方法
如初等指数、对数、平方根和三角函数
类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单

静态方法

public static double abs(double a) ：返回 double 值的绝对值

double d1 = Math.abs(-5); //d1的值为5
double d2 = Math.abs(5); //d2的值为5

public static double ceil(double a) ：返回大于等于参数的最小的整数
ceil：天花板

double d1 = Math.ceil(3.3); //d1的值为 4.0
double d2 = Math.ceil(-3.3); //d2的值为 -3.0
double d3 = Math.ceil(5.1); //d3的值为 6.0

public static double floor(double a) ：返回小于等于参数最大的整数
floor：地板

double d1 = Math.floor(3.3); //d1的值为 3.0
double d2 = Math.floor(-3.3); //d2的值为 -4.0
double d3 = Math.floor(5.1); //d3的值为 5.0

public static long round(double a) ：返回最接近参数的 long(相当于四舍五入方法)

long d1 = Math.round(5.5); //d1的值为6
long d2 = Math.round(5.4); //d2的值为5
long d3 = Math.round(-3.3); //d3的值为-3
long d4 = Math.round(-3.8); //d4的值为-4

public static double random()：返回[0,1)的double随机值
Math.random()内部调用的方法就是Random类中的nextDouble()方法

double rand = Math.random(); // 0.49063812186909517

2、java.math.BigInteger

Integer类作为int的包装类，能存储的最大整型值为231-1，Long类也是有限的，最大为263-1
- 如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了
java.math包的BigInteger可以表示不可变的任意精度的整数
- BigInteger提供所有Java的基本整数操作符的对应方法

构造器

BigInteger(String val)：根据字符串构建BigInteger对象

方法

public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger
BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger
BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger
BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger
BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分
BigInteger remainder(BigInteger val) ：返回其值为 (this % val) 的 BigInteger

@Test
public void test3(){
    BigInteger b1 = new BigInteger("12345678912345678912345678");
    BigInteger b2 = new BigInteger("78923456789123456789123456789");

    System.out.println("和：" + b1.add(b2)); // 78935802468035802468035802467
    System.out.println("减：" + b1.subtract(b2));// -78911111110211111110211111111
    System.out.println("乘：" + b1.multiply(b2));// 974363656170906866147450004116994361840451151863907942
    System.out.println("除：" + b2.divide(b1));// 6392
    System.out.println("余：" + b2.remainder(b1));// 9877181409877181409883013
}

3、java.math.BigDecimal

一般的Float类和Double类可以用来做科学计算或工程计算
但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类
BigDecimal类支持不可变的、任意精度的有符号十进制定点数

构造器

public BigDecimal(double val)
public BigDecimal(int val)
public BigDecimal(String val) 推荐

常用方法

public BigDecimal add(BigDecimal augend)：加
public BigDecimal subtract(BigDecimal subtrahend)：减
public BigDecimal multiply(BigDecimal multiplicand)：乘
public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)：除
- divisor是除数
- scale指明保留几位小数（不传参默认3位）
- roundingMode指明舍入模式
  - ROUND_UP：向上加1
  - ROUND_DOWN：直接舍去
  - ROUND_HALF_UP：四舍五入

@Test
public void test4(){
	BigDecimal bd = new BigDecimal("12435.351");
	BigDecimal bd2 = new BigDecimal("11");
	System.out.println(bd); // 12435.351
	System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP)); // 1130.486
	System.out.println(bd.divide(bd2, 5, BigDecimal.ROUND_HALF_UP)); // 1130.48645
}

4、java.util.Random（产生随机数）

boolean nextBoolean()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的boolean值
void nextBytes(byte[] bytes)：生成随机字节并将其置于用户提供的byte数组中
double nextDouble()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的double值
float nextFloat()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的float值
int nextInt()：返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的int值
int nextInt(int n)：返回一个伪随机数，它是取自此随机数生成器序列的、在0（包括）和指定值（不包括）之间均匀分布的int值
long nextLong()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的long值

@Test
public void test51(){
    Random random = new Random();

    // 随机分布布尔值
    boolean b = random.nextBoolean();
    System.out.println(b); // true

    // 随机分布byte值
    byte[] bytes = new byte[5];
    random.nextBytes(bytes);
    System.out.println(Arrays.toString(bytes)); // [-95, -86, -25, 74, -75]

    // 随机分布double值
    double d = random.nextDouble();
    System.out.println(d); // 0.48792404865555417

    // 随机分布int值
    int i = random.nextInt();
    System.out.println(i); // -235025063
    
    int j = random.nextInt(10); //随机获取[0,10)范围的整数
    System.out.println(j); // 7

    // 随机分布long值
    long l = random.nextLong();
    System.out.println(l); // 8233211111152036839
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-04-03，如有侵权请联系 cloudcommunity@tencent.com 删除

数学