Java-将泛型用于多种类型

Question

I have the following DataSet class where we hold any kind of object. Mostly to transfer objects from the server to the client. The contents variable can hold any serializable object. It could be custom written class Objects or java classes like Integer , String etc.

I'm trying to convert this into generics. How should we go about converting this into Generics at the same time, I would like to make sure that I don't have to change all the containing object class code, since we are even using String and Integer classes within the contents.

I have simplified the class to only show some relevant fields and methods.

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.Serializable;
import java.util.Hashtable;
import java.util.Vector;

public class DataSet implements Serializable, PropertyChangeListener{

    Hashtable contents = new Hashtable();

    @Override
    public void propertyChange(PropertyChangeEvent arg0) {
        // TODO Auto-generated method stub

    }

    public void addObject(Object obj){
        Vector vector = (Vector)contents.get(obj.getClass());
        if (vector == null){
            vector = new Vector();
            vector.add(obj);
            contents.put(obj.getClass(), vector);
        }
    }

    public Vector getObjects(Class objType){
        if (contents.contains(objType)){
            return (Vector)contents.get(objType);
        }
        else{
            return new Vector();
        }
    }
}

Appreciate your prompt replies. But, after reviewing the three answers below, I felt like I didn't convey the problem correct.

To make this the way I want, if I invoke dataset.getObjects(of E type), I should be getting a vector of E type. I shouldn't be casting into (Vector). Because I want the contents to be holding Class<E> , and Vector<E> of key value pairs. If we can do that, then only I could say that this is safe .

DataSet ds = new DataSet();
Vector<String> strings = ds.getObjects(String.class);
Vector<Integer> integer = ds.getObjects(Integer.class);
Vector<Employee> employees = ds.getObjects(Employee.class);

Answer 1

First of all, stay away from class Vector , it's obsolete; use ArrayList instead.

Here's a simple way to store heterogeneous objects while avoiding explicit casting when retrieving objects. I'm sure you can work this model into your solution.

UPDATED , thanks to advice from Paul Bellora .

public class DataSet { 

    private Map<Class<?>, List<?>> contents;

    public DataSet(){
       contents = new HashMap<Class<?>, List<?>>();  
    } 

    @SuppressWarnings(value = { "unchecked" })
    public <T> void addObject(Class<T> klass, T object){
        List<T> objectsList = (List<T>)contents.get(klass);
        if (objectsList == null){
            objectsList = new ArrayList<T>();            
            contents.put(klass, objectsList);
        }
        objectsList.add(object);
    }

    @SuppressWarnings(value = { "unchecked" })
    public <T> List<T> getObjects(Class<T> klazz) {
        return contents.containsKey(klazz) ? 
                contents.get(klazz) : Collections.EMPTY_LIST;
    }

    public static <S, T extends Iterable<S>> void print(T list){
        for (Object element : list){
            System.out.println(element);
        }
    }

    public static void main(String[] o){
       DataSet ds = new DataSet();
       ds.addObject(String.class, "save the earth!");
       ds.addObject(String.class, "firing now!");       
       ds.addObject(Integer.class, new Integer(100));
       ds.addObject(Boolean.class, new Boolean(true));

       print(ds.getObjects(String.class));
       print(ds.getObjects(Boolean.class));
       print(ds.getObjects(Integer.class));      
    }
 }

Hope it helps.

Answer 2

Perhaps this would be sufficient:

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.Serializable;
import java.util.Map;
import java.util.List;

public class DataSet implements Serializable, PropertyChangeListener{

    Map<Class<?>, Vector<Serializable>> contents = new HashMap<Class<?>, Vector<Serializable>>();

    @Override
    public void propertyChange(PropertyChangeEvent arg0) {
        // TODO Auto-generated method stub
    }

    public void <T extends Serializable> addObject(T obj){
        Vector<T> vector = (Vector<T>)contents.get(obj.getClass());
        if (vector == null){
            vector = new Vector<T>();
            contents.put(obj.getClass(), vector);
        }
        vector.add(obj);
    }

    public <T extends Serializable> Vector<T> getObjects(Class<T> objType){
        if (contents.contains(objType)){
            return (Vector<T>)contents.get(objType);
        }
        else{
            return new Vector<T>();
        }
    }
}

I've edited my original post. Indeed, as pointed by Duncan in his comments, a DataSet structure has no point of being generic itself. Still, some generics could still add some syntax sugar in attempt to avoid casting

Answer 3

If I am not mistaken ,your Hashtable contents variable hold the class of a Serializable Object as key and the Serializable Vector List as value

   import java.beans.PropertyChangeEvent;
    import java.beans.PropertyChangeListener;
    import java.io.Serializable;
    import java.util.Hashtable;
    import java.util.Vector;

    public class DataSet implements Serializable, PropertyChangeListener{

        Hashtable<Class,Vector<Serializable> contents = new Hashtable<Class,Vector<Serializable>();

        @Override
        public void propertyChange(PropertyChangeEvent arg0) {
            // TODO Auto-generated method stub

        }

        public void addObject(Serializable obj){

            Vector<Serializable> vector = contents.get(obj.getClass());
            if (vector == null){
                vector = new Vector<Serializable>();
                vector.add(obj);
                contents.put(obj.getClass(), vector);
              }
            else{
              vector.add(obj);
               }
        }

        public Vector<Serializable> getObjects(Class objType){
            if (contents.contains(objType)){
                return (Vector<Serializable>)contents.get(objType);
            }
            else{
                return new Vector<Serializable>();
            }
        }
    }