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

菜鸡的Java笔记 comparator 比较器的更多相关文章

  1. 菜鸡的Java笔记 - java 断言

    断言:assert (了解)        所谓的断言指的是在程序编写的过程之中,确定代码执行到某行之后数据一定是某个期待的内容        范例:观察断言 public class Abnorma ...

  2. 菜鸡的Java笔记 - java 正则表达式

    正则表达式 RegularExpression        了解正则表达式的好处        正则表达式的基础语法        正则表达式的具体操作            content (内容 ...

  3. 菜鸡的Java笔记 数字操作类

    数字操作类        Math 类的使用        Random 类的使用        BigInteger 和 BigDecimal 类的使用                Math 是一 ...

  4. 菜鸡的Java笔记 - java 线程常用操作方法

    线程常用操作方法        线程的命名操作,线程的休眠,线程的优先级            线程的所有操作方法几乎都在 Thread 类中定义好了            线程的命名和取得      ...

  5. 菜鸡的Java笔记 日期操作类

    日期操作类        Date 类与 long 数据类型的转换        SimpleDateFormat 类的使用        Calendar 类的使用                如 ...

  6. 菜鸡的Java笔记 开发支持类库

    开发支持类库 SupportClassLibrary        观察者设计模式的支持类库                    content (内容)        什么是观察者设计模式呢?   ...

  7. 菜鸡的Java笔记 简单JAVA 类的开发原则以及具体实现

    /*  现在要求定义一个雇员信息类 在这个类之中包含有雇员编号 姓名 职位 基本工资 佣金等信息    对于此时给定要求实际上就是描述一类事物,而这样的程序类在在java之中可以将其称为简单java类 ...

  8. 菜鸡的Java笔记 - java 访问控制权限

    java中四种访问控制权限的使用                内容            在java里面一共定义有四个权限,按照由小到大的顺序:private<defaule<prote ...

  9. 菜鸡的Java笔记 国际化程序实现原理

    国际化程序实现原理 Lnternationalization        1. Locale 类的使用        2.国家化程序的实现,资源读取                所谓的国际化的程序 ...

随机推荐

  1. JOIN US | SphereEx 精英集结

    新环境.新气象,SphereEx 欢迎志同道合的你加入! 关于 SphereEx 北京思斐软件技术有限公司(sphere-ex.com),是一家致力于构建新型分布式数据基础设施的公司,秉承开源.共享. ...

  2. Java JDK的下载与安装!Java基础

    在了解什么是Java.Java 语言的特点以及学习方法之后,本节将介绍如何搭建编写 Java 程序所需要的开发环境--JDK,只有搭建了环境才能敲代码! 学Java的都知道,JDK 是一种用于构建在 ...

  3. 洛谷4630APIO2018铁人两项(圆方树+dp)

    QWQ神仙题啊(据说是今年第一次出现圆方树的地方) 首先根据题目,我们就是求对于每一个路径\((s,t)\)他的贡献就是两个点之间的点数,但是图上问题我并没有办法很好的解决... 这时候考虑圆方树,我 ...

  4. centos无法建立ssl连接

    在centos下使用wget安装mysql5.7时,提示无法建立ssl连接 查阅资料,在命令wget后加上 --no-check-certificate也还是无法建立SSL连接. 后来,觉得可能是由于 ...

  5. 初识Linux shell

    目录 初识Linux shell Linux 深入探究Linux内核 系统内存管理 交换空间 页面 换出 软件程序管理 Linux中的进程 Linux系统的运行级 硬件设备管理 插入设备驱动代码的方法 ...

  6. redis两种持久化策略/存储模式

    redis的持久化策略   RDB,即 Redis DataBase,以快照形式将数据写入一个临时文件,持久化结束后,用这个临时文件替换上次持久化的dump文件,达到数据恢复. 默认开启,见redis ...

  7. springMVC上传和下载附件

    上传: 导入需要的jar包:Spring MVC类库 + 文件上传下载需要的JAR包,图中A处为文件上传下载需要的JAR包,其余为Spring MVC类库. 构建领域模层:model层和control ...

  8. 试题 历届试题 核桃的数量 java题解

    资源限制 时间限制:1.0s   内存限制:256.0MB 问题描述 小张是软件项目经理,他带领3个开发组.工期紧,今天都在加班呢.为鼓舞士气,小张打算给每个组发一袋核桃(据传言能补脑).他的要求是: ...

  9. 高效动画实现原理-Jetpack Compose 初探索

    一.简介 Jetpack Compose是Google推出的用于构建原生界面的新Android 工具包,它可简化并加快 Android上的界面开发.Jetpack Compose是一个声明式的UI框架 ...

  10. 浅尝装饰器-@staticmethod 和@classmethod

    [写在前面] 本帖归属于装饰器单元的学习,可以点击关键词'装饰器'查看其他博文讲解 [正文部分] 说到装饰器一开始我觉得很陌生,看了一下别人的博客讲解,原来以前学习遇到的静态方法@staticmeth ...