Item 29 优先考虑类型安全的异构容器

集合API展示了泛型的一般用法。但是它们(Set,HashMap,Map)限制了每个容器只能有固定数目的类型参数。

 

 

比如Set集合，HashMap集合：

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

 

public class NormalUse {

 

 

  public static void main(String[] args) {

   

    Set<String> oneSet = new HashSet<String>();

    oneSet.add("One");

    oneSet.add("Two");

   

   

    Map<String, Integer> oneMap = new HashMap<String, Integer>();

    oneMap.put("One", 1);

    oneMap.put("Two", 2);

    //Set集合，只有一个类型参数；HashMap集合有两个类型参数

  

  }

 

 

}

 

 

异构容器：

 

如果一个容器里面它存放的类型参数数目是不固定的，那么它就是一个异构的容器。这是有使用场景的，比如，使用一个容器来存放数据库中有任意列的一个行。因为一行，列的数目是不固定的，每个列的类型也是不确定的，那么就可以使用一个异构的容器来表示这个行。

 

一个列元素，用一个键值对来表示，并且键和值之间有有类型关系，键的类型跟值的类型是相同的。因为，有不同类型的列。在实现这个目标时，让键参数化(也就是键可以表示不同的类型，而不是容器参数化，Set<T>是容器参数化)。

 

 

下述代码的实现分析：

 

Map<Column<?>,Object> row = new HashMap<>();

这个是实际存放不同的键值对。

不同的键对应不同的值。

因为只是对键进行类型参数化，不是对值进行类型参数。但是值要保证可以表示所有类型，那么值就采用所有对象的根类(Object)。

 

Map包含了某个行的所有列。

 

 

 public <T> void putColumn(Column<T> type, T instance) {

    row.put(type, instance);

  }

这个泛型方法，表示了键和值的对应关系。键的类型跟值的类型是相同的，都是T。

 

 

  public <T> T getColumn(Column<T> type) {

    return type.cast( row.get(type));

  }

这个方法，是为了得到键对应的值类型，存放的值类型转换为添加时的类型。转换失败会抛出ClassCastException异常。

 

如此，就可以使用一个容器来存放不同的元素类型，在这里表示为数据库中的某个行。而Set，HashMap,这样的容器只能存放一种元素类型。

 

 

public class Column<T> {

 

  private final T valClass ;

 

  @SuppressWarnings( "unchecked" )

  public Column(Class<T> valClass) {

    this. valClass = (T) valClass;

  }

 

  @SuppressWarnings( "unchecked" )

  public T cast(Object obj) {

    return obj == null ? null : ((Class<T>) valClass).cast(obj);

  }

}

 

public class DatabaseRow {

 

  private Map<Column<?>, Object> row = new HashMap<>();

 

  public <T> void putColumn(Column<T> type, T instance) {

    if (type == null )

      throw new NullPointerException("Type is null" );

    row.put(type, instance);

  }

 

  public <T> T getColumn(Column<T> type) {

    return type.cast( row.get(type));

  }

 

  public static void main(String[] args) {

    DatabaseRow db = new DatabaseRow();

 

    Column<Integer> colInt = new Column<Integer>(Integer. class);

    Column<Double> colDouble = new Column<Double>(Double. class);

    Column<Float> colFloat = new Column<Float>(Float. class);

 

    db.putColumn(colInt, 1);

    db.putColumn(colDouble, 10.0);

    db.putColumn(colFloat, 12.3f);

 

    System. out.println(colInt.getClass() + " " + colDouble.getClass());

    System. out.println(db.getColumn(colInt) + " " + db.getColumn(colDouble));

  }

 

}

 

--------------------------------------------------------------------------------------------------------

 

另外一个例子：

 

实现一个容器，它存放的是任意类的实例。

public class Favorites {

  // Typesafe heterogeneous container pattern - implementation

  private Map<Class<?>, Object> favorites = new HashMap<Class<?>, Object>();

 

  public <T> void putFavorite(Class<T> type, T instance) {

    if (type == null )

      throw new NullPointerException("Type is null" );

    favorites.put(type, instance);

  }

 

  public <T> T getFavorite(Class<T> type) {

    return type.cast( favorites .get(type));

  }

 

  // Typesafe heterogeneous container pattern - client

  public static void main(String[] args) {

    Favorites f = new Favorites();

    f.putFavorite(String. class , "Java" );

    f.putFavorite(Integer. class , 0xcafebabe);

    f.putFavorite(Class. class , Favorites. class);

 

    String favoriteString = f.getFavorite(String. class );

    int favoriteInteger = f.getFavorite(Integer. class );

    Class<?> favoriteClass = f.getFavorite(Class. class );

    System. out.printf( "%s %x %s%n" , favoriteString, favoriteInteger, favoriteClass.getName());

  }

}

 

----------------------------------------------------------------------------------------------

 

总结：

要实现一个异构的容器，实现方式通常是使用一个键值对，这是因为底层的实现采用Map,然后，对键进行类型参数化，并且指定键和值之间的类型关系。这样就可以实现一个异构的容器，一个容器里面有不同的元素类型，而不是只有一个唯一的类型。另外，还可以对键进行"? extends T"的类型限制。

通过让对键进行类型参数化，这样，新形成的容器，在外部看来就是可以存放不同的类型。虽然，在实现方面，它使用的Map，依然是秉持只能存放一种类型，这种类型就是<Class<?>,Object>，在上述的实现中。