Shulou(Shulou.com)06/01 Report--

This article mainly introduces "what is the difference between java== and equalse". In daily operation, I believe many people have doubts about the difference between java== and equalse. The editor consulted all kinds of materials and sorted out simple and easy-to-use methods of operation. I hope it will be helpful to answer the questions of "what is the difference between java== and equalse?" Next, please follow the editor to study!

1. Generally speaking, the comparison with equalse is the address value.

2. Compare = when comparing the basic data type with the constant pool of the wrapper class, the value is compared

3.equalse is a method and can only work on object data (Integer and other wrapper classes are also objects). By default, address values are also compared, but in most cases we override the equalse method to compare whether the property values are the same.

4. But the equalse method can be overridden. The equalse methods of the encapsulation classes Integer and String in the base type are overridden, so the values are compared

5.Integer 's constant pool is easy to understand-128 127 string also has a constant pool. We literally create String a = "xxx" which all enter the constant pool.

For the constant pool description of String, please refer to this article: https://www.cnblogs.com/tongkey/p/8587060.html

Talk about = = and equals separately, say = first, and compare different data with 1. 5%. Basic data type:

Compare whether their values are equal, such as two variables of type int, and compare whether the values of the variables are the same.

two。 Reference data type:

The comparison is whether the referenced address is the same, for example, two new User objects are created, and whether the addresses of the two User are the same.

3. Basic type wrapper class problem 3.1 wrapper class, create objects through new

The basic type of wrapper class is also an object, regardless of whether it uses a constant pool or not, as long as one party creates the object through new, it must be the address value of the comparison.

Take Integer as an example

Do not use constant pools:-128127 public static void equalsTest () {Integer A=new Integer (1); Integer B=new Integer (1); if (AbeliBs) {System.out.println ("AUBBs");} else {System.out.println ("APCBs");}} output is: public static void equalsTest () {Integer A=new Integer (128); Integer B=new Integer (128) The output result of if (obtainable B) {System.out.println ("AblabB");} else {System.out.println ("obtainable B");}} is: when the wrapper class of basic type of obtainable B3.2 creates an object without using new

Take Integer as an example

At-128 127, constant pool data is used to compare object values; when constant pools are not used, address values are compared

When using a constant pool,-128 127 public static void equalsTest () {Integer Aggluttel 127; Integer Bang Must127; if (Avatar B) {System.out.println ("Aban B");} else {System.out.println ("Avatar B");}} the output result is: when Abel B does not use a constant pool, it compares the address value public static void equalsTest () {Integer auction 128; Integer Ball128. The output result of if (averaged aggregate B) {System.out.println ("averaged B");} else {System.out.println ("averaged roomB");}} is as follows: the special case of averaged B3.3 Integer Integer is assigned a value of 128 whenever compared with the int type, and the constant pool public static void equalsTest () {Integer A=new Integer (128) is not used; int Back128 The output result of if {System.out.println ("Integer B");} else {System.out.println ("invalid B");}} is as follows: looking at the source code and finding that Integer will only compare the values of int / *. The result is * {@ code true} if and only if the argument is not * {@ code null} and is an {@ code Integer} object that * contains the same {@ code int} value as this object. * * @ param obj the object to compare with. * @ return {@ code true} if the objects are the same; * {@ code false} otherwise. * / public boolean equals (Object obj) {if (obj instanceof Integer) {return value = = ((Integer) obj) .intValue ();} return false;} 3.4 constant pools are also used to compare values (constant pools are used in most cases)

We usually use String A = "hello"; all variables created in this way go into the string constant pool

This creation method will use the constant pool public static void equalsTest () {String A = "hello"; String B = "hello"; if (AbeliBs) {System.out.println ("AUBBs");} else {System.out.println ("ASABs");}} the output result is: String A = "hello". All variables created in this way are all modified by the final of the String class. When you create a String variable literally, jvm will put the literal ("hello") into the string constant pool during compilation and has already been loaded into memory when the Java program starts. The characteristic of this string constant pool is that there is only one and only one literal. If there are other identical literals, jvm returns a reference to this literal quantity. If there is no same literal quantity, create this literal quantity in the string constant pool and return its reference.

3.5 when constant pools are not used in the String type, address values are compared

The output result of public static void equalsTest () {String A = "hello"; String B=new String ("hello"); if (Achievement B) {System.out.println ("AbeliB");} else {System.out.println ("Achievement B");}} output is as follows: a new creates an object using a new object, and the result is naturally unequal public static void equalsTest () {String A = "hello" String B=new String ("hello"); / / A reference to hello that becomes a constant pool B=B.intern (); if (alternate pool B) {System.out.println ("if B");} else {System.out.println ("alternate pool B") }} the output result is: a = B2 and equalse are methods, which can only be used on object data (Integer and other wrapper classes are also objects). The default is to compare address values by default or to compare address values by default. But it can be rewritten.

In most classes in Java class libraries, such as primitive types, the equalse methods that encapsulate classes Integer and String are overridden, so values are compared

Usually, we use the equalse override method to compare whether the attribute values inside the object are the same.

3. When the value is the same, the hashcode may not be the same.

Conclusion: the hashcode is the same, the value is not necessarily the same, the value is the same hashCode must be the same (rewrite hashCode method)

1. Why the ashcode is the same, the value must be the same, the value is not necessarily the same hashCode

HashCode is the inherent method of all java objects, and if you don't override it, it actually returns the memory address of the object on the jvm heap, and the memory address of different objects must be different, so the hashCode must be different. If rewritten, it is possible that the hashCode of two different objects will be the same due to the problem of the algorithm used.

The relationship between 2.hashCode and equalse

The two methods hashCode and equals are semantically related, and they need to satisfy:

A.equals (B) = = true-> A.hashCode () = = B.hashCode ()

So when you override one of the methods, you also need to rewrite the other.

3.HashCode method rewriting needs to meet the specification

If two objects are equal according to the equals (Object) method, calling the hashCode method on each of the two objects must produce the same integer result.

The rewriting implementation of hashCode needs to satisfy the invariance, that is, the hashCode of an object cannot be 1 and become 2 after a while.

The rewriting implementation of hashCode is preferably dependent on the final property in the object so that it no longer changes after the object is initialized and constructed. On the one hand, jvm facilitates code optimization and caches the hashCode;. On the other hand, in scenarios using hashMap or hashSet, if the hashCode of the key used will change, it will lead to bug, such as key.hashCode () = 1 when it is put in. When key.hashCode () = 2, the original data cannot be taken out.

Why does 4.hashCode have the same situation?

Take hashSet as an example, the underlying structure of hashSet JDK1.8 was in the form of array + linked list, followed by array + linked list + red-black tree.

Take 1.8 as an example:

When you add elements to the hashSet collection, you need to go through two steps

Calculate hashcode and compare it with hashcode in hashSet array

If there is the same hashcode, use equals to compare the contents of the hash, and save it to the collection if different

So the same hashcode does not necessarily have the same value, but if the value is the same, then his hashcode must be the same.

4. As long as you use HashSet to store data of custom types, remember to override the equals and hashCode methods so far, and the study of "what's the difference between java== and equalse" is over. I hope you can solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.