二十四,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: aresxdy@gmail.com

------------------------------------------------
相关文章
相关标签/搜索