泛型详解21

为什么使用泛型:参数化类型 最大的优点是能在编译时检测出错误  。从jdk1.5开始  

它的类型必须的引用类型的  List< int> list=new ArrayList< int>();    int  double  char这类的就不行    

原理: List<String> list2=new ArrayList<String>();     list2.add("this");   //   实际上是=>  list2.add(new String("this"));  

来看看泛型类

public class generic_2<E> {
 private java.util.ArrayList<E> list=new java.util.ArrayList<E>();
 
 public int getSize(){
  return list.size();
 }
 
 public E peek(){
  return list.get(getSize()-1);
 }
 
 public void push(E o){
  list.add(o);
 }
 
 public E poop(){
  E o=list.get(getSize()-1);
  list.remove(getSize()-1);
  return o;
 }
 
 public boolean isEmpty(){
  return list.isEmpty();
 }
}

如果有多个参数的话这样<E1,E2,E3>  

泛型方法 

 public static void main(String[] args) {
   Integer[] integers={1,2,5,6,6,8};
   String[] strings={"2fs","23fds","fdsf","dfd"};
   generic_1.<Integer>print(integers);  //这样就是受限的
   generic_1.<String>print(strings);
 }
 public static <E> void print(E[] list){
  for(int i=0;i<list.length;i++){
   System.out.println(list[i]+"");
  }
 }

其实不加也行的 类似于这样  generic_1.print(integers);

<E> 和 <E extends Object> 是一样的  

原始类型和向后兼容  

什么是原始类型： 说白了就是Object  向后兼容是它的子类型

 List list=new ArrayList();
   list.add("dadsfdddddddddddda");
   System.out.println(list.get(0));

这 个样子看来是原始类型  使用Object    这是 不安全的做法  如果你再添加一个整形进去 就不会添加进集合中

通配泛型 ? , ? extends T , ? super T   

?  :  和 ？ extends Object 是一样的  非受限泛型类型

? extends T  :  受限通配 例如  Integer 是 Number 的子类型  

?  super T  :   下限通配 T 表示一个未知父类型   Object是String的父类  

public static <T> void add(  generic_2<T> stack1   ,   generic_2<? super T> stack2  ){
  while(!stack1.isEmpty()){
   stack2.push(stack1.poop());
  }
} 

深入原理：　例如　ArrayList<String> list1=new ArrayList<String>();

                            ArrayList<Integer> list2=new ArrayList<Integer>(); 

尽管是俩种类型 但是是运行的时候只有一个ArrayList类会加载到JVM中  list1和list2都是ArrayList的实例  

但是 （ list1 instanceof ArrayList）  和  （ list2 instanceof ArrayList） 都是正确的 · 

泛型在运行时被消除 

但 是

不能new E()  

不能new E[]  

在静态环境下不允许类的参数是泛型类型的

异常类不能是泛型的

编程练习:   代码在SWT那个Eclipse中

1.修改程序清单的GenericStack类，使用数组而不是ArrayList来实现它。 在给栈添加新元素前检查数组的大小，如果满了就创建一个新的数组，为当前的俩倍，然后复制到新数组中去。 

2.(泛型二分查找法) 使用二分查找法实现下面的方法   public static <E extends Comparable<E>> int binarySearch(E[] list ,  E key)  

3.(泛型选择排序)  使用排序法实现下面的方法  public static <E extends Comparable<E>> void selectionSort(E[] list)  

4.(泛型插入排序法)  使用插入排序法实现下面方法 public static <E extends Comparable<E>> void insertionSort(E[]  list);

5.(数组最大元素) 返回最大元素  public static <E extends Comparable<E>> E   max(E[]  list);

6.(二维数组最大元素)   public static <E extends Comparable<E>> E   max(E[][]  list); 

package generic_21;

import java.util.Arrays;

