The "==" operator. Why does not it work?

[Alam Ameghino]

Hi people! First, sorry for me bad english.

I want to get the certification, but I have some troubles.

I can not understand why this code NOT compile in the lines 20 and 21, but it compile in line 19.
Can anyone help me? Thank a lot!

public class Test16 {

	static Object o;
	static Object[] o1;
	static Object[][] o2;
	static Object[][][] o3;
	
	static Integer I;
	static Integer[] I1;
	static Integer[][] I2;
	static Integer[][][] I3;
	
	static int i;
	static int[] i1;
	static int[][] i2;
	static int[][][] i3;

	public static void main(String[] args) {
		System.out.println(o1 == o3);
		System.out.println(I1 == I3);
		System.out.println(i1 == i3);

	}

}

[Henry Wong]

al am wrote:
Hi people! First, sorry for me bad english.

I want to get the certification, but I have some troubles.

I can not understand why this code NOT compile in the lines 20 and 21, but it compile in line 19.
Can anyone help me? Thank a lot!

public class Test16 {

	static Object o;
	static Object[] o1;
	static Object[][] o2;
	static Object[][][] o3;
	
	static Integer I;
	static Integer[] I1;
	static Integer[][] I2;
	static Integer[][][] I3;
	
	static int i;
	static int[] i1;
	static int[][] i2;
	static int[][][] i3;

	public static void main(String[] args) {
		System.out.println(o1 == o3);
		System.out.println(I1 == I3);
		System.out.println(i1 == i3);

	}

}

Line 20: An Integer array object is NOT an array of array of Integer array object. And the compiler can determine that at compile time. Hence, it is a compile time error.

Line 21: An int array object is NOT an array of array of int array object. And the compiler can determine that at compile time. Hence, it is a compile time error.

Line 19: An Object Array object may be an array of array of Object array object, as an array of array of Object IS-A Object. Hence, the compiler will generate the code, to perform the check at runtime.

Henry

[Alam Ameghino]

Thanks Henry.

I can understand the things that you are saying about lines 20 and 21, but I can not understand the things that you are saying about line 19.

If line 20 NOT compile ok, so, We could say "X[] == X[][]" will not compile for any X (X is an Object, not a primitive type), but it is not true.

I can not understand why it NOT compile for any X, witt exception of X = Object.

Again, sorry for me bad enlgish. I hope you can read it ok.

Really, a lot of thanks.

[Li Qiangqiang]

sorry firstly.

 System.out.println(I1 == I3);  
                   System.out.println(i1 == i3);  

error:Incompatible operand types Integer[] and Integer[][][]
so it is wrong.

[Henry Wong]

al am wrote:
I can understand the things that you are saying about lines 20 and 21, but I can not understand the things that you are saying about line 19.

If line 20 NOT compile ok, so, We could say "X[] == X[][]" will not compile for any X (X is an Object, not a primitive type), but it is not true.

I can not understand why it NOT compile for any X, witt exception of X = Object.

Again, sorry for me bad enlgish. I hope you can read it ok.
.

First, examine the inheritance tree for Integer. I assume that you already know that an Integer IS-A Number, and Number IS-A Object, so hence, Integer IS-A Object. If we draw it out, along with other Number types, it looks like this...

Object  +----------- Number  +------------  Byte
                             |
                             +------------- Short
                             |
                             +------------- Integer
                             |
                             +------------- Long
                             |
                             +------------- Float
                             |
                             +------------- Double

Second, remember that arrays are objects. This means that an int[] is an object -- and not a primitive. In fact, the array versions of all of the primitive types are objects. Like so...

Object  +----------- Number  +------------  Byte
        |                    |
        |                    +------------- Short
        |                    |
        |                    +------------- Integer
        |                    |
        |                    +------------- Long
        |                    |
        |                    +------------- Float
        |                    |
        |                    +------------- Double
        |
        +------------- byte[]
        |
        +------------- short[]
        |
        +------------- int[]
        |
        +------------- long[]
        |
        +------------- float[]
        |
        +------------- double[]

And finally, remember that an Object[] IS-A Object, so filling in the inheritance tree for that...

Object  +----------- Number  +------------  Byte
        |                    |
        |                    +------------- Short
        |                    |
        |                    +------------- Integer
        |                    |
        |                    +------------- Long
        |                    |
        |                    +------------- Float
        |                    |
        |                    +------------- Double
        |
        +------------- byte[]
        |
        +------------- short[]
        |
        +------------- int[]
        |
        +------------- long[]
        |
        +------------- float[]
        |
        +------------- double[]
        |
        +------------- Object[]  +----------- Number[]  +------------  Byte[]
                                                        |
                                                        +------------- Short[]
                                                        |
                                                        +------------- Integer[]
                                                        |
                                                        +------------- Long[]
                                                        |
                                                        +------------- Float[]
                                                        |
                                                        +------------- Double[]

So... can you noticed that an Integer[] is NOT IS-A Integer? One is not a subclass of the other. However, an Object[] IS-A Object. One is a subclass of the other. Does that help? The Object class type is the only type with this relationship with its element type.

Henry

[Alam Ameghino]

First, I want to grateful to you A LOT.
But, there are not way. I can not understand it! I am so angry with me!

Let me explain to you through the next chart what is my problem.

For resolve it I had the next premise: "Two object are comparable (== operator) if they are in the same hierarchy"

I suppose that the next hierarchy chart that I did is correct, if it is not correct, please, let me know it.



In the hierarchy chart we can see:

- IN RED COLOR, that Integer[] and Integer[][] are not in the same hierarchy, so hence, is correct that it do NOT compile.

- IN GREEN COLOR, that Object[] and Object[][] are not in the same hierarchy, so hence, Why does it compile?

Again, sorry for me bad english!

THANKS!

[Paul Anilprem]

al am wrote:
- IN GREEN COLOR, that Object[] and Object[][] are not in the same hierarchy, so hence, Why does it compile?

THANKS!

Object[] and Object[][] ARE in the same hierarchy because as explained by Henry above, Object[] IS-A Object.

[Henry Wong]

al am wrote:
Let me explain to you through the next chart what is my problem.

For resolve it I had the next premise: "Two object are comparable (== operator) if they are in the same hierarchy"

I suppose that the next hierarchy chart that I did is correct, if it is not correct, please, let me know it.

As mentioned, the basic concept to remember is An Object[] IS-A Object. Also, by deduction...

An Object[][] IS-A Object[]
An Object[][] IS-A Object

An Object[][][] IS-A Object[][]
An Object[][][] IS-A Object[]
An Object[][][] IS-A Object

An Object[][][][] IS-A Object[][][]
An Object[][][][] IS-A Object[][]
An Object[][][][] IS-A Object[]
An Object[][][][] IS-A Object

It is probably much easier to think about it in terms of just deducing it from the basic An Object[] IS-A Object concept instead of a class hierarchy, but if you want to use a class hierarchy, then your drawing is wrong. To draw the class hierarchy, the important relationships are listed in green.

Henry

[Alam Ameghino]

Hi Paul,

Henry said that Object[] is an Object, and Object[][] is an Object. I am agree with it. But he never say that they are in the same hierarchy!


THANKS TO ALL PEOPLE!

[Henry Wong]

al am wrote:
Henry said that Object[] is an Object, and Object[][] is an Object. I am agree with it. But he never say that they are in the same hierarchy!

The only rule that you need to remember is an Object[] is an Object. Everything else you should be able to deduce it -- otherwise, it is a lot of rules to remember.

Henry

[Alam Ameghino]

Henrry, I think that I could understand to the end!

You chart help me a lot!

I did and example with their own hierarchy chart. You can see it in the image.

For me is new it. I thought that X[] is and X[][] was always false. But I can see now that X[] is and X[][], for X = Object is true!!




Please, if I am wrong let me see!

A lot of thanks!

[Alam Ameghino]

Hi people,

I noticed that the previous hierarchy chart was wrong. I did another example, and I fixed it.
This is the new hierarchy chart:

package casting;

import static java.lang.System.out;

class Bar {}

public class Test02 {
	
	static Bar[] Ba1;	static Bar[][] Ba2;	static Bar[][][] Ba3;
	
	static byte[] b1;	static byte[][] b2;	static byte[][][] b3;
	
	static int[] i1;	static int[][] i2;	static int[][][] i3;

	static Byte[] B1;	static Byte[][] B2;	static Byte[][][] B3;
	
	static Integer[] I1;	static Integer[][] I2;	static Integer[][][] I3;
	
	static Number[] N1;	static Number[][] N2;	static Number[][][] N3;
	
	static Object[] O1;	static Object[][] O2;	static Object[][][] O3;

	public static void main(String[] args) {
		out.print(O1 == b1);		out.print(O1 == b2);		out.print(O1 == b3);
		out.print(O2 == b1);		out.print(O2 == b2); 		out.print(O2 == b3);
		out.print(O1 == i1);		out.print(O1 == i2);		out.print(O1 == i3);
		
		out.print(O1 == O2);		out.print(O1 == O3);
		out.print(O2 == O3);
		
		out.print(O1 == B1);		out.print(O1 == B2);		out.print(O1 == B3);
		out.print(O1 == I1);		out.print(O1 == I2);		out.print(O1 == I3);
		out.print(O1 == Ba1);		out.print(O1 == Ba2);		out.print(O1 == Ba3);
		out.print(O2 == Ba1);		out.print(O2 == Ba2);		out.print(O2 == Ba3);
		
		out.print(Ba1 == Ba2);		out.print(Ba1 == Ba3);		
		out.print(Ba2 == Ba3);
		
		out.print(O1 == N1);		out.print(O1 == N2);		out.print(O1 == N3);
		
		out.print(N1 == N2);		out.print(N1 == N3);		
		out.print(N1 == I1);		out.print(N1 == I2);		out.print(N1 == I3);
		out.print(N2 == I1);		out.print(N2 == I2);		out.print(N2 == I3);
		out.print(N3 == I1);		out.print(N3 == I2);		out.print(N3 == I3);
		
		out.print(b1 == b2);		out.print(b1 == b3);		out.print(b2 == b3);		

		out.print(B1 == B2);		out.print(B1 == B3);		out.print(B2 == B3);		
		
		out.print(I1 == I2);		out.print(I2 == I3);		out.print(I2 == I3);
	}
}

I want to show gratitude to all people that helped me understand it, in special to Henrry.

THANKS.