您的位置:68399皇家赌场 > 集群主机 > 【皇家赌场】Java的equals()方法

【皇家赌场】Java的equals()方法

发布时间:2019-05-23 05:52编辑:集群主机浏览(75)

     

    "=="操作符的意义

    1、用于着力数据类型的可比,相比的是值。

    贰、用于相比较对象,推断目标的引用是还是不是对准堆内部存款和储蓄器的同等块地方。

    equals的作用

     用于比较八个目的的剧情是还是不是壹律

    代码如下:

     

     1 /*
     2      * String de ==和equals
     3      */
     4     @Test
     5     public void aa5(){
     6         
     7         String s1="abc";//创建一个对象“abc”
     8         String s2="abc";//当String缓存池中存在这个指定的对象“abc”,将不会再创建新的String对象。反之,则创建新的对象
     9         String s3=new String("abc");
    10         String s4=new String("abc");
    11         System.out.print("s1==s2:");
    12         System.out.println(s1==s2);//返回true
    13         System.out.print("s3==s4:");
    14         System.out.println(s3==s4);//返回false,s3和s4是两个不同的对象
    15         System.out.println(s1.equals(s2));//返回true
    16         System.out.println(s3.equals(s4));//返回true
    17         System.out.println(s1.equals(s4));//返回true
    18     }
    

     

     equals的底层原理表明

    String.class下的equals方法

    public boolean equals(Object anObject) {
            if (this == anObject) {
                return true;
            }
            if (anObject instanceof String) {
                String anotherString = (String) anObject;
                int n = value.length;//(private final char value[];//这是String类中的value属性声明,是一个char类型的数组)
                if (n == anotherString.value.length) {
                    char v1[] = value;
                    char v2[] = anotherString.value;
                    int i = 0;
                    while (n-- != 0) {
                        if (v1[i] != v2[i])
                                return false;
                        i  ;
                    }
                    return true;
                }
            }
            return false;
        }
    

    Object.calss下的equals方法

    public boolean equals(Object obj) {
            return (this == obj);
        }
    

     

    public class equalsTest {
        public static void main(String[] args) {
            String a3=new String("33");
            A a1=new A(22);
            A a2=new A(22);
            System.out.println(a1.equals(a2));//true,使用的equals方法是重写之后的equals方法
            B b1=new B(22);
            B b2=new B(22);
            System.out.println(b1.equals(b2));//false,使用的equals是原来的
        }
    }
    class A{
        private int age;
        public A(){};
        public A(int age){
            this.age=age;
        }
           //重写equals方法
        public boolean equals(Object obj){
            A other=(A)obj;
            return this.age==other.age;
        }
    }
    class B{
        private int age;
        public B(){};
        public B(int age){
            this.age=age;
        }
    
    
    }
    

     

     

     

     

    通过几天的求学,终于对equals的用法有了相比健全的认知,并做一个总括。

    Java提高篇——equals()方法和“==”运算符,javaequals

    equals和==

      ==能够用于中央项目和引用类型:当用于着力类型时,相比值是还是不是同样;当用于引用类型时,相比较的是所针对的目的的地址是不是相同。如果有卷入档期的顺序,则先将包装类型转变为基本项目再相比较值是不是等于。当两边都为包装等级次序时,即为对象,相比的是地点。

      “==”和“!=”比较的是地点,指四个new()出来的地方。

      equals不能够功用于基本数据类型的变量,倘使未有对equals重写,则相比较的的是引用类型的变量所针对的靶子的地点。String类的equals方法重写了是相比值。

      下边是String的equals的源码:能够看出String是将字符串拆成字符挨个相比。

    public boolean equals(Object anObject) {
            if (this == anObject) {
                return true;
            }
            if (anObject instanceof String) {
                String anotherString = (String) anObject;
                int n = value.length;
                if (n == anotherString.value.length) {
                    char v1[] = value;
                    char v2[] = anotherString.value;
                    int i = 0;
                    while (n-- != 0) {
                        if (v1[i] != v2[i])
                                return false;
                        i  ;
                    }
                    return true;
                }
            }
            return false;
    }
    

     

      Integer的equals()方法如下:是Integer的实例且value值也也正是的景况下重临true,别的重临false。

     

    public boolean equals(Object obj) {
            if (obj instanceof Integer) {
                return value == ((Integer)obj).intValue();
            }
            return false;
    }
    

     

      多个基本型的封装型实行equals()相比,首先equals()会相比较类型,倘若类型同样,则持续相比较值,假如值也如出1辙,重临true。

      基本型和主题封装型举办“==”运算符的比较,基本型封装型会自动拆箱变为基本型后再开始展览比较。

     

    一.equals的原意——即在Object对象中定义的equals()方法有何的意义。

    equals()

    超类Object中有那些equals()方法,该方法首要用来相比较七个指标是或不是等于。该措施的源码如下:

    public boolean equals(Object obj) {
        return (this == obj);
        }
    

    大家清楚全数的目的都有所标记(内部存款和储蓄器地址)和气象(数据),同不时候“==”比较五个指标的的内部存款和储蓄器地址,所以说利用Object的equals()方法是比较四个目的的内部存款和储蓄器地址是还是不是等于,即若object一.equals(object2)为true,则意味着equals一和equals二实际上是援引同三个指标。就算不常候候Object的equals()方法能够满足大家有的中坚的渴求,然则大家务供给清楚大家很超过一四个月美国首都以张开七个对象的可比,今年Object的equals()方法就不可能了,实际上JDK中,String、Math等封装类都对equals()方法开始展览了重写。上边是String的equals()方法:

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = count;
            if (n == anotherString.count) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = offset;
            int j = anotherString.offset;
            while (n-- != 0) {
                if (v1[i  ] != v2[j  ])
                return false;
            }
            return true;
            }
        }
        return false;
        }
    

    对于这几个代码段:if (v一[i ] != v2[j ])return false;大家得以特别清楚的观看String的equals()方法是进展内容比较,而不是援引比较。至于别的的封装类都大致。

    equals和hashCode

      参谋博客

             

            

    (此处先附上==的功能,后边仍有描述。因为==和equals()方法的涉嫌是异常的细心的,前面有自己要好的见识。

    equals()方法和“==”运算符相比

    首先笼统的来说   “java中equals()方法和“==”运算符”   都以相比较的地址,那干什么大家在动用中总会师世模糊的景观呢老是弄错吗,那是因为“重写equals()方法”和局地“特殊情况”的留存。

    有二种用法表达:

    (一)对于字符串变量来讲,使用“==”和“equals()”方法比较字符串时,其相比较艺术分裂。

      “==”相比较三个变量本身的值,即几个指标在内部存款和储蓄器中的首地址。

      “equals()”相比字符串中所包蕴的内容是不是一致。

    比如:

    String s1,s2,s3 = "abc", s4 ="abc" ;

    s1 = new String("abc");

    s2 = new String("abc");

    那么:

    s1==s贰 是 false      //三个变量的内部存储器地址分裂样,也正是说它们对准的靶子不 同样,故不等于。

    s一.equals(s二) 是 true     //三个变量的所包蕴的内容是abc,故相等。

    注意(**1)**:

    如果:          StringBuffer s1 = new StringBuffer("a");
                       StringBuffer s2 = new StringBuffer("a");
    结果:          s1.equals(s2) //是false

    演说:StringBuffer类中绝非重新定义equals这些点子,由此这些主意就来源于Object类,而Object类中的equals方法是用来比较“地址”的,所以等于false.

    注意(**2)**:

    对此s三和s四来讲,有一点不一致样要引起注意,由于s3和s4是七个字符串常量所生成的变量,当中所存放的内部存款和储蓄器地址是相等的,所以s三==s四是true(纵然未有s三=s4那样1个赋值语句)

    (2)对于非字符串变量来讲,"=="和"equals"方法的作用是均等的都以用来比较其**对象在堆内部存款和储蓄器的首地址,即用来比较多个引用变量是还是不是对准同3个目的。**

    比如:

    class A

    {

          A obj1   =    new A();

          A obj2   = new A();

    }

    那么:obj1==obj2是false

             obj1.equals(obj2)是false

    只是如加上那样一句:obj1=obj2;

    那么 obj1==obj2 是true

           obj1.equals(obj2) 是true

    总之:equals方法对于字符串来讲是相比较内容的,而对于非字符串来讲是比较其针对性的靶子是不是同样的。

                == 相比较符也是比较指向的对象是还是不是1致的也正是指标在对内存中的的首地址。

       String类中再一次定义了equals这几个方法,而且相比的是值,而不是地点。所以是true。

    注意:

    • 若是是核心类型比较,那么只好用==来相比较,不可能用equals
    public class TestEquals {
    public static void main(String[] args) 
    {
    int a = 3;
    int b = 4;
    int c = 3;
    System.out.println(a == b);//结果是false
    System.out.println(a == c);//结果是true
    System.out.println(a.equals(c));//错误,编译不能通过,equals方法
    //不能运用与基本类型的比较
    }
    }
    
    • 对于着力项目标卷入等级次序,比方Boolean、Character、Byte、Shot、Integer、Long、Float、Double等的引用变量,==是相比较地址的,而equals是相比内容的。
    public class TestEquals {
    public static void main(String[] args) 
    { Integer n1 = new Integer(30);
    Integer n2 = new Integer(30);
    Integer n3 = new Integer(31);
    System.out.println(n1 == n2);//结果是false 两个不同的Integer对象,故其地址不同,
    System.out.println(n1 == n3);//那么不管是new Integer(30)还是new Integer(31) 结果都显示false
    System.out.println(n1.equals(n2));//结果是true 根据jdk文档中的说明,n1与n2指向的对象中的内容是相等的,都是30,故equals比较后结果是true
    System.out.println(n1.equals(n3));//结果是false 因对象内容不一样,一个是30一个是31
    }
    }
    

    那是Integer的实例,假若是其它的举例说Double、Character、Float等也一致。

    equals() 超类Object中有其一equals()方法,该格局主要用来相比八个对象是还是不是等于。该办法的...

      equals

      暗许情形(未有覆盖equals方法)下equals方法都是调用Object类的equals方法,而Object的equals方法首要用来判别指标的内存地址引用是或不是同1个地点(是还是不是同1个指标)。假设类中覆盖了equals方法,那么将在依靠现实的代码来分明equals方法的效果了,覆盖后一般都以透过对象的内容是不是等于来判断目的是或不是等于。

    ==用于比较引用和比较基本数据类型时具有不同的功能:
     比较基本数据类型,如果两个值相同,则结果为true
     而在比较引用时,如果引用指向内存中的同一对象,结果为true)
    

      hashCode

      public native int hashCode();

      它是一个本土方法,它的实现与本土机械有关,这里我们近期以为他回来的是指标存款和储蓄的概况地点(实际上不是,这里写是惠及驾驭)。

            hashcode方法只有在集合中用到。

      hashCode在饰演的剧中人物为寻域(找出有个别对象在群集中区域地点)。hashCode能够将集聚分成若干个区域,各个对象都足以总括出他们的hash码,能够将hash码分组,每一种分组对应着有个别存款和储蓄区域,依照1个对象的hash码就足以显明该目的所蕴藏区域,那样就大大缩小查询相配成分的数额,进步了查询功效。

      对于HashMap、HashSet、HashTable来说,它变得不行首要。所以在选择HashMap、HashSet、HashTable时必然要注意hashCode。

      将对象放入到聚聚焦时,首先推断要放入对象的hashcode值与聚集中的任性一个成分的hashcode值是还是不是等于,固然不等于直接将该指标放入集结中。纵然hashcode值相等,然后再通过equals方法推断要放入对象与聚集中的任性2个指标是或不是等于,即使equals判定不对等,直接将该因素放入到集合中,不然不放入。那样管理,当大家存入大批量成分时就足以大大收缩调用equals()方法的次数,十分的大地进步了频率。

    public boolean equals(Object obj)

    皇家赌场 1

     

    其比较规则为:当参数obj引用的对象与近些日子目的为同三个对象时,就回去true,不然再次回到false.

    Integer类型与int类型的==比较

    参照博客:

            

    比方来验证:

    Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
    System.out.println(f1 == f2); //true
    System.out.println(f3 == f4); //false
    

     

       同样都以Integer类型的可比,为啥用十0比的结果是true,150比的结果是false。

      给二个Integer赋予一个int类型的时候,会调用Integer的静态方法valueOf。

    public static Integer valueOf(int i) {
            assert IntegerCache.high >= 127;
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i   (-IntegerCache.low)];
            return new Integer(i);
        }
    

     

       valueof()是把int 转化成Integer对象类型;(皇家赌场,延长:intValue()是把Integer对象类型形成int的基础数据类型

      在IntegerCache中cache数组初叶化如下,存入了-128

    • 127的值。

       从下面我们能够领悟给Interger 赋予的int数值在-12八 - 127的时候,直接从cache中获得,那么些cache引用对Integer对象地址是不变的,不过不在那个范围内的数字,则new Integer(i) 那几个地点是新的地点,不容许一样的。

      使用Integer a = 1;或Integer a = Integer.valueOf(1); 在值介于-128至1二7直接时,作为着力项目。

      使用Integer a = new Integer(1); 时,无论值是有些,都看成对象。

    public class Fish {
    private int weight;
    private String color;

    延伸

      java中还会有与Integer类似的是Long,它也是有1个缓存,在间隔[-128,127]限制内取得缓存的值,而Long与long相比较的时候先转变来long类型再做值的相比

      Double类型,它并未有缓存,可是当Double与double比较的时候会先调换到double类型,再做值的可比

     

     

     

     

     

     

     

    public Fish(int weight, String color) {
        this.color = color;
        this.weight = weight;
    }
    
    public int getWeight() {
        return weight;
    }
    
    public void setWeight(int weight) {
        this.weight = weight;
    }
    
    
    
    public String getColor() {
        return color;
    }
    
    public void setColor(String color) {
        this.color = color;
    }
    

     

     

    }

    本文由68399皇家赌场发布于集群主机,转载请注明出处:【皇家赌场】Java的equals()方法

    关键词: 68399皇家赌场 编程语言 所有随笔 计算机 JavaSE

上一篇:细说前端自动化打包工具--webpack

下一篇:没有了