public class ZHomework {

	 
	public static void main(String[] args) {
		 /*二分查找
		 Integer[] list=new Integer[]{1,4,5,6,7,8,12};
		 Double[] list2=new Double[]{2.4,3.4,5.6,6.7};
		 Integer key=6;
		 Double key2=3.4;
		 Integer answer=ZHomework.<Integer>binarySearch(list, key);
		 Integer answer2=ZHomework.<Double>binarySearch(list2, key2);
		 if(answer!=-1){
			 System.out.println("the key of "+ key + " in array location is "+answer);
		 }
		 
		 if(answer2!=-1){
			 System.out.println("the key of "+ key2 + " in array location is "+answer2);
		 }
		 */
		
		/*选择排序 
		Integer[] list=new Integer[]{11,4,55,6,7,18,2};
		ZHomework.<Integer>selectionSort(list);
		System.out.println(Arrays.asList(list));
		*/
		
		/**插入排序
		Integer[] list2=new Integer[]{11,4,55,6,7,18,2};
		ZHomework.<Integer>insertionSort(list2);
		System.out.println(Arrays.asList(list2));
		 */
		/*一位数组最大值
		Integer[] list=new Integer[]{11,4,55,6,7,18,2};
		Integer max=ZHomework.<Integer>max(list);
		System.out.println(max);
		*/
		Double[][] list=new Double[][]{{11.3,45.4,56.2,45.2},{13.3,45.4,6.2,45.2},{1.3,45.4,6.2,45.2},{11.3,5.4,6.2,4.2}};
		System.out.println(ZHomework.<Double>max(list));
	}
	
	/**
	 * 泛型二分法查找 针对排序好的
	 * @param <E>
	 * @param list
	 * @param key
	 * @return
	 */
	public static <E extends Comparable<E>> int binarySearch(E[] list,E key){
		int start=0;
		int end =list.length-1;
		while(start<=end){
			int middle=(start+end)/2;
			if(key.compareTo(list[middle])>0){
				start=middle+1;
			}else if(key.compareTo(list[middle])<0){
				end=middle-1;
			}else{
				return middle;
			}
		}
		return -1;
	}
	
	/**
	 * 泛型选择排序法
	 * @param <E>
	 * @param list
	 */
	public static <E extends Comparable<E>> void selectionSort(E[] list){
		if(list.length<=0||list==null){
			return ;
		}
		for(int i=0;i<list.length;i++){
			int min=i;
			for(int j=i+1;j<list.length;j++){
				if(list[min].compareTo(list[j])>0){
					min=j;
				}
			}
			if(min!=i){
				E tem=list[i];
				list[i]=list[min];
				list[min]=tem;
			}
		}
	}

	/**
	 * 泛型插入排序法
	 * @param <E>
	 * @param list
	 */
	public static <E extends Comparable<E>> void insertionSort(E[] list){
		if(list==null||list.length<=0){
			return;
		}
		for(int i=1;i<list.length;i++){
			E tem=list[i];
			int position=i;    //记录点
			for(int j=i-1;j>=0;j--){    //将当前位置之前的数组做处理
				if(tem.compareTo(list[j])<0){
					list[j+1]=list[j];
					position--;
				}else{
					break;
				}
			}
			list[position]=tem;
		}
	}
	
	/**
	 * 一位数组最大值
	 * @param <E>
	 * @param list
	 * @return
	 */
	public  static <E extends Comparable<E>> E max(E[] list){
		E max=list[0];
		for(int i=1;i<list.length;i++){
			if(max.compareTo(list[i])<0){
				max=list[i];
			}
		}
		return max;
	}
	
	/**
	 * 二维数组最大值
	 * @param <E>
	 * @param list
	 * @return
	 */
	public  static <E extends Comparable<E>> E max(E[][] list){
		E max=list[0][0];
		for(int i=0;i<list.length;i++){
			for(int j=0;j<list[i].length;j++){
				if(max.compareTo(list[i][j])<0){
					max=list[i][j];
				}
			}
		}
		return max;
	}
	
}

  

 还有一些不是很懂，说不出来的感觉。 不过还好 。 参照书籍《Java语言程序设计·进阶篇》

我是菜鸟，我在路上。