集合(Collection ArrayList LinkedList 泛型) 4

泛型

我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成 Object 类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

public static void main(String[] args) {
    Collection coll = new ArrayList(); 
    coll.add("hello");
    coll.add("xu");
    coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放 
    Iterator it = coll.iterator(); 
    while(it.hasNext()){ 
        //需要打印每个字符串的长度,就要把迭代出来的对象转成String类型 
        String str = (String) it.next(); 
        System.out.println(str.length()); 
    }
 }

程序在运行时发生了问题 java.lang.ClassCastException。 为什么会发生类型转换异常呢？ 我们来分析下：由于集合中什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException。 怎么来解决这个问题呢？Collection 虽然可以存储各种对象，但实际上通常 Collection只存储同一类型对象。例如都是存储字符串对象。因此在 JDK5 之后，新增了 泛型 ( Generic ) 语法，让你在设计 API 时可以指定类或方法支持泛型，这样我们使用 API的时候也变得更为简洁，并得到了编译时期的语法检查。

• 泛型：可以在类或方法中预知使用未知的类型
• 注意：一般在创建对象是，将未知的类型确定具体的类型。当没有指定泛型时，默认类为Object类型。

使用泛型的好处

• 将运行时期的ClassCastException转移到了编译时期编程编译失败
• 避免类型强制转换的麻烦

public static void main(String[] args){
    Collection<String> list = new ArrayList<String>(); 
    list.add("hello"); 
    list.add("xu"); 
    // list.add(5);//当集合明确类型后，存放类型不一致就会编译报错 
    // 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型 
    Iterator<String> it = list.iterator(); 
    while(it.hasNext()){ 
        String str = it.next(); 
        //当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型 
        System.out.println(str.length()); 
    } 
}

定义和使用含有泛型的类

格式：

修饰符 class 类名<代表泛型的变量>{}

列如，API中的ArrayList集合：泛型在定义时不具体，使用时才变得具体，在使用时确定泛型的具体数据类型。

class ArrayList<E>{
    public boolean add(E e){}

    public E get(int index){}
    ...
}

使用泛型L就是在什么时候确定泛型。在创建对象的时候确定泛型

如：

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

此时，变量E的值为String类型时，那么我们的类型就可以理解为：

class ArrayList<String>{
    public boolean ass(String e){}
    
    public String get(int index){}
    ...
}

此时，变量E的值为Integer类型时，那么我们的类型就可以理解为：

class ArrayList<Integer>{
    public boolean ass(Integer e){}
    
    public Integer get(int index){}
    ...
}

含有泛型的方法

格式：

修饰符 <代表泛型的变量> 返回值类型 方法名（参数）{}

如：

public class MyGenericMethod { 
    public <MVP> void show(MVP mvp) { 
        System.out.println(mvp.getClass()); 
    }
    public <MVP> MVP show2(MVP mvp) { 
        return mvp; 
    } 
}

调用方法时，确定泛型的类型

public static void main(String[] args){
    //创建对象
    MyDenericMethod mm = new MyGeericMethod();
    //演示看方法提示
    mm.show("aaa1");
    mm.show(123233);
    mm.show(12.322);
}

含有泛型的接口

格式：

public interface MyGenericInterface<E>{
    public abstract void add(E e);
    
    public abstract E getE();
}

1、定义类时确定泛型的类型

public class MyImp1 implements MyGenericInterface<String> { 
    @Override 
    public void add(String e) { 
        // 省略... 
    }
    @Override 
    public String getE() { 
        return null; 
    } 
}

此时泛型E的值就是String类型

2、始终不确定泛型的类型，知道创建对象时再确定泛型的类型

列如：

public class MyImp2<E> implements MyGenericInterface<E>{
    @Override
    public void add(E e){]
        //省略...
    }
    
    @Override
    public E getE(){
        return null;
    }
}

确定泛型：

public static void main(String[] args){
    MyImp2<String> my = new MyImp2<String>();
    my.add("asa);
}

泛型通配符

当时用泛型类或者接口时 ，传递的数据中，泛型类型不确定，可以通过通匹配符<?>表示，但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法自身无法使用。

通配符基本使用

泛型的通配符 : 不知道使用什么类型来接收的时候 , 此时可以使用 ?,? 表示未知通配符。

此时只能接受数据 , 不能往该集合中存储数据。

 

public static void main(String[] args){
    Collection<Integer> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(lis2);
}
//?为通配符，可以接受任意类型
public static void getElement(Collection<?> coll){
    Iterator<?> it = coll.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
}

注意：泛型不存在继承关系Collection list = new ArrayList（）；这种是错误的！

通配符高级使用---受限泛型

之前设置泛型时，实际上可以任意设置，只要是类就行。但是在Java的泛型中可以指定一个泛型的上限和下限。

反省的上限：

• 格式：

类型名称<? extends 类>对象名称

• 意义：只接受给类型及其子类

泛型的下限

• 格式：

类型名称<?super 类> 对象名称

• 意义：只能接受该类型及其父类

案例：

需求：创建老师类和班主任类，提供姓名和年龄属性，并都具有work方法。将多个老师对象和多个班主任对象存储到两个集合中。提供一个方法可以同时遍历两个集合，并调用work方法。

Employee员工类：

public abstract class Employee{
    private String name;
    private int age;
    
    public Employee(){
    }
    
    public Employee(String name,int age){
        this.name = name;
        this.age = age;
    }
    //省略get/set
    public abstract void work();
}

Teacher类：

public class Teacher extends Employee{
    public Teacher(){
    }
    public Teacher(String name,int age){
        super(name,age);
    }
    @Override
    public void work(){
        System.out.println("老师在上课“）；
    }
}

Manager类：

public class Manager extends Employee{
    public Manager(String name, int age){
        super(name, age);
    }
    public Manager(){}
    
    @Override
    public void work(){
        System.out.println("班主任管理班级“);
    }
}

测试类：

public static void main(String[] args) throws  UnsupportedEncodingException{
    List<Teacher> teacherList = new ArrayList<Teacher>();
    teacherList.add(new Teacher("zahngsan",30);
    teacherList.add(new Teacher("lisi",23);
    
    List<Manager> managerList = new ArrayList<Manager>();
    managerList.add(new Manager("wangwu",23);
    managerList.add(new Manager("zhaoliu:,24);
    getElement(teacherList);
    getElement(managerList);
}
//定义方法，参数为List集合，泛型被限定为Employee，可以接受的泛型为Employee或者子类！
public static void getElement(List<? extends Employee> list){
    Iterator<? extends Employee> it  =  list.iterator();
    while(it.hacNext()){
        Employee employee = it.next();
        System.out.println(employee.getName()+"::"+employee.getAge());
        employee.wprk();
    }
}