Java 比较器

比较器

Arrays 类

主要功能：

• 完成所有与数组有关的操作的工具类

二分查找：

• 在一个有序的数字序列中进行二分查找

public static int binarySearch(数据类型 [] a , 数据类型 key)

案例实现

public class TestDemo {
	public static void main(String [] args) throws ParseException {
		int date [] = new int [] {1,4,2,5,7,4,3,8} ;
		java.util.Arrays.parallelSort(date); // 排序
		System.out.println(Arrays.binarySearch(date, 3)); // 二分查找
		
	}
}

数组比较：

public static boolean equals(数据类型 [] a , 数据类型 [] b)

和Object.equals()没有任何关系，本次的arrays中的equals比较的是数组不是对象。

public class TestDemo {
	public static void main(String [] args) throws ParseException {
		int dateA [] = new int [] {1,4,2,5,7,4,3,8} ;
		int dateB [] = new int [] {1,4,2,5,7,4,3,8} ;
		System.out.println(Arrays.equals(dateA, dateB));
	}
}

比较器：Comparable *

对象数组排序

public static void sort(Object [] a);

Arrays类可以直接利用 sort() 方法实现对象数组的排序

• 测试代码 *

class Book implements Comparable<Book> { //使用比较器
	private String title ; 
	private double price ; 
	public Book (String title , double price) {
		this.title = title ;
		this.price = price ; 
		
	}
	public String toString() {
		return this.title + "   " + this.price;
	}
	@Override
	public int compareTo(Book o) { 
		// compareTo 方法由 Arrays.sort()方法自动调用
		if (this.price > o.price) {
			return 1 ;
		} else if (this.price < o.price){
			return -1 ;
		} else {
			return 0 ;
		}
	}
}

public class TestDemo {
	public static void main(String [] args) throws ParseException {
		Book books [] = new Book [] {
				new Book("java",23),
				new Book("python",20),
				new Book("php",11),
				new Book("C/C++",44)
		} ;
		Arrays.parallelSort(books);// 排序
		System.out.println(Arrays.toString(books));
	}
}

要对某个对象进行数组排序，对象所在的类一定要实现 Comparable 接口，覆写compareTo()方法。

二叉树结构：BinaryTree

• 数，是一种比链表更为复杂的概念，本质也属于动态对象数组，但是与链表相比，数更有利于数据进行排序。

数的操作原理

• 选择一个数据作为根节点，而后比根节点小的数据放在根节点左节点，比左节点小的放在根节点的右节点。按照 中序 进行遍历。

class Book implements Comparable<Book> { //使用比较器
	private String title ; 
	private double price ; 
	public Book (String title , double price) {
		this.title = title ;
		this.price = price ; 
		
	}
	public String toString() {
		return this.title + "   " + this.price;
	}
	@Override
	public int compareTo(Book o) { 
		// compareTo 方法由 Arrays.sort()方法自动调用
		if (this.price > o.price) {
			return 1 ;
		} else if (this.price < o.price){
			return -1 ;
		} else {
			return 0 ;
		}
	}
}

class BinaryTree {
	private class Node{
		private Comparable data ;
		private Node left ;
		private Node right ; 
		public Node (Comparable data) {
			this.data = data ;
		}
		public void addNode(Node newNode) {
			if (this.data.compareTo(newNode.data) < 0 ) {
				if (this.left == null) {
					this.left = newNode ;
				}else {
					this.left.addNode(newNode);
				} 
			}else {
				if (this.right == null) {
					this.right = newNode ;
				} else {
					this.right.addNode(newNode);
				}
			}
		}
		public void toArrayNode () {
			if (this.left != null) {
				this.left.toArrayNode();
			}
			BinaryTree.this.retData[BinaryTree.this.foot ++] = this.data;
			if (this.right != null) {
				this.right.toArrayNode();
			}
		}
	}
	private Node root ; // 定义根节点
	private int count = 0 ;
	private Object [] retData;
	private int foot;
	public void add(Object obj) {
		Comparable com = (Comparable) obj ;// 必须转为 Comparable
		Node newNode = new Node(com); //创建新的Node节点
		if (this.root == null) {
			this.root = newNode ;
		} else {
			this.root.addNode(newNode);
		}
		this.count ++ ;
	}
	public Object [] toArray(){
		if (this.root ==null) {
			return null;
		}
		this.foot = 0 ;
		this.retData = new Object [this.count] ;
		this.root.toArrayNode();
		return this.retData;
	}
}

public class TestDemo {
	public static void main(String [] args) {
		BinaryTree bt = new BinaryTree();
		bt.add(new Book("java",23));
		bt.add(new Book("python",20));
		bt.add(new Book("php",11));
		bt.add(new Book("C/C++",44));
		Object obj [] = bt.toArray();
		
		System.out.println(Arrays.toString(obj));
	}
}

Comparator接口(下下策)

• 该接口是一个函数式接口：即只有继承方法

@FunctionalInterface
public interface Comparator<T> {
    public int compare(T o1 , T o2);
    public boolean equals(Object obj);
}

我们可以借助该接口，将没有实现Comparable接口的类，进行改变；

实现该接口，创建一个“工具类”，实现Book类对象的排序需求

class Book { 
	private String title ; 
	private double price ; 
	public Book (String title , double price) {
		this.title = title ;
		this.price = price ; 
	}
	public String getTitle() {
		return title;
	}
	public double getPrice() {
		return price;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public String toString() {
		return this.title + "   " + this.price;
	}
}

class BookComparator implements Comparator<Book>{ // 比较器工具
	@Override
	public int compare(Book o1, Book o2) {
		if (o1.getPrice() > o2.getPrice()) {
			return 1;
		} else if (o1.getPrice() > o1.getPrice()){
			return -1;
		}else {
			return 0 ;
		}
	}
}

public class TestDemo {
	public static void main(String [] args) {
		Book books [] = new Book [] {
				new Book("java",23),
				new Book("python",20),
				new Book("php",11),
				new Book("C/C++",44)
		} ;
		Arrays.parallelSort(books,new BookComparator());
		
		System.out.println(Arrays.toString(books));
	}
}

• 区别：

  comparable是在一个类定义阶段实现的接口类，而comparator则需要专门定义一直指定的类。

总结

• 涉及到对象数组的排序，就使用Comparable接口
• 根据实际情况掌握 二叉树代码