Java常用类库——Arrays类(用于普通数组操作)、比较器（Comparable、Comparator 用于对象排序）的使用...

最新推荐文章于 2022-05-06 16:46:56 发布

iteye_18817

最新推荐文章于 2022-05-06 16:46:56 发布

阅读量248

点赞数

文章标签： java 数据结构与算法

学习目标

掌握Arrays类的使用

掌握填充以及排序器

掌握Comparable比较接口的使用

了解比较器的基本排序原理

掌握Comparator比较接口的使用

Arrays类

Arrays类是数组的操作类，定义在java.util包中，主要的功能可以实现数组元素的查找，数组内容的填充、排序等。

有以下的方法：

public static boolean equals(int[] a, int[] a2) 判断两个数组是否相等，此方法被重载多次，可以判断各种数组类型的数组。

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) 输出数组信息，此方法被重载多次，可以输出各种数据类型的数组。

查找API如下：

java.util 
类 Arrays

java.lang.Object
  继承者 java.util.Arrays
public class Arrays
extends Object
此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。

此类中所含方法的文档都包括对实现 的简短描述。应该将这些描述视为实现注意事项，而不应将它们视为规范 的一部分。实现者应该可以随意替代其他算法，只要遵循规范本身即可。（例如，sort(Object[]) 使用的算法不必是一个合并排序算法，但它必须是稳定的。）

此类是 Java Collections Framework 的成员。

从以下版本开始：
1.2

方法摘要
static
<T> List<T>
asList(T... a) 
          返回一个受指定数组支持的固定大小的列表。
static int	binarySearch(byte[] a, byte key) 
          使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。
static int	binarySearch(byte[] a, int fromIndex, int toIndex, byte key) 
          使用二分搜索法来搜索指定的 byte 型数组的范围，以获得指定的值。
static int	binarySearch(char[] a, char key) 
          使用二分搜索法来搜索指定的 char 型数组，以获得指定的值。
static int	binarySearch(char[] a, int fromIndex, int toIndex, char key) 
          使用二分搜索法来搜索指定的 char 型数组的范围，以获得指定的值。
static int	binarySearch(double[] a, double key) 
          使用二分搜索法来搜索指定的 double 型数组，以获得指定的值。
static int	binarySearch(double[] a, int fromIndex, int toIndex, double key) 
          使用二分搜索法来搜索指定的 double 型数组的范围，以获得指定的值。
static int	binarySearch(float[] a, float key) 
          使用二分搜索法来搜索指定的 float 型数组，以获得指定的值。
static int	binarySearch(float[] a, int fromIndex, int toIndex, float key) 
          使用二分搜索法来搜索指定的 float 型数组的范围，以获得指定的值。
static int	binarySearch(int[] a, int key) 
          使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
static int	binarySearch(int[] a, int fromIndex, int toIndex, int key) 
          使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。
static int	binarySearch(long[] a, int fromIndex, int toIndex, long key) 
          使用二分搜索法来搜索指定的 long 型数组的范围，以获得指定的值。
static int	binarySearch(long[] a, long key) 
          使用二分搜索法来搜索指定的 long 型数组，以获得指定的值。
static int	binarySearch(Object[] a, int fromIndex, int toIndex, Object key) 
          使用二分搜索法来搜索指定数组的范围，以获得指定对象。
static int	binarySearch(Object[] a, Object key) 
          使用二分搜索法来搜索指定数组，以获得指定对象。
static int	binarySearch(short[] a, int fromIndex, int toIndex, short key) 
          使用二分搜索法来搜索指定的 short 型数组的范围，以获得指定的值。
static int	binarySearch(short[] a, short key) 
          使用二分搜索法来搜索指定的 short 型数组，以获得指定的值。
static
<T> int
binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c) 
          使用二分搜索法来搜索指定数组的范围，以获得指定对象。
static
<T> int
binarySearch(T[] a, T key, Comparator<? super T> c) 
          使用二分搜索法来搜索指定数组，以获得指定对象。
static boolean[]	copyOf(boolean[] original, int newLength) 
          复制指定的数组，截取或用 false 填充（如有必要），以使副本具有指定的长度。
static byte[]	copyOf(byte[] original, int newLength) 
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
static char[]	copyOf(char[] original, int newLength) 
          复制指定的数组，截取或用 null 字符填充（如有必要），以使副本具有指定的长度。
