泛型详解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语言程序设计·进阶篇》

我是菜鸟，我在路上。