二十四,Arrays和比较器
1.Arrays类定义
Arrays类是Java API中提供的类 ,与数组操作相关.可以使用此类对数组进行相关的操作.在java.util包中.Arrays类中提供的方法可直接实现数组的排序、搜索等.
-
数组赋值：fill();
-
比较数组：equals(); //此方法比较数组中元素值是否相等.
-
数组排序语法: Arrays.sort(<数组名>)； //默认升序
-
数组搜索语法: Arrays.binarySearch（<数组名>,<关键字>）； //查找目标数据在数组中的位置
排序方法:
-
冒泡排序
-
选择排序
-
插入排序
-
快速排序
示例:
package com.android.phoenix.activity.changeInfo;
import java.util.Arrays;
public class Demo {
public static void output(int[] array) {
if (array != null) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
System.out.println();
}
public static void main(String[] args) {
int[] array = new int[5];
// 填充数组
Arrays.fill(array, 5);
System.out.println("填充数组：Arrays.fill(array, 5)：");
TestArrays.output(array);
// 将数组的第2和第3个元素赋值为8
Arrays.fill(array, 2, 4, 8);
System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");
TestArrays.output(array);
int[] array1 = { 7, 8, 3, 2, 12, 6, 3, 5, 4 };
// 对数组的第2个到第6个进行排序进行排序
Arrays.sort(array1, 2, 7);
System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");
TestArrays.output(array1);
// 对整个数组进行排序
Arrays.sort(array1);
System.out.println("对整个数组进行排序：Arrays.sort(array1)：");
TestArrays.output(array1);
// 比较数组元素是否相等
System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):" + "\n"
+ Arrays.equals(array, array1));
int[] array2 = array1.clone();
System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):" + "\n"
+ Arrays.equals(array1, array2));
// 使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）
Arrays.sort(array1);
System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)："
+ "\n" + Arrays.binarySearch(array1, 3));
// 如果不存在就返回负数
System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)："
+ "\n" + Arrays.binarySearch(array1, 9));
}
}
输出结果：
填充数组：Arrays.fill(array, 5)： 5 5 5 5 5 将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)： 5 5 8 8 5 对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)： 7 8 2 3 3 6 12 5 4 对整个数组进行排序：Arrays.sort(array1)： 2 3 3 4 5 6 7 8 12 比较数组元素是否相等:Arrays.equals(array, array1): false 克隆后数组元素是否相等:Arrays.equals(array1, array2): true 元素3在array1中的位置：Arrays.binarySearch(array1, 3)： 1 元素9在array1中的位置：Arrays.binarySearch(array1, 9)： -9注 :数组中对元素进行排序操作的方法是 sort(),但是使用 sort()方法对数组对象进行排序的时候需要实现 Comparable接口 .
示例:
package com.aresxiong.comparesdemo;
import java.util.Arrays;
public class ComparatorDemo {
public static void main(String[] args) {
Student stu[] = { new Student(1, "张三", 21, 99.1f),
new Student(2, "李四", 20, 99.1f),
new Student(3, "王五", 21, 89.1f),
new Student(4, "赵六", 21, 80.1f),
new Student(5, "孙七", 19, 80.1f) };
System.out.println("============== 数组声明之前 ===============");
print(stu);
System.out.println("============== 数组排序之后 ===============");
Arrays.sort(stu,new StudentComparator());// 排序
print(stu);
}
public static void print(Student stu[]) {
for (int i = 0; i < stu.length; i++) {
System.out.println(stu[i]);
}
}
} 注
:这个对象数组排序就会抛出类转换异常
.
2.Comparable接口
实现了Comparable接口的类在一个Collection(集合）里是可以排序的,而排序的规则是按照你实现的Comparable里的抽象方法compareTo(Object o) 方法来决定的.
compareTo方法在Object中并没有被声明,它是java.lang.Compareable接口中唯一的方法.一个类实现了Compareable接口,就表明它的实例具有内在的排序关系(natural ordering).如果一个数组中的对象实现了Compareable接口,则对这个数组进行排序非常简单：Arrays.sort();对于存储在集合中的Comareable对象,搜索、计算极值以及自动维护工作都非常简单.一旦你的类实现了Compareable接口,它就可以跟许多泛型算法(generic algorithm)以及依赖于该接口的集合的操作实现进行协作,以小的努力得到强大的功能.
Java平台库中的所有值类(value classes)都实现了Compareable接口. compareTo的约定是：
将当前这个对象与指定的对象进行顺序比较,当该对象小于、等于或大于指定对象时,分别返回一个负整数、0或正整数,如果无法进行比较,则抛出ClassCastException异常. 接口定义如下:
public interface Comparable<T>{
int ComparableTo(T O){
//比较代码
}
} 有三种返回类型
:
-
小于: -1
-
等于: 0
-
大于: 1
示例:
import java.util.Arrays;
class Student implements Comparable<Student> { // 实现比较器，并指定泛型
private int stuno;
private String name;
private int age;
private float score;
public Student(int stuno, String name, int age, float score) {
this.stuno = stuno;
this.name = name;
this.age = age;
this.score = score;
}
public int compareTo(Student stu) {
//覆写 compareTo方法
if (this.score > stu.score) {
//制定需要比较的属性
return -1;
// 和<互换为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 String toString() { // 覆写toString()
return "学生编号：" + this.stuno + "；姓名：" + this.name + "；年龄：" + this.age
+ "；成绩：" + this.score;
}
}
public class CompareableDemo01 {
public static void main(String[] args) {
Student stu[] = { new Student(1, "张三", 21, 99.1f),
new Student(2, "李四", 20, 99.1f),
new Student(3, "王五", 21, 89.1f),
new Student(4, "赵六", 21, 80.1f),
new Student(5, "孙七", 19, 80.1f) };
System.out.println("============== 数组声明之前 ===============");
print(stu);
System.out.println("============== 数组排序之后 ===============");
Arrays.sort(stu);// 排序
print(stu);
}
public static void print(Student stu[]) {
for (int i = 0; i < stu.length; i++) {
System.out.println(stu[i]);
}
}
}
3. 二叉树排序的应用
二叉排序数的（递归）定义
①若左子树非空,则左子树所有节点的值均小于它的根节点.
②若右子树非空,则右子树所有节点的值均大于于它的根节点.
③左右子树也分别为二叉排序树.
示例:
package com.ares.comparesdemo;
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.println(this.data); // 找到根内容
if (this.right != null) {// 存在右子树
this.right.printNode(); // 继续找到下面的右子树
}
}
}
private Node root; // 根节点
public void add(Comparable data) {// 接收数据
Node newNode = new Node(data); // 实例化节点类
if (this.root == null) {// 没有根节点
this.root = newNode; // 第一个节点作为根节点
} else {
this.root.addNode(newNode);
}
}
public void print() { // 输出
this.root.printNode();// 输出全部的节点
}
}
public class CompareableDemo03 {
public static void main(String[] args) {
BinaryTree bt = new BinaryTree() ;
bt.add(3) ;
bt.add(5) ;
bt.add(1) ;
bt.add(0) ;
bt.add(1) ;
bt.add(9) ;
bt.print() ;
}
}
4.Comparator接口
Comparable接口在使用的时候直接在类中实现即可,那么现在如果一个类已经开发完成了,不能再修改,为了使此类具有排序的功能,可以使用Comparator接口完成排序的操作.
public static <T> void sort( T[] a, Comparator<? super T > c)
示例:
package com.ares.comparesdemo;
import java.util.Comparator;
public class StudentComparator implements Comparator<Student> {
// 实现比较器，并指定泛型
public int compare(Student stu1, Student stu2) {
if (stu1.getScore() > stu2.getScore()) {
return -1;
} else if (stu1.getScore() < stu2.getScore()) {
return 1;
} else {
if (stu1.getAge() > stu2.getAge()) {
return 1;
} else if (stu1.getAge() < stu2.getAge()) {
return -1;
} else {
return 0;
}
}
}
public boolean equals(Object obj) {
return this.equals(obj);
}
}
参考:
http://blog.sina.com.cn/s/blog_93daad41010115yq.html
http://javabc.baike.com/article-410985.html
http://xifeng91.iteye.com/blog/327220
20150503
JAVA学习笔记系列
--------------------------------------------
联系方式
--------------------------------------------
Weibo: ARESXIONG
E-Mail: [email protected]
------------------------------------------------