static double[]	copyOf(double[] original, int newLength) 
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
static float[]	copyOf(float[] original, int newLength) 
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
static int[]	copyOf(int[] original, int newLength) 
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
static long[]	copyOf(long[] original, int newLength) 
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
static short[]	copyOf(short[] original, int newLength) 
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
static
<T> T[]
copyOf(T[] original, int newLength) 
          复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。
static
<T,U> T[]
copyOf(U[] original, int newLength, Class<? extends T[]> newType) 
          复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。
static boolean[]	copyOfRange(boolean[] original, int from, int to) 
          将指定数组的指定范围复制到一个新数组。
static byte[]	copyOfRange(byte[] original, int from, int to) 
          将指定数组的指定范围复制到一个新数组。
static char[]	copyOfRange(char[] original, int from, int to) 
          将指定数组的指定范围复制到一个新数组。
static double[]	copyOfRange(double[] original, int from, int to) 
          将指定数组的指定范围复制到一个新数组。
static float[]	copyOfRange(float[] original, int from, int to) 
          将指定数组的指定范围复制到一个新数组。
static int[]	copyOfRange(int[] original, int from, int to) 
          将指定数组的指定范围复制到一个新数组。
static long[]	copyOfRange(long[] original, int from, int to) 
          将指定数组的指定范围复制到一个新数组。
static short[]	copyOfRange(short[] original, int from, int to) 
          将指定数组的指定范围复制到一个新数组。
static
<T> T[]
copyOfRange(T[] original, int from, int to) 
          将指定数组的指定范围复制到一个新数组。
static
<T,U> T[]
copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) 
          将指定数组的指定范围复制到一个新数组。
static boolean	deepEquals(Object[] a1, Object[] a2) 
          如果两个指定数组彼此是深层相等 的，则返回 true。
static int	deepHashCode(Object[] a) 
          基于指定数组的“深层内容”返回哈希码。
static String	deepToString(Object[] a) 
          返回指定数组“深层内容”的字符串表示形式。
static boolean	equals(boolean[] a, boolean[] a2) 
          如果两个指定的 boolean 型数组彼此相等，则返回 true。
static boolean	equals(byte[] a, byte[] a2) 
          如果两个指定的 byte 型数组彼此相等，则返回 true。
static boolean	equals(char[] a, char[] a2) 
          如果两个指定的 char 型数组彼此相等，则返回 true。
static boolean	equals(double[] a, double[] a2) 
          如果两个指定的 double 型数组彼此相等，则返回 true。
static boolean	equals(float[] a, float[] a2) 
          如果两个指定的 float 型数组彼此相等，则返回 true。
static boolean	equals(int[] a, int[] a2) 
          如果两个指定的 int 型数组彼此相等，则返回 true。
static boolean	equals(long[] a, long[] a2) 
          如果两个指定的 long 型数组彼此相等，则返回 true。
static boolean	equals(Object[] a, Object[] a2) 
          如果两个指定的 Objects 数组彼此相等，则返回 true。
static boolean	equals(short[] a, short[] a2) 
          如果两个指定的 short 型数组彼此相等，则返回 true。
static void	fill(boolean[] a, boolean val) 
          将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
static void	fill(boolean[] a, int fromIndex, int toIndex, boolean val) 
          将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。
static void	fill(byte[] a, byte val) 
          将指定的 byte 值分配给指定 byte 节型数组的每个元素。
static void	fill(byte[] a, int fromIndex, int toIndex, byte val) 
          将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。
static void	fill(char[] a, char val) 
          将指定的 char 值分配给指定 char 型数组的每个元素。
static void	fill(char[] a, int fromIndex, int toIndex, char val) 
          将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。
static void	fill(double[] a, double val) 
          将指定的 double 值分配给指定 double 型数组的每个元素。
static void	fill(double[] a, int fromIndex, int toIndex, double val) 
          将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。
static void	fill(float[] a, float val) 
          将指定的 float 值分配给指定 float 型数组的每个元素。
static void	fill(float[] a, int fromIndex, int toIndex, float val) 
          将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。
static void	fill(int[] a, int val) 
          将指定的 int 值分配给指定 int 型数组的每个元素。
static void	fill(int[] a, int fromIndex, int toIndex, int val) 
          将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
