Java 常用类库（三）-CSDN博客

本文链接：https://blog.csdn.net/ff906317011/article/details/78774859

博主最近有点忙，鸽了好几天,抱歉！今天将对Java常用类库做最后的总结，今天我们来说说java.util.Arrays.sort（数组类）。

java.util.Arrays.sort

“ java.util.Arrays.sort(数组名称) ”是一个数组排序操作，实际上这一个操作就是调用了java.util包中Arrays子类的sort()方法而成的，而Arrays是一个数组操作的工具类。

常用方法

方法	类型	描述
public static boolean equals(int[] a,int[] b)	普通	判断两个数组是否相等，此方法被重载多次，可判断多种数据类型的数组
public static void fill(int[] a,int val)	普通	将指定内容填充到数组中，此方法被重载多次，可填充多种数据类型的数组
public static void sort(int[] a)	普通	数组排序
public static int binarySearch(int[] a,int key)	普通	对排序后的数组进行检索，使用二分检索
public static String toString(int[] a)	普通	输出数组信息

Arrays类方法使用

// 使用Array类
import java.util.Arrays;public class test {    
public static void main(String[] args) throws CloneNotSupportedException {    
int dataA[] = new int[] {1,3,2} ;    
int dataB[] = new int[] {1,2,3} ;    
Arrays.fill(dataA, 9);    
System.out.println(Arrays.equals(dataA, dataB));    
System.out.println(Arrays.toString(dataA));    
    }
}

运行结果：

false[9, 9, 9]

比较器

首先，让我们看一段代码

// 自定义类没有实现比较器接口
import java.util.Arrays;class Person {    
private String name ;    
private int age ;    
public Person(String name,int age) {        
this.name = name ;        
this.age = age ;    
}    
@Override    
public String toString() {        
return "name:" + this.name +",age:" + this.age;    
}
}
public class test {    
public static void main(String[] args) throws CloneNotSupportedException {    
Person per[] = new Person[] {new Person("zhangsan", 20),                
new Person("lisi", 37),
new Person("wangwu", 15)} ;
############ 此句会出现异常 ############    
Arrays.sort(per);       
//排序##############################    
for (int i = 0; i < per.length; i++) {        
System.out.println(per[i]);        
}    
}
}

运行结果：
Exception in thread "main" java.lang.ClassCastException: Person cannot be cast to java.lang.Comparable

观察一下Arrays类中存在的一个方法：

对象数组的排序：public static void sort(Object[] a)
查看java.util.Arrays.sort(Object[] a) 可以发现对此异常的说明：

ClassCastException - if the array contains elements that are not mutually comparable (for example, strings and integers)
如果容器内包含的元素之间不可以相互比较，则抛出ClassCastException异常。

那么怎么能让自定义类的元素之间相互比较呢，这里可以使用Comparable接口。

Comparable接口

java.lang.Comparable接口是最为常用的一个比较器，此接口定义如下：

public interface Comparable<T>{    
int compareTo(T o)
}

在Comparable接口中发现只有一个CompareTo() 方法，而此方法可以返回三种类型的数据：-1,0,1。而一个类在实现了该接口后具备有比较能力，也主要是由于覆写了compareTo(T o) 方法，通过此方法定义比较规则，而在日后对类对象比较的时候则会依次规则进行比较。

在学习String类中，也学习过CompareTo()方法，可以进行大小的判断。

//  String 中的compareTo()方法
//  Returns:
//  the value 0 if the argument string is equal to this string; 
    a value less than 0 if 
//  this s

使用Comparable接口

// 比较器的使用
import java.util.Arrays;
class Person implements Comparable<Person>{    
private String name ;    
private int age ;    
public Person(String name,int age) {        
this.name = name ;        
this.age = age ;    
}    
@Override    
public String toString() {        
return "name:" + this.name +",age:" + this.age;    
}    
// 覆写接口中的函数 compareTo（）;    
@Override    
public int compareTo(Person o) {        
if (this.age > o.age) {            
return 1 ;        
}else if (this.age < o.age) {            
return -1 ;        
}else {            
return 0 ;        
}    
}
}
public class test {   
public static void main(String[] args) throws CloneNotSupportedException {    
Person per[] = new Person[] {
new Person("zhangsan", 20),                
new Person("lisi", 37),new Person("wangwu", 15)
} ;    
Arrays.sort(per);      
// 排序    
for (int i = 0; i < per.length; i++) {        System.out.println(per[i]);        
}    
}
}

运行结果：

name:wangwu,age:15name:zhangsan,age:20name:lisi,age:37

挽救的比较器：Comparator

在工作之中使用比较器，首选Comparable，但是Comparable有一个特点，它必须在定义的时候就实现好接口。有这样一种情况，一个类已经完成，且不允许做出任何修改，此类在先期设计时没有考虑对象数组的比较问题。

// Comparator接口（挽救比较器）定义如下
public interface Comparator<T> {    
int compare(T o1,T o2);    
boolean equals(Object obj);}

虽然Comparator接口中定义了两个抽象方法，但是子类只需要覆写 compare() 方法即可，而equals()方法在Object类中已经有了默认实现（地址比较）。

如果要利用Comparator接口实现对象数组的排序操作，还需要更换java.util.Arrays类中的排序方法。更改为：
public static void sort(T[] a, Comparator < ? super T> c)