package cn.xf.cp.ch02.item27; import java.util.HashSet;
import java.util.Set; public class Union
{
/**
* 这个方法就会有警告
* @param s1
* @param s2
* @return
*/
public static Set union1(Set s1, Set s2)
{
Set result = new HashSet(s1);
result.addAll(s2);
return result;
} /**
* 这里使用泛型就是安全没有警告的
* @param s1
* @param s2
* @return
*/
public static <E> Set<E> union(Set<E> s1, Set<E> s2)
{
Set<E> result = new HashSet<E>(s1);
result.addAll(s2);
return result;
} }
但是有的时候,我们发现使用泛型的时候,在调用构造器的时候要明确泛型的类型,这样书写很麻烦
这里可以使用一个泛型静态方法,利用泛型的类型推导
package cn.xf.cp.ch02.item27; import java.util.HashMap;
import java.util.List;
import java.util.Map; public class GenericStaticFactory
{
public static <K, V> HashMap<K, V> newHashMap()
{
return new HashMap<K, V>();
} public static void main(String[] args)
{
//这里创建对象的时候,就会根据前面map中的String和List<String>自动转换
Map<String, List<String>> anagrams = newHashMap();
}
}
关于泛型单利工厂的实现
package cn.xf.cp.ch02.item27; public class GenericSingletonFactory
{
//先创建object对象,暂时替代T对象
private static UnaryFunction<Object> IDENTITY_FUNCTION = new UnaryFunction<Object>()
{
public Object apply(Object arg)
{
return arg;
}
}; //根据T,吧IDENTITY_FUNCTION转换为相应的类型,由于IDENTITY_FUNCTION返回未被修改的object类型参数,所以下面类型转换时安全的
@SuppressWarnings("unchecked")
public static <T> UnaryFunction<T> identityFunction()
{
return (UnaryFunction<T>) IDENTITY_FUNCTION;
} public static void main(String[] args)
{
String[] strings =
{ "jute", "hemp", "nylon" };
UnaryFunction<String> sameString = identityFunction();
for (String s : strings)
System.out.println(sameString.apply(s)); Number[] numbers =
{ 1, 2.0, 3L };
UnaryFunction<Number> sameNumber = identityFunction();
//这里用来判断是否真的实现了单例
Object t1 = sameString;
Object t2 = sameNumber; if(t1 == t2)
{
System.out.println("相同引用");
} String s1 = "123456";
String s2 = new String("123456"); if(s1.equals(s2))
System.out.println("相同内容"); for (Number n : numbers)
System.out.println(sameNumber.apply(n));
}
}
显示结果: