DataStructures:Introduction

1.Java中的基本思想可以用过使用Object这样的适当的超类实现泛型。基本类型的自动包/拆装，会是基本类型的包装类与Object兼容。且自动包/拆装是编译器自动内部运行。

public class Test {        public static void main(String[] args) {           System.out.println("ok");           System.out.println("+++++++++++++++++++");           MemoryCell m = new MemoryCell();           m.write("37");//传入的参数是String           System.out.println("contents are :"+m.read());           MemoryCell m1 = new MemoryCell();           m.write(37);//传入的参数是int           System.out.println("contents are :"+m.read());        }}class  MemoryCell{    private Object storedValue;//使用Object实现泛型    public Object read(){         return storedValue;    }    public void write(Object x){        storedValue=x;    }}##################################################Console:ok+++++++++++++++++++contents are :37contents are :37

2.使用借口类型实现泛型。当只使用Object类中已有的方法进行操作时，则可以使用Object完成泛型任务。但当需要新的方法，区别Object的方法，则可以使用接口实现泛型。

3.数组中的协变数组类型（covariant array type）保证数组在编译期间不会出错，所以下边的代买在编译期间不会出错。但数组要求存储对象类型一致性，所以下边代码在运行期间会出错。代码会抛出异常：

public class Test {        public static void main(String[] args) {           person[] ps = new employee[5];//ps数组对象为emplyee类型           ps[0]=new student();//student类型无法存到employee数组对象中           System.out.println("ok");        }}class person{}class employee extends person{}class student extends person{}###Console:###Exception in thread "main" java.lang.ArrayStoreException: student    at Test.main(Test.java:6)

4.Java5后支持泛型类型，指定泛型类时，在类名后面的一对尖括号内包含一个或者多个类型参数，而在类体中的域或者方法可以使用这些类型参数。如下代码实现泛型类型：

public class GenericMemoryCell<T> {     private T storedvalue;     public T read(){         return storedvalue;     }     public void write(T x){         storedvalue=x;     }     public static void main(String[] args) {        GenericMemoryCell<String> m = new GenericMemoryCell<String>();        m.write("fdklsjf");        System.out.println(m.read());        GenericMemoryCell<String> m1 = new GenericMemoryCell<String>();//m1指定的类型为String        m1.write(37);//传入的是int与指定类型String冲突        System.out.println(m1.read());    }} ########################################Console：Exception in thread "main" java.lang.Error: Unresolved compilation problem:     The method write(String) in the type GenericMemoryCell<String> is not applicable for the arguments (int)    at GenericMemoryCell.main(GenericMemoryCell.java:16)

6.泛型在编译期间会检验类型。协变类型在编译期间无法检验出错，所以泛型检验可以使用通配符加强在编译期间的类型检验。泛型可以理解为类型标记，在编译期间进行处理。而通配符加强了类型之间的父子关系。

import java.awt.List;import java.util.ArrayList;import java.util.Collection;public class WildCard {    public static double totalArea(Collection<? extends Shape> arr){        double total = 0;        for(Shape s:arr){            if(s!=null){                total += s.area;            }        }        return total;    }    public static void main(String[] args) {        WildCard testwildcard = new WildCard();        Collection<Shape> arr = new ArrayList<Shape>();        Shape shape1 = new Shape(23.3);        Shape shape2 = new Shape(34);        arr.add(shape1);        arr.add(shape2);                System.out.println(testwildcard.totalArea(arr));        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++");        Square square1 = new Square(78);        Square square2 = new Square(34);        Collection<Shape> arr2 = new ArrayList<Shape>();        arr2.add(square1);        arr2.add(square2);        System.out.println(testwildcard.totalArea(arr2));    }}class Shape{    double area;    Shape(double area){        this.area=area;    }}class Square extends Shape {    Square(double area) {        super(area);    }}################################################Console:57.3+++++++++++++++++++++++++++++++++++++++++++++++112.0

7.泛型方法类似泛型类，因为两者的类型参数表都使用相同的语法。在泛型方法中类型参数位于返回类型之前。

public static <T> boolean contains(Collection<T> arr,T x){        for(T val:arr){            if(x.equals(arr)){                return true;            }        }        return false;    } System.out.println(WildCard.contains(arr, shape1));        System.out.println(WildCard.contains(arr2, square2));   ---------------------------------------------------对泛型类型进行限界（使用extends或者super）.编译器会对泛型进行类型檫除，使用限定的类型替换泛型参数。泛型的好处是程序员不用进行类型转换而是由编译器进行类型检查。public static<T extends Comparable<? super T>> T findMax(T [] arr){        int maxIndex = 0;        for(int i=1;i<arr.length;i++){            if(arr[i].compareTo(arr[maxIndex])>0){                maxIndex = i;            }        }        return arr[maxIndex];    }

函数对象

import java.util.Comparator;public class FindMax {     public static <T> T findMax(T[] arr,Comparator<? super T> cmp){        int maxIndex = 0;        for(int i=1;i<arr.length;i++){            if(cmp.compare(arr[i],arr[maxIndex])>0){                maxIndex=i;            }        }        return arr[maxIndex];    }    public static void main(String[] args) {        String [] arr ={"ZEBER","ALLIGATOR","crocodeile"};        System.out.println(findMax(arr,new CasInsensitiveCompare()));    }}class CasInsensitiveCompare implements Comparator<String>{    @Override    public int compare(String o1, String o2) {        return o1.compareToIgnoreCase(o2);    }}// package java.util// interface Comparator<T>{//  int compare(T lhs, T ths);//}