泛型的作用

第一是泛化。

可以用T代表任意类型Java语言中引入泛型是一个较大的功能增强不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了，这带来了很多好处。

第二是类型安全

。泛型的一个主要目标就是提高Java程序的类型安全，使用泛型可以使编译器知道变量的类型限制，进而可以在更高程度上验证类型假设。如果不用泛型，则必须使用强制类型转换，而强制类型转换不安全，在运行期可能发生ClassCast Exception异常，如果使用泛型，则会在编译期就能发现该错误。

第三是消除强制类型转换。

泛型可以消除源代码中的许多强制类型转换，这样可以使代码更加可读，并减少出错的机会。

第四是向后兼容。

支持泛型的Java编译器（例如JDK1.5中的Javac）可以用来编译经过泛型扩充的Java程序（Generics Java程序），但是现有的没有使用泛型扩充的Java程序仍然可以用这些编译器来编译。

泛型的优点

1、类型安全

泛型的主要目标是提高Java程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在非常高的层次上验证类型假设。没有泛型，这些假设就只存在于系统开发人员的头脑中。

通过在变量声明中捕获这一附加的类型信息，泛型允许编译器实施这些附加的类型约束。类型错误就可以在编译时被捕获了，而不是在运行时当作ClassCastException展示出来。将类型检查从运行时挪到编译时有助于Java开发人员更早、更容易地找到错误，并可提高程序的可靠性。

2、消除强制类型转换

泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。尽管减少强制类型转换可以提高使用泛型类的代码的累赞程度，但是声明泛型变量时却会带来相应的累赞程度。在简单的程序中使用一次泛型变量不会降低代码累赞程度。但是对于多次使用泛型变量的大型程序来说，则可以累积起来降低累赞程度。所以泛型消除了强制类型转换之后，会使得代码加清晰和筒洁。

3、更高的运行效率

在非泛型编程中，将筒单类型作为Object传递时会引起Boxing（装箱）和Unboxing（拆箱）操作，这两个过程都是具有很大开销的。引入泛型后，就不必进行Boxing和Unboxing操作了，所以运行效率相对较高，特别在对集合操作非常频繁的系统中，这个特点带来的性能提升更加明显。

4、潜在的性能收益

泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，Java系统开发人员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为未来版本的JVM的优化带来可能

泛型概述

Java SE 5.0以前操作集合的缺点：

当把一个对象存入集合后，集合会“忘记”这个对象的类型，将该对象从集合中取出时，这个对象的编译类型就变成了Object类型。

从集合中取出对象，需要执行类型转换操作：

由于没有类型检查，可以向集合添加任意对象，get方法在取出元素时，如果进行强制类型转换就很容易出错

ArrayList files = new ArrayList();
 . . . 
String filename = (String) files.get(0); 

泛型提供了参数化类型

在定义集合类时，可以使用“<参数化类型>”的方式指定该类中方法操作的数据类型。如

ArrayList<String> files = new ArrayList<String>(); 

限定了ArrayList集合只能存储String类型元素。

取出对象的类型为String，无需执行类型转换。

没有使用泛型的Java代码警告

 泛型的使用

如何定义泛型List对象

List<T>

T是类型变量

T也可以是泛型变量类型

泛型经常被称为参数化类型，它能够像方法一样接受不同类型的参数

<Integer>存储Integer的List

        List <Integer> numbers = new ArrayList<Integer>();
        for (int i = 1; i <= 49; i++){
            numbers.add(i);
        }
Collections.shuffle(numbers);//对集合中的元素随机排序
        List<Integer> subnumbers=    numbers.subList(0, 6);
        Collections.sort(subnumbers);
        System.out.println(subnumbers);

泛型中使用通配符

泛型中可以使用“？”通配符作为参数，表示该泛型可以接收任意类型的数据

public static void print(List<?>  list) {
for (Object element : list) {
                     System.out.println(element );
               } }

上界通配符：

泛型中只允许一个类自身(接口)或者其子类(实现该接口的类)作为参数传入。

ArrayList<? extends 父类(接口)>

下界通配符：

泛型中只允许一个类自身或者该类的父类作为参数传入。

ArrayList<? super 子类>。

自定义泛型

Point类具有两个成员，类型待定

使用private T x表示x的类型为参数T

public class GerDemo {
public static void main(String[] args) {
Point<Integer> p1=new Point<Integer>();  //点p1
p1.setX(5);
p1.setY(8);
System.out.println("p1:("+p1.getX()+","+p1.getY()+")");
Point<Integer> p2=new Point<Integer>(34,98); //点p2
System.out.println("p2:("+p2.getX()+","+p2.getY()+")");
Point<Double> p3=new Point<Double>(); //点p3
p3.setX(5.9);
p3.setY(8.0);
System.out.println("p3:("+p3.getX()+","+p3.getY()+")");
Point<Double> p4=new Point<Double>(2.1,9.2); //点p4
System.out.println("p4:("+p4.getX()+","+p4.getY()+")");
}
}

public class Point<T>
{  
    private T x;
    private T y;
    public Point() {}
    public Point(T x, T y) {  this.x = x;  this.y = y;  } 
    public T getX() {  return  x;  }
    public T getY() {  return  y;  }    
    public void setX(T x) {  this.x = x;  }
    public void setY(T y) {  this.y = y; }    
}

class ArrayAlg {
   public static <T extends Comparable> Pair<T> minmax(T[ ] a) {
        if (a == null || a.length == 0) {
            return null;
        }
        T min = a[0];T max = a[0];
        for (int i = 1; i < a.length; i++) {
            if (min.compareTo(a[i]) > 0) {min = a[i];}
            if (max.compareTo(a[i]) < 0) { max = a[i];}
        }
        return new Pair<T>(min, max);
    }
}

        GregorianCalendar[ ] birthdays = {
            new GregorianCalendar(1906, Calendar.DECEMBER, 9), 
            new GregorianCalendar(1815, Calendar.DECEMBER, 10), 
            new GregorianCalendar(1903, Calendar.DECEMBER, 3), 
            new GregorianCalendar(1910, Calendar.JUNE, 22), 
        };
        Pair<GregorianCalendar> mm =   ArrayAlg.minmax(birthdays);
        System.out.println("min = " + mm.getFirst().getTime());
        System.out.println("max = " + mm.getSecond().getTime());

     

如何求出一个int类型数组的最大值和最小值？

如何求出一个String类型数组的最大值和最小值(字典顺序)？

String[ ] words ={"able","word","excel","course","java","c#"};
      Pair<String> mm = ArrayAlg.minmax(words);
      System.out.println("first word = " + mm.getFirst());
      System.out.println("last word = " + mm.getSecond());