-
什么是泛型?
-
一个泛型类(generic class)就是有一个或多个类型变量的类。
-
又叫做参数化类型,将类型当做参数传递给一个类或者方法
-
为什么要使用泛型程序设计?
-
泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。泛型可以看作是普通的工厂
-
泛型类声明
原生态类型
/** * 原生态类型 */ public class Stack { private Object[] elements; private int size = 0; private static final int DEFAULT_INITIAL_CAPACITY = 16; public Stack() { elements = new Object[DEFAULT_INITIAL_CAPACITY]; } public void push(Object e) { ensureCapacity(); elements[size++] = e; } public Object pop() { if (size == 0) { throw new EmptyStackException(); } Object result = elements[size--]; elements[size] = null; return result; } public boolean isEmpty() { return size == 0; } private void ensureCapacity() { if (elements.length == size) { elements = Arrays.copyOf(elements, 2 * size + 1); } } }
泛型类声明方式一
/** * 原生态类型转泛型类型方式一(较常用) */ public class StackE1<E> { private E[] elements; private int size = 0; private static final int DEFAULT_INITIAL_CAPACITY = 16; @SuppressWarnings("unchecked") public StackE1() { // 创建Object 数组,并转换成泛型数组 elements = (E[]) new Object[DEFAULT_INITIAL_CAPACITY]; } public void push(E e) { ensureCapacity(); elements[size++] = e; } public E pop() { if (size == 0) { throw new EmptyStackException(); } E result = elements[size--]; elements[size] = null; return result; } public boolean isEmpty() { return size == 0; } private void ensureCapacity() { if (elements.length == size) { elements = Arrays.copyOf(elements, 2 * size + 1); } } }
泛型类声明二
/** * 原生态类型转泛型类型方式二 */ public class StackE2<E> { private Object[] elements; private int size = 0; private static final int DEFAULT_INITIAL_CAPACITY = 16; public StackE2() { // 创建Object 数组,并转换成泛型数组 elements = new Object[DEFAULT_INITIAL_CAPACITY]; } public void push(E e) { ensureCapacity(); elements[size++] = e; } public E pop() { if (size == 0) { throw new EmptyStackException(); } @SuppressWarnings("unchecked") E result = (E) elements[--size]; elements[size] = null; return result; } public boolean isEmpty() { return size == 0; } private void ensureCapacity() { if (elements.length == size) { elements = Arrays.copyOf(elements, 2 * size + 1); } } }
-
泛型方法
原始泛型方法
public class StackMethod { public static Set union(Set s1,Set s2){ Set result = new HashSet(s1); result.add(s2); return result; } }
泛型方法声明
public class StackMethodM1 { // 1.public static Set<E> 之间的<E> 代表什么意思? // 它表示一个类型参数,能被用来声明返回值类型,并且能作为泛型方法得到的实际参数类型的占位符,这个过程称为类型推导 // 2.Set<E> s1, Set<E> s2 代表什么意思? // 字母E是一个代号,被称为类型变量或类型参数,当然你也可以换成a,b,c...这么写更规范,通常有E(element)、T(type)、K、V、N(number) // 注意类型参数只能代表引用型类型,不能是原始类型(像int,double,char...) public static <E> Set<E> union(Set<E> s1, Set<E> s2) { Set<E> result = new HashSet<E>(s1); result.addAll(s2); return result; } }
-
泛型单例工厂(类型推导的应用)
泛型静态工厂方法,目的是为了消除,Map<String,List<String>> map = new HashMap<String,List<String>>(),标记部分的冗余部分
public class HashMapUtil { // 泛型静态工厂方法 public static <K, V> HashMap<K, V> newInstance() { return new HashMap<K, V>(); } }
客户端实例
public class HashMapInstance { public static void main(String[] args) { // 利用工具类创建HashMap 对象 Map<String, List<String>> map = HashMapUtil.newHashMap(); // 原始方法创建HashMap 对象 Map<String, List<String>> map1 = new HashMap<String, List<String>>(); } }
-
递归类型限制
定义一个泛型接口,跟泛型类差不多
public interface IUnaryFun<T> { T apply(T arg); }
假设需要提供一个恒等函数,如果在每次需要的时候都重新创建一个,这样会很浪费,因为他是无状态的,如果泛型被具体化了,每个类型都需要一个恒等函数,但是他们被擦除以后,就只需要一个泛型单例。
/** * 递归限制类型 */ public class RecursiveType { // 泛型单例工厂模式 private static IUnaryFun<Object> IDENTITY_FUN = new IUnaryFun<Object>() { public Object apply(Object arg) { return arg; } }; // 无状态的参数类型 @SuppressWarnings({ "unchecked" }) private static <T> IUnaryFun<T> identityFun() { return (IUnaryFun<T>) IDENTITY_FUN; } public static void main(String[] args) { String[] strings = { "bob", "lily", "lucy" }; IUnaryFun<String> sameString = identityFun(); for (String s : strings) { System.out.println(sameString.apply(s)); } Number[] numbers = { 1, 1.1d, 2.2f }; IUnaryFun<Number> sameNumber = identityFun(); for (Number n : numbers) { System.out.println(sameNumber.apply(n)); } } }
-
通配符限制和PECS
在泛型类型声明一种添加的pushAll() 方法,如下
public void pushAll(Iterable<E> src) { for (E e : src) { push(e); } }
客户端如下图的错误信息,因为如前所述,参数化类型是不可变得,因此无法将Integer 类型的数据插入Number 类型的参数中,尽管Number 是Integer 的父类
Java 提供一种特许的参数化类型:有限制的通配符类型 来处理这种情况。pushAll 输入的参数不应为“E 的Iterable 接口”,而应该为“E 的某个子类型的Iterable 接口”,有一个通配符类型正符合此意:Iterable<? Extends E>,修改后的代码如下,StackE3 可以正确无误地编译,这个也叫上界通配符
public void pushAll(Iterable<? extends E> src) { for (E e : src) { push(e); } }
编写与pushAll 方法呼应的popAll方法,从堆栈中弹出每个元素,并将这些元素添加到指定集合中,在泛型类型声明一种添加的popAll() 方法,如下
public void popAll(Collection<E> dst) { while (!isEmpty()) { dst.add(pop()); } }
客户端如下图错误信息,同样的,因为Collection<Object> 不是Collection<Number> 的子类型
popAll 的输入参数类型不应该为“E 的集合”,而应该为“E 的某种超类的集合”,通俗的讲,就是Number 类型的数据无法添加到Object 类型,他们之间一开始是没关系的,这时仍有一个通配符正符合此意:Collection<? super E>。这也叫下界通配符
public void popAll(Collection<? super E> dst) { while (!isEmpty()) { dst.add(pop()); } }