Varargs and arrays - Mughal's mock exam, question 60

[T Vergilio]

from Mughal's mock exam, question 60:

public class Varargs {
public static <E> void print(E e, E...src) {
System.out.print("|");
for (E elt : src) {
System.out.print(elt + "|");
}
System.out.println();
}
public static void main(String[] args) {
String[] sa = {"9", "6"};
print("9", "6"); // (1)
print(sa); // (2)
print(sa, sa); // (4)
print(sa, sa, sa); // (5)
print(sa, "9", "6"); // (6)
}
}

I have a problem with line 6. As far as the generic print method is concerned, the element <E> is a String array, right? So the varargs E...src would be an array of String arrays?

How do the Strings "9" and "6" get interpreted as being an array of Strings? They are passed to the print method individually...

[Seetharaman Venkatasamy]

Chandella Montero wrote:How do the Strings "9" and "6" get interpreted as being an array of Strings?

the second argument "6" interpreted by the compiler as new String[]{"6"} . so it matches the parameter E ... src again it is interpreted as Object[] src.

For better understanding I do suggest you to use decompiler on .class file

[Mike Zal]

Edit: comment removed after having access to compiler

[Jeane Lindford]

Seetharaman Venkatasamy wrote:
the second argument "6" interpreted by the compiler as new String[]{"6"} . so it matches the parameter E ... src again it is interpreted as Object[] src.
For better understanding I do suggest you to use decompiler on .class file

I still didn't understand
can you give me more details?
I've decompiled and opened the .class file but I didn't understand much
and I've made this test inside print method:

System.out.println(e instanceof String[]);
System.out.println(src instanceof Object[]);

both return true
so I've found the correct types (I think)
but I still can't understand why src is an Object[] and not a String[]
thanks

[deca leni]

Generics are a facility of allowing "a type or method to operate on objects of various types while providing compile-time type safety".so
common use of this feature is when using a Java Collection that can hold objects of any type, to specify the specific type of object you will be storing in it.so it depends on the objects types.and you can not directly that both of them are String..

when it is come to "String" they always create a new object in the memory so each time you pass a "String" value there is new object.so I'll explain line by line.