static void	fill(long[] a, int fromIndex, int toIndex, long val) 
          将指定的 long 值分配给指定 long 型数组指定范围中的每个元素。
static void	fill(long[] a, long val) 
          将指定的 long 值分配给指定 long 型数组的每个元素。
static void	fill(Object[] a, int fromIndex, int toIndex, Object val) 
          将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
static void	fill(Object[] a, Object val) 
          将指定的 Object 引用分配给指定 Object 数组的每个元素。
static void	fill(short[] a, int fromIndex, int toIndex, short val) 
          将指定的 short 值分配给指定 short 型数组指定范围中的每个元素。
static void	fill(short[] a, short val) 
          将指定的 short 值分配给指定 short 型数组的每个元素。
static int	hashCode(boolean[] a) 
          基于指定数组的内容返回哈希码。
static int	hashCode(byte[] a) 
          基于指定数组的内容返回哈希码。
static int	hashCode(char[] a) 
          基于指定数组的内容返回哈希码。
static int	hashCode(double[] a) 
          基于指定数组的内容返回哈希码。
static int	hashCode(float[] a) 
          基于指定数组的内容返回哈希码。
static int	hashCode(int[] a) 
          基于指定数组的内容返回哈希码。
static int	hashCode(long[] a) 
          基于指定数组的内容返回哈希码。
static int	hashCode(Object[] a) 
          基于指定数组的内容返回哈希码。
static int	hashCode(short[] a) 
          基于指定数组的内容返回哈希码。
static void	sort(byte[] a) 
          对指定的 byte 型数组按数字升序进行排序。
static void	sort(byte[] a, int fromIndex, int toIndex) 
          对指定 byte 型数组的指定范围按数字升序进行排序。
static void	sort(char[] a) 
          对指定的 char 型数组按数字升序进行排序。
static void	sort(char[] a, int fromIndex, int toIndex) 
          对指定 char 型数组的指定范围按数字升序进行排序。
static void	sort(double[] a) 
          对指定的 double 型数组按数字升序进行排序。
static void	sort(double[] a, int fromIndex, int toIndex) 
          对指定 double 型数组的指定范围按数字升序进行排序。
static void	sort(float[] a) 
          对指定的 float 型数组按数字升序进行排序。
static void	sort(float[] a, int fromIndex, int toIndex) 
          对指定 float 型数组的指定范围按数字升序进行排序。
static void	sort(int[] a) 
          对指定的 int 型数组按数字升序进行排序。
static void	sort(int[] a, int fromIndex, int toIndex) 
          对指定 int 型数组的指定范围按数字升序进行排序。
static void	sort(long[] a) 
          对指定的 long 型数组按数字升序进行排序。
static void	sort(long[] a, int fromIndex, int toIndex) 
          对指定 long 型数组的指定范围按数字升序进行排序。
static void	sort(Object[] a) 
          根据元素的自然顺序对指定对象数组按升序进行排序。
static void	sort(Object[] a, int fromIndex, int toIndex) 
          根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。
static void	sort(short[] a) 
          对指定的 short 型数组按数字升序进行排序。
static void	sort(short[] a, int fromIndex, int toIndex) 
          对指定 short 型数组的指定范围按数字升序进行排序。
static
<T> void
sort(T[] a, Comparator<? super T> c) 
          根据指定比较器产生的顺序对指定对象数组进行排序。
static
<T> void
sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) 
          根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
static String	toString(boolean[] a) 
          返回指定数组内容的字符串表示形式。
static String	toString(byte[] a) 
          返回指定数组内容的字符串表示形式。
static String	toString(char[] a) 
          返回指定数组内容的字符串表示形式。
static String	toString(double[] a) 
          返回指定数组内容的字符串表示形式。
static String	toString(float[] a) 
          返回指定数组内容的字符串表示形式。
static String	toString(int[] a) 
          返回指定数组内容的字符串表示形式。
static String	toString(long[] a) 
          返回指定数组内容的字符串表示形式。
static String	toString(Object[] a) 
          返回指定数组内容的字符串表示形式。
static String	toString(short[] a) 
          返回指定数组内容的字符串表示形式。
 
从类 java.lang.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait,

程序代码示例如下：

