Java,重写Comparable比较方法,重写equals方法, Long 与 Long equals,Long 与 Long == ,Long 与 long ==

Posted 2022-04-17 二十六画生的博客

jdk1.8

1 重写Comparable比较方法
2 重写equals方法
3 Long 与 Long equals,Long 与 Long  == ,Long 与 long  == 

package com.bd1;

import java.util.ArrayList;
import java.util.Collections;

/**
 * @Author you guess
 * @Date 2022/4/13 16:38
 * @Version 1.0
 * @Desc 1 重写Comparable比较方法
 * 2 重写equals方法
 * 3 Long 与 Long equals,Long 与 Long  == ,Long 与 long  == ,
 */

public class UDClass implements Comparable<UDClass>  //实现Comparable接口

    private Long time;
    private String remark;

    public UDClass(Long time, String remark) 
        this.time = time;
        this.remark = remark;
    

    @Override//不管是否把@Override注释掉，均会执行这个重写的compareTo方法
    public int compareTo(UDClass other) //重写，按照time升序，time大的元素放后面
        System.out.println("进入compareTo......");
        if (this.time > other.time) 
            return 1;
         else if (this.time < other.time) 
            return -1;
        
        return 0;
    

    @Override//不管是否把@Override注释掉，均会执行这个重写的equals方法
    public boolean equals(Object obj) 
        System.out.println("进入equals......");
        //this是对象a1，obj是对象a2
        if (this == obj) 
            return true;//地址相等
        
        if (obj == null) 
            return false;//非空性：对于任意非空引用x，x.equals(null)应该返回false。
        

        if (obj instanceof UDClass) 
            UDClass other = (UDClass) obj;
            //String类型是比较每位字符，Long类型是转为long后比较值
            if (other.remark.equals(remark) && other.time.equals(time)) 
                return true;
            

        
        return false;
    

    public String toString() 
        return remark;
    

    public Long getTime() 
        return time;
    

    public void setTime(Long time) 
        this.time = time;
    

    public String getRemark() 
        return remark;
    

    public void setRemark(String remark) 
        this.remark = remark;
    

    public static void main(String[] args) 
        ArrayList list = new ArrayList();
        UDClass a1 = new UDClass(1L, "remark1");
        UDClass a2 = new UDClass(1L, "remark1");
        UDClass a3 = new UDClass(3L, "remark3");
        UDClass a4 = new UDClass(0L, "remark0");
        list.add(a1);
        list.add(a2);
        list.add(a3);
        list.add(a4);

        for (Object a : list) 
            System.out.println(((UDClass) a).getTime());
            System.out.println(((UDClass) a).getRemark());
        
        System.out.println("----------------");
        Collections.sort(list);//会调用重写的compareTo方法
        for (Object a : list) 
            System.out.println(((UDClass) a).getTime());
            System.out.println(((UDClass) a).getRemark());
        
        System.out.println("----------------");


        /**
         * 如果不重写equals方法，则是调用Object.java类中的equals方法，直接是==比较
         * public boolean equals(Object obj) 
         *         return (this == obj);
         *     
         * 则是返回false
         * ----
         *
         * 如果重写了equals方法，则调用这个自己重写的方法,返回true
         */
        System.out.println(a1.equals(a2));

        System.out.println("----------------");

        Long aL = 1L;
        Long bL = 1L;
        System.out.println(aL == bL);//true
        System.out.println(aL.equals(bL));//true，是转化为long值后再比较的

        long cL = 1L;
        Long dL = 1L;
        System.out.println(cL == dL);//true
        //System.out.println(cL.equals(dL));//报错，Cannot resolve method 'equals(java.lang.Long)'
       
        System.out.println("----------------");

        Long eL = new Long(1L);//false
        System.out.println(aL == eL);//true
        System.out.println(aL.equals(eL));//true，是转化为long值后再比较的
    

输出：

1
remark1
1
remark1
3
remark3
0
remark0
----------------
进入compareTo......
进入compareTo......
进入compareTo......
进入compareTo......
进入compareTo......
0
remark0
1
remark1
1
remark1
3
remark3
----------------
进入equals......
true
----------------
true
true
true
----------------
false
true

Collections.sort(list) 执行前：

Collections.sort(list) 执行后：

Long == Long :  指向同一个对象，返回true

 Long == long :  Long会转为long后再比较值

Long == new Long(): 指向2个不同的对象，返回false