代码改变世界

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

2015-04-19 22:21  ttylinux  阅读(395)  评论(0编辑  收藏  举报

集合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>,在上述的实现中。