Type Safe Collections

Question

Hello All,
I want to have type safe collections. Today. when we do programming with collections it almost behaves like a scripting language with no data types. any thing which is an object goes in and comes out freely.
what about having a Collection(vector, ArrayList) class which can contain objects of only one type.
something like
ArrayList<Integer> a = new ArrayList();
regards,
Abhishek.

Answer 1

Here's my way of using generics in normal Java - not quite as good as a compile error - but it works, and gives you a runtime error on inserting an object of the wrong type.
I did this when at Uni, hence all the funky comments (well, you can't expect the lecturers to actually read the code, can you?).
Just something you may find useful:
import java.util.*;
���An implementation of the Proxy pattern, designed to wrap any list, and make it accept
���objects of the specified type (subclasses are allowed) only, hence allowing a user of
���this class to 'trust' the Proxy list.
public class TypeSafeList extends AbstractList implements Serializable
���protected List source;
���protected Class acceptable;
���/**
������@param list the list to assign.
������@exception java.lang.IllegalArgumentException if the list contains elements of a
������different type to that specified
���*/
���public TypeSafeList(List list,Class acceptable)
���{
������Iterator iterator = list.iterator();
������while( iterator.hasNext() )
���������if( !acceptable.isInstance( iterator.next() ) )
������������throw new IllegalArgumentException( list+" contains elements not of type "+acceptable);
������this.source=list;
������this.acceptable=acceptable;
���}
���/**
������Passes on the request to the underlying list. See java.util.List.
���*/
���public Object get(int index)
���{
������return source.get(index);
���}
���/**
������Passes on the request to the underlying list. See java.util.List.
���*/
���public int size()
���{
������return source.size();
���}
���/**
������Checks that the type of the parameter is valid, and then passes on the
������request to the underlying list. See java.util.List.
������
������@exception java.lang.IllegalArgumentException if the type of the parameter is
������invalid.
���*/
���public Object set(int index,Object element)
���{
������return source.set(index,checkType(element));
���}
���/**
������Passes on the request to the underlying list. See java.util.List.
���*/
���public Object remove(int index)
���{
������return source.remove(index);
���}
���/**
������Checks that the type of the parameter is valid, and then passes on the
������request to the underlying list. See java.util.List.
���*/���
���public void add(int index,Object object)
���{
������source.add(index,checkType(object));
���}
���/**
������Return the Class object this List is configured to accept.
���*/
���public Class getAcceptable()
���{
������return acceptable;
���}
���
���/**���
������Checks the validity of the parameter against the protected field 'acceptable'.
������@return object if object is valid.
������@exception java.lang.IllegalArgumentException if the argument is invalid.
���*/
���protected Object checkType(Object object) throws IllegalArgumentException
���{
������if (acceptable.isInstance(object))
���������return object;
������throw new IllegalArgumentException(object+" needs to be of type "+acceptable.getName());
���}
}