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
536
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