import java.util.* ;
public class ArraysDemo{
	public static void main(String arg[]){
		int temp[] = {3,4,5,7,9,1,2,6,8} ;	// 声明一个整型数组
		Arrays.sort(temp) ;		// 进行排序的操作
		System.out.print("排序后的数组：") ;
		System.out.println(Arrays.toString(temp)) ;	// 以字符串输出数组
		// 如果要想使用二分法查询的话，则必须是排序之后的数组
		int point = Arrays.binarySearch(temp,3) ;	// 检索位置
		System.out.println("元素‘3’的位置在：" + point) ;
		Arrays.fill(temp,3)	;// 填充数组
		System.out.print("数组填充：") ;
		System.out.println(Arrays.toString(temp)) ;
	}
};

注意：fill填充数组不是加在数组后面，而是将数组中的所有元素都重新赋一个新值。

注意sort方法中有一个专门对对象排序的辅助类参数，当然对于已经实现Comparable接口的对象直接对数组排序即可。

Comparable接口的作用

之前Arrays类中存在sort()方法，此方法可以直接对对象数组进行排序。

Comparable接口：

可以直接使用java.util.Arrays类进行数组的排序操作，但对象所在的类必须实现Comparable接口，用于指定排序接口，Comparable接口定义如下：

public interface Comparable<T>{

public int compareTo(T o);

}

此方法返回一个int类型的数据，但是此int的值只能是以下三种：

1：表示大于

-1：表示小于

0：表示等于

要求：

定义一个学生类，里面有姓名、年龄、成绩三个属性，要求按成绩由高到低排序，如果成绩相等则按照年龄由低到高排序。

代码示例如下：

class Student implements Comparable<Student> {	// 指定类型为Student
	private String name ;
	private int age ;
	private float score ;
	public Student(String name,int age,float score){
		this.name = name ;
		this.age = age ;
		this.score = score ;
	}
	public String toString(){
		return name + "\t\t" + this.age + "\t\t" + this.score ;
	}
	public int compareTo(Student stu){	// 覆写compareTo()方法，实现排序规则的应用
		if(this.score>stu.score){
			return -1 ;
		}else if(this.score<stu.score){
			return 1 ;
		}else{
			if(this.age>stu.age){
				return 1 ;
			}else if(this.age<stu.age){
				return -1 ;
			}else{
				return 0 ;
			}
		}	
	}
};
public class ComparableDemo01{
	public static void main(String args[]){
		Student stu[] = {
			new Student("张三",20,90.0f),
			new Student("李四",22,90.0f),
			new Student("王五",20,99.0f),
			new Student("赵六",20,70.0f),
			new Student("孙七",22,100.0f)} ;
		java.util.Arrays.sort(stu) ;	// 进行排序操作
		for(int i=0;i<stu.length;i++){	// 循环输出数组中的内容
			System.out.println(stu[i]) ;
		}
	}
};

运行结果如下：

注意：如果此时Student类中没有实现Comparable接口，则在执行时会出现以下的异常：

Exception in thread "main" java.lang.ClassCastException

分析比较器的排序原理

实际上比较器的操作，就是数据结构里的二叉树排序算法。

排序的基本原理：使用第一个元素作为根节点，之后如果后面的内容比根节点小，则放在左子树，如果内容比根节点的内容要大，则放在右子树。之后利用中序遍历的方式把内容依次读取出来。

下边就手工实现一个二叉树的比较算法。

为了操作方便，此处使用Integer类完成。

public class ComparableDemo02{
	public static void main(String args[]){
		Comparable com = null ;			// 声明一个Comparable接口对象
		com = 30 ;						// 通过Integer为Comparable实例化
		System.out.println("内容为：" + com) ;	// 调用的是toString()方法
	}
};

利用此特性，动手实现一个二叉树，实例如下：

