Tutorial :How are Java generics different from C++ templates? Why can't I use int as a parameter?


I am trying to create

ArrayList<int> myList = new ArrayList<int>();  

in Java but that does not work.

Can someone explain why int as type parameter does not work?
Using Integer class for int primitive works, but can someone explain why int is not accepted?

Java version 1.6


Java generics are so different from C++ templates that I am not going to try to list the differences here. (See What are the differences between “generic” types in C++ and Java? for more details.)

In this particular case, the problem is that you cannot use primitives as generic type parameters (see JLS §4.5.1: "Type arguments may be either reference types or wildcards.").

However, due to autoboxing, you can do things like:

List<Integer> ints = new ArrayList<Integer>();  ints.add(3); // 3 is autoboxed into Integer.valueOf(3)  

So that removes some of the pain. It definitely hurts runtime efficiency, though.


The reason that int does not work is that you cannot use primitive types as generic parameters in Java.

As to you're actual question, how is C++ templates different from Java generics, the answer is ... really really different. It's essentially two completely different approaches to implementing a similar end effect.

Java tends to focus on the definition of the generic. That is the validity of the generic definition is checked by only considering the code in the generic. If parameters are not properly constrained certain actions cannot be performed on them. The actual type it is eventually invoked with is not considered.

C++ is the opposite. Only minimal verification is done on the template itself. It really only needs to be parsable to be considered valid. The actual correctness of the definition is done at the place in which the template is used.


They are very different concepts, which can be used to perform some, but not all of the same tasks. As said in the other responses, it would take a quite a bit to go over all the differences, but here's what I see as the broad strokes.

Generics allow for runtime polymorphic containers through a single instantiation of a generic container. In Java, all the (non-primitive) objects are references, and all references are the same size (and have some of the same interface), and so can be handled by the bytecode. However, a necessary implication of having only instantiation of byte code is type eraser; you can't tell which class the container was instantiated with. This wouldn't work in c++ because of a fundamentally different object model, where objects aren't always references.

Templates allow for compile time polymorphic containers through multiple instantiations (as well as template metaprogramming by providing a (currently weakly typed) language over the c++ type system.). This allows for specializations for given types, the downside being potential "code bloat" from needing more than one compiled instantiation.

Templates are more powerful than generics; the former is effectively another language embedded within c++, while to the best of my knowledge, the latter is useful only in containers


that's because int is a primitive, it is a known issue.

If you really wanted to, you can subclass/write your own collection that can do that.


You can't use primitives as type parameters in Java. Java's generics worth through type erasure, meaning that the compiler checks that you're using the types as you've defined them, but upon compilation, everything is treated as an Object. Since int and other primitives aren't Objects, they can't be used. Instead, use Integer.


You could try TIntArraList from GNU Trove which will act like an ArrayList of int values.


The main difference is in way they are implemented, but their names accurately describe their implementation.

Templates behave like templates. So, if you write:

template<typename T>  void f(T s)  {      std::cout << s << '\n';  }    ...  int x = 0;  f(x);  ...  

Compiler applies the template, so in the end compiler treats the code like:

void f_generated_with_int(int s)  {      std::cout << s << '\n';  }    ...  int x = 0;  f_generated_with_int(x);  ...  

So, for each type which is used to call f a new code is "generated".

On the other hand, generics is only typechecked, but then all type information is erased. So, if you write:

class X<T> {      private T x;        public T getX() { return x; }      public void setX(T x) { this.x = x; }  }    ...  Foo foo = new Foo();  X<Foo> x = new X<>();  x.setX(foo);  foo = x.getX();  ...  

Java compiles it like:

class X {      private Object x;        public Object getX() { return x; }      public void setX(Object x) { this.x = x; }  }    ...  Foo foo = new Foo();  X x = new X();  x.setX(foo);  foo = (Foo)x.getX();  ...  

In the end:

  • templates require instantiation of each call to templated function (in compilation of each .cpp file), so templates are slower to compile
  • with generics you can't use primitives, because they are not Object, so generics is less versatile

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Next Post »