1.数组操作类: Arrays
2.两种比较器的使用: Comparable Comparator
3.实现二叉树算法
content (内容)
1.数组操作类: Arrays
Arrays 类一早就开始使用了。最早使用的是它的排序操作,但是现在打开 Arrays 观察一下有那些方法
二分查找法: public static int binarySearch(数据类型[] a,数据类型 key)
数组比较: public static boolean equals(数据类型[] a,数据类型[] a2)
数组的填充: public static void fill(数据类型[] a,数据类型 val)
数组转换为String输出: public static String toString(数据类型[] a)
范例:二分查找
package cn.mysterious.study3; import java.util.Arrays; public class StudyComparator { public static void main(String[] args) { // TODO Auto-generated method stub int data [] = new int[]{1,29,93,44,55,666,7,788,99}; java.util.Arrays.sort(data); System.out.println(Arrays.binarySearch(data, 7)); } }
范例:数组比较
package cn.mysterious.study3; import java.util.Arrays; public class StudyComparator { public static void main(String[] args) { // TODO Auto-generated method stub int dataA [] = new int[]{1,29,93,44,55,666,7,788,99}; int dataB [] = new int[]{1,29,93,44,55,666,7,788,99}; System.out.println(Arrays.equals(dataA, dataB)); } }
范例:数组填充
package cn.mysterious.study3; import java.util.Arrays; public class StudyComparator { public static void main(String[] args) { // TODO Auto-generated method stub int data [] = new int[]{1,29,93,44,55,666,7,788,99}; Arrays.fill(data, 10); System.out.println(Arrays.toString(data)); } }
在 Arrays 类中几乎包含了所有可能使用到的数组相关操作 重要的是这些方法的原理因为面试题或面试上会问到
2.比较器: Comparable
在 Arrays 类中提供有一个方法: public static void sort(Object[] a)
此方法可以直接针对对象数组进行排序的操作
但是如果现在真的要进行对象数组的排序,并不是意味着直接调用次方法即可
如果直接调用就有可能出现如下的错误信息:
Exception in thread "main" java.lang.ClassCastException:
cn.mysterious.study3.Person cannot be cast to java.lang.Comparable
之所以造成这样的问题,是因为如果要想进行对象数组的排序,必须要解决数据大小关系的问题,然而对象无法区分出大小关系
那么为了解决这样的问题 java 会自动的在排序的时候将所有的对象强制转换为 Comparable 接口对象
也就是说如果要想实现对象数组的自动排序,那么对象所在的类一定要实现 Comparable 接口
public interface Comparable<T>{ public int compareTo(T o) }
String 累中的 comparaTo() 方法本身就是覆写了 Comparable 接口中的 comparaTo() 方法,而如果说用户现在需要进行排序
实际上只需要返回三个内容即可:0,-1,1
范例:对象数组的排序实现
package cn.mysterious.study3; 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; } public void setAge(int age) { this.age = age; } @Override public String toString() { // TODO Auto-generated method stub return "姓名:" + this.name + ",年龄:" + this.age + "\n"; } @Override public int compareTo(Person o) { // TODO Auto-generated method stub if (this.age > o.age) { return 1; }else if(this.age > o.age){ return -1; }else { return 0; } // 简化操作: return this.age - o.age; } } public class StudyComparator { public static void main(String[] args) { Person per[] = new Person[]{ new Person("小少爷",15), new Person("大少爷",35), new Person("二少爷",28), }; Arrays.sort(per); System.out.println(Arrays.toString(per)); } }
结论:以后不管何种情况下,只要是进行对象数组的排序,一定要使用 Comparable 接口完成
实现二叉树算法( Binary Tree ,(简称:BT) )
二叉树也好,链表也好,本质是一样的,目的就是为了保存数据,实现动态的对象数组
所有的数据结构都一定有一个前提:必须痛过节点来进行数据的包裹,目的:确定先后顺序
那么现在也对 Node 进行修改,让其可以保存对象( Object Comparable ),但是现在每个节点上要保留有两个子节点:左子树,右子树
保存的原则:比根节点小的数据放在左子树,比根节点大于等于的数据保存的右子树
最后按照中序遍历(左-根-右)的方式可以取得内容,所以数据是排序后的结果
范例:实现基础的二叉树 StudyTwoForkTree
package cn.mysterious.study3; 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; } public void setAge(int age) { this.age = age; } @Override public String toString() { // TODO Auto-generated method stub return "姓名:" + this.name + ",年龄:" + this.age + "\n"; } @Override public int compareTo(Person o) { return this.age - o.age; } } class BinaryTree{ // 二叉树的实现类 private class Node{ // 数据结构中必须有 Node 类,负责保存数据以及节点的关系匹配 @SuppressWarnings(value = "rawtypes") private Comparable data; private Node left;//比根节点小的内容 private Node rigth;//比根节点大或等于的内容 @SuppressWarnings("unused") public Node( @SuppressWarnings("rawtypes") Comparable data){ this.data = data; } @SuppressWarnings("unchecked") public void addNode(Node newNode) { // TODO Auto-generated method stub if (this.data.compareTo(newNode.data) > 0) { // 保存在左边 if (this.left == null) { this.left = newNode; }else { this.left.addNode(newNode); } }else { if (this.rigth == null) { this.rigth = newNode; } else { this.rigth.addNode(newNode); } } } public void toArrayNode() { // TODO Auto-generated method stub if (this.left != null) {// 有左节点 this.left.toArrayNode(); } BinaryTree.this.retData[BinaryTree.this.foot ++] = this.data; if (this.rigth != null) { this.rigth.toArrayNode(); } } } //****** 编写 BinaryTree 的操作 ****** private Node root; //必须保留根节点 private int count = 0; private int foot = 0; private Object[] retData; @SuppressWarnings("rawtypes") public void add(Object obj) { //数据的追加 Comparable data = (Comparable)obj; Node newNode = new Node(data);// 将数据包装在 Node 节点之中 if (this.root == null) { this.root = newNode; }else { this.root.addNode(newNode); } this.count ++; } public Object[] toArray(){ if (this.count > 0) { this.foot = 0; this.retData = new Object[this.count]; this.root.toArrayNode(); return this.retData; } else { return null; } } } public class StudyTwoForkTree { public static void main(String[] args) { BinaryTree bt = new BinaryTree(); bt.add(new Person("小少爷",15)); bt.add(new Person("大少爷",35)); bt.add(new Person("二少爷",28)); System.out.println(Arrays.toString(bt.toArray())); } }
如果想收入高一些的可以适当的把代码写的完善一些
比较器: Comparator
通过 Comparable 的观察可以发现,如果一个类的对象要想进行对象数组排序,那么这个类在定义的时候就必须明确的实现好 Comparable 接口
但是有没有这样一种可能性出现,一个类原本定义完成了,原本是没有排序要求的,可是后期却需要追加排序,并且这个类已经不能够修改了
那么在这种情况下,就可以利用另外一个接口完成排序: java.util.Comparator 接口
此接口定义如下:
@FunctionalInterface public interface Comparator<T>{ public int compare(T o1,T o2) public boolean equals(Object obj) }
如果要想继续使用 Arrays 实现排序操作,那么就必须观察新的排序方法:
排序: public static <T> void sort(T[] a,Comparator<? super T> c)
范例:定义一个单独的 Person 类
class Person { private String name; private int age; public Person(){} public Person(String name,int age){ this.name = name; this.age = age; } public void setAge(int age) { this.age = age; } @Override public String toString() { // TODO Auto-generated method stub return "姓名:" + this.name + ",年龄:" + this.age + "\n"; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public String getName() { return name; } }
前提: Person 类不允许发生改变
范例:实现单独的比较器
package cn.mysterious.study3; import java.util.Comparator; class Person { private String name; private int age; public Person(){} public Person(String name,int age){ this.name = name; this.age = age; } public void setAge(int age) { this.age = age; } @Override public String toString() { // TODO Auto-generated method stub return "姓名:" + this.name + ",年龄:" + this.age + "\n"; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public String getName() { return name; } } class PersonComparator implements Comparator<Person>{ @Override public int compare(Person o1, Person o2) { // TODO Auto-generated method stub return o1.getAge() - o2.getAge(); } } public class ComparatorClass { public static void main(String[] args) { Person per[] = new Person[]{ new Person("小少爷",15), new Person("大少爷",35), new Person("二少爷",28), }; Arrays.sort(per,new PersonComparator()); // 编写排序 System.out.println(Arrays.toString(per)); } }
面试题:请解释两种比较器的区别?
在进行对象数组排序的过程之中需要使用到比较器,比较器有两个: Comparator Comparable
java.util.Comparable :是在类定义的时候默认实现好的接口。里面提供有一个 comparaTo() 方法用于比较大小
java.util.Comparator :需要单独定义一个排序的比较规则类,里面有两个方法: compare(),equals()
总结
以后如果开发中考虑到排序的需求,优先考虑使用 Comparable 接口,不到万不得已不要使用 Comparator