Java-集合框架2

泛型：

• Java泛型，JDK1.5引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
• 常见的有：泛型类，泛型接口、泛型方法。
• 语法：
  • <T,...> T称为类型占位符，表示一种引用类型。
• 好处：
  • 提高代码重用性
  • 防止类型转换异常，提高代码安全性

/**
 * 泛型类
 * 语法：类名<T>
 * T是类型占位符，表示一种引用类型如果编写多个使用逗号隔开
 */
public class MyGeneric<T> {
    //泛型的使用
    //创建变量
    T t;

    //创建方法（作为方法的参数）
    public void show(T t){
        //泛型不能实例化
        //T t1 = new T();
        System.out.println(t);

    }

    //泛型作为方法的返回值
    public T getT(){
        return t;
    }
}

public class TestGeneric {
    public static void main(String[] args) {
        //使用泛型类创建对象
        //注意：1、泛型只能使用引用类型。2、不同的泛型类型对象之间不能相互赋值。
        MyGeneric<String> generic = new MyGeneric<>();
        generic.t="Hello";
        generic.show("Hi");
        String t = generic.getT();
        System.out.println(t);

        MyGeneric<Integer> generic1 = new MyGeneric<Integer>();
        generic1.t=100;
        generic1.show(200);
        Integer t1 = generic1.getT();
        System.out.println(t1);

        //MyGeneric<String> generic2 = generic1;
        //泛型接口
        MyInterfaceImpl2 myInterface2 = new MyInterfaceImpl2();
        myInterface2.server("xxxxx");

        //泛型方法
        MyGenericMethod method = new MyGenericMethod();
        method.show("Generic");
    }
}

泛型接口

/**
 * 泛型接口
 * 语法：接口名<t>
 *     注意：不能泛型静态常量
 */
public interface MyInterface<T> {
    String name = "张三 ";
    T server(T t);
}

public class MyInterfaceImpl implements MyInterface<String> {
    @Override
    public String server(String o) {
        System.out.println(o);
        return o;
    }
}

public class MyInterfaceImpl2<T> implements MyInterface<T>{
    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}

泛型集合

• 参数化类型，类型安全的集合，强制集合的类型必须一致。

• 特点：
  • 编译时即可检查，而非运行时抛出异常。
  • 访问时不必转换类型（拆箱）。
  • 不同泛型之间引用不能相互赋值，泛型不存在多态

import java.util.ArrayList;
import java.util.Iterator;

public class Demo03 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("曾小贤");
        list.add("胡一菲");
//        list.add(18);
//        list.add(20);
        for (String s : list) {
            System.out.println(s);
        }

        Student s1 = new Student("胡一菲",19);
        Student s2 = new Student("曾小贤",20);
        Student s3 = new Student("吕子乔",22);
        ArrayList<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        System.out.println("——————————————增强For——————————————————");
        for (Student student : students) {
            System.out.println(student.toString());
        }

        System.out.println("——————————————迭代器——————————————————");
        Iterator<Student> iterator = students.iterator();
        while (iterator.hasNext()){
            Student next = iterator.next();
            System.out.println(next);
        }
        //不同类型不能赋值
//        list = students;


    }
}