class BinaryTree{
	class Node{			// 声明一个节点类
		private Comparable data ;	// 保存具体的内容
		private Node left ;			// 保存左子树
		private Node right ;		// 保存右子树
		public Node(Comparable data){
			this.data = data ;
		}
		public void addNode(Node newNode){
			// 确定是放在左子树还是右子树
			if(newNode.data.compareTo(this.data)<0){	// 内容小，放在左子树
				if(this.left==null){
					this.left = newNode ;	// 直接将新的节点设置成左子树
				}else{
					this.left.addNode(newNode) ;	// 继续向下判断
				}
			}
			if(newNode.data.compareTo(this.data)>=0){	// 放在右子树
				if(this.right==null){
					this.right = newNode ;	// 没有右子树则将此节点设置成右子树
				}else{
					this.right.addNode(newNode) ;	// 继续向下判断
				}
			}
		}
		public void printNode(){	// 输出的时候采用中序遍历
			if(this.left!=null){
				this.left.printNode() ;	// 输出左子树
			}
			System.out.print(this.data + "\t") ;
			if(this.right!=null){
				this.right.printNode() ;
			}
		}
	};
	private Node root ;		// 根元素
	public void add(Comparable data){	// 加入元素
		Node newNode = new Node(data) ;	// 定义新的节点
		if(root==null){	// 没有根节点
			root = newNode ;	// 第一个元素作为根节点
		}else{
			root.addNode(newNode) ; // 确定是放在左子树还是放在右子树
		}
	}
	public void print(){
		this.root.printNode() ;	// 通过根节点输出
	}
};
public class ComparableDemo03{
	public static void main(String args[]){
		BinaryTree bt = new BinaryTree() ;
		bt.add(8) ;
		bt.add(3) ;
		bt.add(3) ;
		bt.add(10) ;
		bt.add(9) ;
		bt.add(1) ;
		bt.add(5) ;
		bt.add(5) ;
		System.out.println("排序之后的结果：") ;
		bt.print() ;
	}
};

另一种比较器：Comparator

如果一个类已经开发完成，但是在此类建立的初期并没有实现Comparable接口，此时肯定是无法进行对象排序操作的，所以为了解决这样的问题，java又定义了另一个比较器的操作接口——Comparator。此接口定义在java.util包中，接口定义如下：

public interface Comparator<T>{

public int compare(T o1, T o2);

boolean equals(Object obj);

}

下面定义一个自己的类，此类没有实现Comparable接口。

如下所示：

import java.util.* ;
class Student{	// 指定类型为Student
	private String name ;
	private int age ;
	public Student(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public boolean equals(Object obj){	// 覆写equals方法
		if(this==obj){
			return true ;
		}
		if(!(obj instanceof Student)){
			return false ;
		}
		Student stu = (Student) obj ;
		if(stu.name.equals(this.name)&&stu.age==this.age){
			return true ;
		}else{
			return false ;
		}
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return this.name ;
	}
	public int getAge(){
		return this.age ;
	}
	public String toString(){
		return name + "\t\t" + this.age  ;
	}
};

class StudentComparator implements Comparator<Student>{	// 实现比较器
	// 因为Object类中本身已经有了equals()方法
	public int compare(Student s1,Student s2){
		if(s1.equals(s2)){
			return 0 ;
		}else if(s1.getAge()<s2.getAge()){	// 按年龄比较
			return 1 ;
		}else{
			return -1 ;
		}
	}
};

public class ComparatorDemo{
	public static void main(String args[]){
		Student stu[] = {new Student("张三",20),
			new Student("李四",22),new Student("王五",20),
			new Student("赵六",20),new Student("孙七",22),
		new Student("郑八",18),new Student("谢九",30),
		new Student("于十",18),new Student("八十一",21)};
		java.util.Arrays.sort(stu,new StudentComparator()) ;	// 进行排序操作
		for(int i=0;i<stu.length;i++){	// 循环输出数组中的内容
			System.out.println(stu[i]) ;
		}
	}
};

注意：equals方法不实现也可，因为Object类中已经有了equals方法。但最好还是实现，因为一般对象的比较都是比较内容和类型的，很少比较内存地址的。

总结：

在使用中还是尽可能的使用Comparable在需要排序的类上实现此接口，而Comparator需要单独建立一个排序的类，这样如果有很多的话，则排序的规则类也会非常多，操作起来非常麻烦。

掌握一点：只要是对象排序，则在java中永远是以Comparable接口为准的。

iteye_18817

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java常用类库——Arrays类(用于普通数组操作)、比较器（Comparable、Comparator 用于对象排序）的使用...

学习目标掌握Arrays类的使用掌握填充以及排序器掌握Comparable比较接口的使用了解比较器的基本排序原理掌握Comparator比较接口的使用Arrays类Arrays类是数组的操作类，定义在java.util包中，主要的功能可以实现数组元素的查找，数组内容的填充、排序等。有以下的方法：public static boolean equals(int[] a, int[...
复制链接

扫一扫