泛型

23.不要在新代码中使用原生态类型

24.消除非受检警告

25.列表优于数组

数组是协变的

public static void main(String[] args) {
		Object [] objects = new Long[1];
		objects[0] = "1";
		System.out.println(objects[0]);
	}

只有在运行时才会报错

数组是具体化的，因此数组会在运行时才知道并坚持它们的元素类型约束，泛型是通过擦除来实现的，因此泛型只在编译时强化类型信息，并在运行时丢弃元素类型信息，擦除就是使泛型可以和每页使用泛型的代码随意进行互换

26.优先考虑泛型

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 Stack<E> {
	private Object[] elements;
	private int size = 0;
	private static final int DEFAULT_INITIAL_CAPACITY = 16;
	@SuppressWarnings("unchecked")
	public Stack(){
		//方法一
		//elements = (E[]) new Object[DEFAULT_INITIAL_CAPACITY];
		//方法二
		elements = new Object[DEFAULT_INITIAL_CAPACITY];
	}
	public void push(E e){
		ensureCapacity();
		elements[size++] = e;
	}
	public E pop(){
		if(size == 0){
			throw new EmptyStackException();
		}
		//方法2
		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);
		}
	}
}
 

27.优先使用泛型方法

//有警告
	public static Set union(Set s1,Set s2){
		Set result = new HashSet(s1);
		result.addAll(s2);
		return result;
	}
	//修正，使方法变成类型安全的
	public static <E> Set<E> union(Set<E> s1,Set<E> s2){
		Set<E> result = new HashSet<>(s1);
		result.addAll(s2);
		return result;
	}

泛型方法无需明确类型参数的值，不像调用泛型构造器那样必须指定，编译器通过检查方法参数的类型来计算类型参数的值，类型推导

泛型构造器，明确传递参数的值，类型参数出现在变量声明的俩边，冗余，可以使用泛型静态工厂

	Map<String, List<String>> anagarms = new HashMap<String ,List<String>>();
	//泛型静态工厂方法
	public static<K,V> HashMap<K, V> newHashMap(){
		return new HashMap<K,V>();
	}
	Map<String, List<String>> anagarms =newHashMap();
	//现在可以
	Map<String, List<String>> anagarms = new HashMap<>();

28.利用有限制通配符来提升API的灵活性

	public void pushAll(Iterator<E> src){
		for (E e:src) {
			push(e);
		}
	}

	Stack<Number> numberStack = new Stack<>();
	Iterator<Integer> iterator =;
	numberStack.pushAll(integers);

如果泛型不一样会报错
可以用有限制的通配符来处理

Iterator<? Extends E>,E的某个子类型迭代器接口

	public void pushAll(Iterator<? extends E> src){
		for (E e:src) {
			push(e);
		}
	}

	public void popAll(Collection<? extends E>){
		while (!isEmpty) {
			dst.add(pop());			
		}
	}

类型匹配不严格，使用通配符类型，严格就没必要使用通配符
生产者<? extends T>,消费者<? super T>

29.