burakdede

As you may know auto boxing and unboxing is a new feature of the Java 6.(which is not new for languages like C#, we can say it is new feature for the Java).Java has two main data types one is primitive type and other is reference types.Primitive types are the types generally built in language (like int , short,byte,long,float,double,bool,char…) and allocated on the stack side of the memory.But reference types are the types lets say shortly any type that subtype of the class Object in java (like class,array,String…) and they allocated on the heap side of the memory.

What about boxing and unboxing , boxing is conversion of the one primitive type to its corresponding reference type (int to Integer in this situation) while unboxing is conversion of the reference type to corresponding primitive type.You can think of actually “boxing” the varaible and putting it to heap side , and unboxing as reverse procedure to the stack side.

These boxing and unboxing operations are automatically done by java while using generics.Generics  can think of as a compile time check for class or interface or any other types that used with generics for their parameters.From definition its hard to understand so lets show a example of generics use.

1
2
3

List<Integer> ints = new ArrayList<Integer>();
ints.add(1);
int n = ints.get(0);

Here as you can see we are creating a list from arraylist(which is a class the implements list interface so assigment is OK) with specified parameters String in angle brackets.With the help of generics it is guaranteed that all the parameters that added to arraylist is String , if you try to add something other that String it is a compile time error.Before java generics its programmer job to guess what is the variable type coming from list and make suitable cast to that object.It is a extra work for programmer.With generics its is now compiler responsibility to check parameters and give compile time error.

You can say it is not different from c++ templates , but actually it does.There is a different implementation of the generics in bot c++ and java side.In C++ if you use generics and create and objects lets say List<String> and List<Integer> and List<List<String>> , C++ made 3 copy of your code for each generic in use.If you use 100 different type of generics there will be 100 different code , this can lead to code bloat.But in java no matter how many differnt generics you use there is only one code for all.C++ model generics called expansion,it can be lead to code bloat but in performance side it is more efficient that Java model.Also if you are using generics with C++ you have to be careful about usage of angle brackets.

Lets look at another code to see how auto boxing and unboxing work with Java.

1
2
3
4
5

public static int sum (List<Integer> ints) {
  int s = 0;
  for (int n : ints) { s += n; }
  return s;
}

In this code sample we again using a list from arraylist as  parameter to sum function with specified Integer generic.(you can say what is the difference between “Integer” and “int” , and why we not using “int” for generics like this “List<int> ints”) Cause type parameters always bound to reference type not primitive types.And also you can ask why we are using “int” insted of “Integer” as return type like “return Integer”? .Because result types may be either primitive or reference types, and it is more efficient to use the former than the latter.Also you can say why for variable(or you can say foreach another new feature of java 6) not “Integer” insted of  “int”.This is actually hold performace issue behind.If you use “Integer” instead of “int” compiler unbox the value of “Integer” every time and perform operation than box the value back for later iteration.This is a big performance loss.

Here how generics doing auto boxing and unboxing.

1
2
3

List<Integer> ints = new ArrayList<Integer>();
ints.add(new Integer(1));
int n = ints.get(0).intValue();

This is the different version of the first code sample at top.This is how it looks when we are using generics in our code.As you can see if we try to add int value to List that expects Integer , it automatically box the value and then add it to the list.On the other hand if we try to get the value out of list , it again automatically unbox the value and assign it .(here we using integer so if we try to box int value it is done with new Integer(x) , and if we try to unbox it you have to call intValue method of the Integer).

For more information about generics you can look at Sun documentation for generics and also for Collections framework of Java.