Java基础

Java集合框架

泛型

• 本质是参数化类型，把类型作为参数传递
• 常见类型有泛型类、泛型 接口、泛型方法
• 好处：提高代码的重用性、防止类型转换异常

​ 泛型类

/**
 * 泛型类
 * 语法：类型<T>
 *     T是一个占位符，表示一种引用类型。可以编写多个逗号隔开
 * @author xue
 */
public class GenericDemo<T> {
    //使用泛型T
    T t;

    //泛型作为方法的参数
    public void show(T t) {
        System.out.println(t);
    }

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

public class TestGeneric {
    
    public static void main(String[] args) {
        //使用泛型类创建对象
        GenericDemo<String> gd = new GenericDemo();
        gd.t = "test";
        gd.show("nihao");
        System.out.println(gd.getT());

        GenericDemo<Integer> gd2 = new GenericDemo<>();
        gd2.t = 23424;
        gd2.show(234256436);
        System.out.println(gd2.getT());
        
        //不同泛型对象不能相互复制
        //GenericDemo<String> gd3 = gd2;
    }
}

​ 泛型接口

/**
 * 泛型接口
 * 语法：接口名<T>
 * 不能泛型静态常量
 * @param <T>
 * @author xue
 */
public interface GenericDemo2<T> {
    String name = "zhangsan";

    T server(T t);
}


/**
 * 这里是先指定泛型类型
 */
public class GenericDemo2Imp implements GenericDemo2<String>{


    @Override
    public String server(String s) {
        System.out.println(s);
        return s;
    }
}

//使用泛型接口类GenericDemo2Imp
//使用时直接创建对象
        GenericDemo2Imp gd2i = new GenericDemo2Imp();
        gd2i.server("我被String固定了");


/**
 * 这里是不指定泛型类型
 */
public class GenericDemo2Imp2<T> implements GenericDemo2<T>{
    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}


//使用泛型接口类GenericDemo2Imp2
        GenericDemo2Imp2<Integer> gd2i2 = new GenericDemo2Imp2();
        gd2i2.server(123);
        GenericDemo2Imp2<String> gd2i3 = new GenericDemo2Imp2();
        gd2i3.server("我可以自己指定泛型了");

​ 泛型方法

/**
 * 泛型方法
 * 语法： <T> 返回值类型
 * @author xue
 */
public class FuncDemo {

    //泛型方法 可以是静态
    public <T> T show(T t){
        System.out.println("泛型方法"+t);
        return t;
    }
}

//泛型方法调用
        FuncDemo fd = new FuncDemo();
        //方法传入类型是什么 泛型类型就是什么
        fd.show("我是String类型");

泛型集合

• 参数化类型、类型安全的集合，强制集合元素的类型必须一致。
• 编译时即可检查是否异常
• 访问时不必类型转换了
• 不同反省之间引用不能相互赋值，泛型不存在多态

public class GenericDemo1 {
    public static void main(String[] args) {
        ArrayList<String> alist = new ArrayList<>();
        alist.add("只能");
        alist.add("添加");
        alist.add("字符串");

        for (String s:alist) {
            System.out.println(alist);
        }

        ArrayList<Student> alist2 = new ArrayList<>();
        Student stu1 = new Student("zhangsan",20);
        Student stu2 = new Student("lisi",23);
        Student stu3 = new Student("wangwu",45);
        alist2.add(stu1);
        alist2.add(stu2);
        alist2.add(stu3);

        Iterator<Student> it = alist2.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s);
        }
        
        //有了泛型之后可以发现不必强制转换类型了

    }
}