public class Varargs {  
public static <E> void print(E e, E...src) {  

"E e" means you can pass any types of single value.
"E... src" means you can pass any types of multiple value
that belongs to same type.means array reference.
so it could be a 0-any number of length array.so you can pass value only if you need.

 
System.out.print("|"); 
for (E elt : src) {

"E elt" like "E e". "sre" is an array refrence.(I think you know it.if you don't please check about it
about foreach)

  
String[] sa = {"9", "6"};
print("9", "6"); 

this is a String type array object
you pass 1 value to first"E e" and 1 value to the second"E... src"

print(sa);

you pass "sa" array to the first and no value to the second.yes you can do because array length can be 0-any number

print(sa, sa);

you pass 1 value as "sa" to first parameter and to the scened parameter pass "sa" array then it prints "sa" values

print(sa, sa, sa);

you pass 1 value as "sa" to first parameter and to the scened parameter pass "sa" 2 time
means that "sre" array now seems like this src[0]=sa ,src[1]=sa now "" is an object array

print(sa, "9", "6");

as I told you every single String create new Object "9" "6" both create individual objects.and referenced
to "src" array src[0]="9" ,src[1]="6" but these are objects not just a Strings.when we print String objects
it prints the real String value because there is a method call toString() in String class.but still String is an object type

try this code

public class Varargs {  
public static <E> void print(E e, E...src) {
System.out.print("e value is type of String:");  
System.out.println(e instanceof String); 
System.out.print("e value is type of String arry:");
System.out.println(e instanceof String[]);
System.out.print("sre value is type of object array:");
System.out.println(src instanceof Object[]);
 
System.out.print("|"); 
 
for (E elt : src) {  
System.out.println(elt + "|"); 
  
}  
System.out.println("\n"+"--------------------");  
}  
public static void main(String[] args) {  
String[] sa = {"9", "6"};  
print("9", "6"); // (1)  
print(sa); // (2)  
print(sa, sa); // (4)  
print(sa, sa, sa); // (5)  
print(sa, "9", "6"); // (6) 

}  
}

[deca leni]

deca leni wrote:Generics are a facility of allowing "a type or method to operate on objects of various types while providing compile-time type safety".

if more explanation let me know..

[Seetharaman Venkatasamy]

Jeane Lindford wrote:

System.out.println(e instanceof String[]);
System.out.println(src instanceof Object[]);

what happened when you run System.out.println(src instanceof String[]); ?

actually all the generic information is erased by the compiler at compile time. so all the types T are replaced by the super type of object i.e, java.lang.Object. this type eraser introduced for the backward compatibility.

[T Vergilio]

Deca, I tried compiling and running your code, and indeed, it seems like what is passed to the method is an Object, followed by an Object array.

I still don't get why

public static <E> void print(E e, E...src)

compiles without warnings. Doesn't the compiler check that E is used to refer to the same type at compile time?

And how come if I change the class declaration to:

public static <E, Y> void print(E e, Y...src)

and the for loop declaration to

for (Y elt : src) { 

I get a warning:

Varargs.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

Can anyone explain? This is driving me insane!

[deca leni]

yep you right...look at here

public static <E> void print(E e, E...src) {  
System.out.print("|");  
for (E elt : src) {  
System.out.print(elt + "|");  
}

though you pass 2 parameter values, it prints only values of "E...src".
"E elt" variable reference. it gets the current value of the "src" array value.
this is how loop work.
in first round "E elt" gets the src[0] then and print
in next time "E elt" gets the src[1] then and print
in next time "E elt" gets the src[2] then and print
so on until it reach the end of the array.

remember, the disasters happen at runtime not the compile time.most of compilers generate warnings to tell you when you are using a unsafe(non-generic) collection.non generic is quit happy to hold anything that is not primitive.so programmer have to be careful.
generic code(type safe) can be integrated with legacy(non-generic) code after java5 .the code I gave you is not generic safe.but think generic as strictly a compile time protection. the compiler uses generic type (the <type> in the angle brackets) to make sure that your doesn't put the wrong thing in to a collection.and that you don't assign what you get from a collection to the wrong reference type.But none of this protection exists at run time.that's why the disasters happen at runtime.

BUT this is different from Arrays.
they give both compile/run time protection.

try this code..

public class Varargs { 
 
public static <E> void print(E e, E... src) {//old non-generic
System.out.print(e);
System.out.print("|");
 
for (E elt : src) {  
System.out.println(elt + "|"); 
  
}  
System.out.println("\n"+"--------------------");  
} 
// now I'm goin to mix old non-genaric(type unsafe) code with generic(type safe) code

public static void printMe(String e,String... src){/*#1 new generic safe methos code
												 *now you can pass String types values only
												 */
print(e,src);//old non-generic
}

public static void main(String[] args) {  
String[] sa = {"9", "6"};//satring array

/** Note Generic as strictly a compile time protection.the compiler uses generic type 
*(the <type> in the angle brackets) to make sure that your doesn't put 
*the wrong thing in to a collection
*if use wrong values then it will give you a compile time error.
*use abow methods with relevent values.
*/
printMe("String", "6"); //#1  
printMe("String",sa); //#1

}  
}

[deca leni]

try to learn about Generic and Collection class of Java DOC then you'll be able to get more information about this..

[Jeane Lindford]

I've made

System.out.println(e instanceof String[]);
System.out.println(src instanceof Serializable[]);

and both returned true
so the first one was transformed in a String and the second one in a Serializable array, not an Object as I was thinking (but since an instantiated Serializable is an Object, it passes the IS-A test [and an Object[] can receive any kind of not primitive array])
oh man, this is driving me crazy too lol
I think I need to understand better the rules of generics types transformation... where I can find this info?

[Seetharaman Venkatasamy]

Jeane Lindford wrote:
I think I need to understand better the rules of generics types transformation... where I can find this info?

always *google* is there to help you. however *Core Jva volume-1 by Horstmann* book is fantastic on generics .

Note: for your information, String implements serializable

[Andreas Svenkson]

This is a tricky topic, atleast imho, and I would also have reasoned like the original poster at first - thinking E would be String[] and src a String[][].

Here's what I think is going on instead, and I may very well be wrong....

For some reason, for a method call of the type:

    print(sa, "9", "6"); // (6)  

... the compiler is deciding that the generic type E should be java.io.Serializable.

This works fine for a String array, since this implements Serializable. What happens next is that for the vararg call, the two arguments "9" and "6" are stuffed into a Serializable[], basically since they are both Strings they are a match for a "Serializable...v" vararg method signature, which is why we end up with a Serializble[] called 'src'.

I believe this is what happens, and if I were to guess I think that the reason is this: Serializable is the first superclass (yes I know it's an interface, but we're talking about an IS-A test in essence, class or interface), to which both a String[] and a String can be converted. Obviously I would say this is a very simplified explanation, but in essence I think that's the reasoning that the compiler goes through when it attempts to lock down what the type E should be for this method invocation, with these specific arguments.

One thing I can say for sure though for generic methods, with dual parameters referring to the generic type: the first argument to the method NOT necessarily the type that sets the rules for what the type E should be for any said method invocation. It may very well be the second argument, so don't be fooled looking only at what was the first argument sent, the generic type may well be locked down decisively by what was passed in as a second argument - in my experience it all depends on what you send in and what those arguments can be converted to in order to match the method signature.

// Andreas

[Tommy Delson]

See my comments and analysis below for more info...hope it help.

public class Varargs { //No type is specified for the class Varargs so, Varargs class is not generic, but print() method does.

	//The <E> is a placeholder for the type you pass in, any other identifier is valid.
	//Creating Generic Methods - The <E> before void simply defines what E is before you
	//use it as a type in the argument. <E> is a placeholder for String type in this case
	public static <E> void print(E e, E...src) { //uses the parameterized type of the method as argument type
												 // var-args "E... src" accepting zero to many arguments
		System.out.print("|");

		for (E elt : src) { //Retrieve an element from "src" array using enhanced for loop
							//E type must match with "src" type which is String
				System.out.print(elt + "|");
		}

		System.out.println();
	}

	public static void main(String[] args) {

		String[] sa = {"9", "6"}; //Declare, construct, and initialized an array of type String

		print("9", "6"); // (1) Work - Passing 2 arguments literal String to a print() method that takes
		                 //(String e, String... src). It works because it match the number of arguments and String type.
		                 //The var-arg "src" meant zero to many so, in this case we have one argument "6" type String.

		print(sa); // (2) - Work - Matching number of argument despite passing only 1 argument. Hence var-args accepting
		           //zero to many arguments.

		print(sa, sa); // (4) - Compile with warning and run without any problem. Warning because the compiler doesn't like you're passing
		               //       an array "sa" type String to print() method that take var-args arguments type Serializable super of String.
                              //If you pass 3 or more "sa" to print() method the compiler will treats as var-args.

		print(sa, sa, sa); // (5) - Work - Hence matching number of arguments, any extra "sa" compiler treated this as passing var-args.

		print(sa, "9", "6"); // (6) - Work - Hence matching number of arguments, the compiler treated second and third argument as var-args.
	}
}


/*

This type of scenarios called "Creating Generic Methods", check page 665 in K & B book for more insight. And the use
of parameterized type of the method as argument and var-args.

It's straight forward, reread all the Generic topic to clear your doubt.


Compile with warning on (4):
Varargs.java:25: warning: non-varargs call of varargs method with inexact argument type for last parameter;
cast to java.io.Serializable for a varargs call
cast to java.io.Serializable[] for a non-varargs call and to suppress this warning
                print(sa, sa); // (4)
                          ^
1 warning


Analysis: This WARNING simply means that you're passing an array type Serializable (hence String implements Serializable)
to a method that takes or accepts var-args type String.

Because the caller passing the array "sa" with super type which is Serializable the var-args in the print() method
convert to String type

String[] is not just Serializalbe[] that happens to contain String objects. It's a different type (a subtype of Serializable[]).


Try this (You'll get an error):

Serializable[] greetings = {"Hello", "World"};
Strings[] strings = (String[]) greetings;


-The next line meant you need to cast to Serializable to make a var-args call or non-varargs call and suppress
the warning.


*/

[T Vergilio]

Hey Tommy, Creating Generic Methods is on page 627 in my book by the way Yeah, I re-read that part. But it doesn't mention anything about var-args or arrays being passed to var-args methods. Looking at the comments in your code, am I right to say that any array of any type passed to a var-args method is ALWAYS read as a Serializable?

I've been experimenting....

and look what I got:

public class Varargs {    
public static <E> void print(E e, E...src) {  
System.out.print("e value is type of String:");    
System.out.println(e instanceof String);   
System.out.print("e value is type of String arry:");  
System.out.println(e instanceof String[]);  
System.out.print("sre value is type of object array:");  
System.out.println(src instanceof Object[]);  
   
System.out.print("|");   
   
for (E elt : src) {    
System.out.println(elt + "|");   
    
}    
System.out.println("\n"+"--------------------");    
}    
public static void main(String[] args) {    
String[] sa = {"9", "6"};    
int[] in = {9,6};// array of primitives

print("9", "6"); // (1)    
print(sa); // (2)    
//print(sa, sa); // (4)    
print(sa, sa, sa); // (5)    
print(sa, "9", "6"); // (6)   
print(in);//(7) prints all right
print(in, in); //(8) so does this
print(in, "9", "6"); // (9) amazingly, there is no problem with this line either!!!
  
}    
} 

Look at lines 7, 8 and especially 9

Running the program, I get for the last three print calls:

--------------------
e value is type of String:false
e value is type of String arry:false
sre value is type of object array:true
|
--------------------
e value is type of String:false
e value is type of String arry:false
sre value is type of object array:true
|[I@19821f|

--------------------
e value is type of String:false
e value is type of String arry:false
sre value is type of object array:true
|9|
6|

So... an array of primitives (ints) is of type Object[]?!

[Tommy Delson]

Chandella Montero wrote:Hey Tommy, Creating Generic Methods is on page 627 in my book by the way Yeah, I re-read that part. But it doesn't mention anything about var-args or arrays being passed to var-args methods. Looking at the comments in your code, am I right to say that any array of any type passed to a var-args method is ALWAYS read as a Serializable?

That's correct, you won't find anything about "var-args or arrays being passed to var-args methods". What I meant is in combination of all, if you need to understand more about var-args and arrays reread these topics in K & B or others, after all you'll understand why and clear your doubt.

Also, this type of scenarios also included "Overloading Made Hard—Method Matching", you can check this topic on page 248 K & B book for more insight.




I've been experimenting....

and look what I got:

public class Varargs {    
public static <E> void print(E e, E...src) {  
System.out.print("e value is type of String:");    
System.out.println(e instanceof String);   
System.out.print("e value is type of String arry:");  
System.out.println(e instanceof String[]);  
System.out.print("sre value is type of object array:");  
System.out.println(src instanceof Object[]);  
   
System.out.print("|");   
   
for (E elt : src) {    
System.out.println(elt + "|");   
    
}    
System.out.println("\n"+"--------------------");    
}    
public static void main(String[] args) {    
String[] sa = {"9", "6"};    
int[] in = {9,6};// array of primitives

print("9", "6"); // (1)    
print(sa); // (2)    
//print(sa, sa); // (4)    
print(sa, sa, sa); // (5)    
print(sa, "9", "6"); // (6)   
print(in);//(7) prints all right
print(in, in); //(8) so does this
print(in, "9", "6"); // (9) amazingly, there is no problem with this line either!!!

/* 

Analysis on (9):

Yes and indeed no problem at all to passing an int and two literals type String to print() method.
    
Here is why:
  
Basically the Generic Method like print() with placeholder <E> is accepting any type you are passing in because, 
E placeholder  automatically hold the type you passing in (i.e in this case int, String, String).

More specific,  print(in, "9", "6") is print(int, String, String) that what you're passing to the print() method. You can pass 
print(Short, Integer, Integer) or (byte, Short, Short) etc. in the print() method as long as type and arguments number are 
matching. In this scenario "Overloading Made Hard—Method Matching" is also in ACTION or in USE, reread this topic and 
see if it makes sense.

*/

}    
} 

Look at lines 7, 8 and especially 9

Running the program, I get for the last three print calls:

--------------------
e value is type of String:false
e value is type of String arry:false
sre value is type of object array:true

Let's dissect, analyze, and find out why.

Your caller: print(in); //(7) prints all right

The calling method actually is "print(int e);" so, let's see if it makes sense on your instance check.

e value is type of String:false - Yes it's true, "e" value is an int not a String.
e value is type of String arry:false - Yes it's true, "e" value is an int array not String array. If your check is "e instance of int[]" then it's true, but not "e instance of Integer[]" .

sre value is type of object array:true - It's true an int is type of Object because the print() method does an auto boxing on the value you're passing in the method.

Autoboxing: int =>boxing to Integer => boxing to Number => boxing to Object

That's why it return true even thought you're passing an array in[] type int in the print() method.


I'll leave the rest to you to analyze and find out why, hope it help.





|
--------------------
e value is type of String:false
e value is type of String arry:false
sre value is type of object array:true
|[I@19821f|

--------------------
e value is type of String:false
e value is type of String arry:false
sre value is type of object array:true
|9|
6|

So... an array of primitives (ints) is of type Object[]?!