Java 集合之泛型详解

泛型

泛型表示集合中保存数据的类型

    /*
     * 保存字符串
     * ArrayList<E> E就代表 要保存的元素类型 
     * 后面的尖括号 要跟前面填的泛型保持一致
     * 如果前面声明了泛型 后面泛型可以省略不写 省略不写 表示类型一致
     * jdk1.7 菱形泛型
     */
    public static void fun1() {
        // 创建一个集合 保存a b c d
        ArrayList<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        // 遍历
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            // 添加泛型之后 可以省去强转类型的麻烦
            String next = iterator.next();
            System.out.println(next);
        }
    }

    /*
     * 写泛型编译期就会报错
     */
    public static void fun2() {
        // 创建集合 保存3学生
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("aaa", 12));
        list.add(new Student("bbb", 15));
        list.add(new Student("ccc", 18));
        // 获取迭代器
        Iterator<Student> iterator = list.iterator();
        Student next = iterator.next();
        System.out.println(next);

        // 设置泛型 可以把运行期报错 转化到编译期就报错
        // Worker worker = (Worker)iterator.next();
    }

泛型类

泛型类(泛型类声明时  尖括号中的字母 可以随便定义)
泛型类的类型在初始化这个类的对象的时候确定

代码示例:
        public class Worker<T> {
            // 利用泛型写成员变量
            private T t;
            // 利用泛型写 set/get 方法
            public T getT() {
                return t;
            }

            public void setT(T t) {
                this.t = t;
            }
            // 普通成员方法
            public void sayHi(T t) {
                System.out.println(t);
            }
            // 声明不同泛型的方法 在调用泛型方法的时候 指定泛型的类型
            // <Z> 声明一个泛型 只有声明过 才能使用
            public<Z> void print(Z z) {
                System.out.println(z);
            }
            // 静态方法不能直接使用T,当你调用静态方法的时候可能还没有对象,没有对象就没有指定泛型所以不能用
            public static<R> void fun(R r) {
                System.out.println(r);
            }
            // 工作方法
            public void work() {
                System.out.println("搬砖");
            }
        }

        public static void fun3() {
            // 创建泛型类
            Worker<String> worker = new Worker<>();
            // 给属性赋值
            worker.setT("hhh");
            System.out.println(worker.getT());
            // 调用成员方法
            worker.sayHi("...");
            // 调用 方法 给定类型
            worker.print("---");
            Worker.fun("***");
            worker.work();
        }

泛型接口

        // 泛型接口
        interface InterA<W>{
            public abstract void fun(W w);
        }

        // 实现类
        class InterAImpl implements InterA<String>{
            @Override
            public void fun(String w) {
                System.out.println(w);
            }
        }

        public static void main(String[] args) {
            // 创建实现类
            InterAImpl impl = new InterAImpl();
            impl.fun("```");
        }

向下限定/向上限定

? extends E (向下限定)
?是子类 继承 E是父类  ?只能是 E类 的子类

? super   E(向上限定)
?是父类    E是子类   ?只能是E类的 父类

? extends E (向下限定) 代码:
                /*
                 * 需求:
                 * 创建一个保存人的集合  存2人
                 * 创建一个保存学生的集合 存2人
                 */
                ArrayList<Person> persons = new ArrayList<>();
                persons.add(new Person("qwe", 11));
                persons.add(new Person("asd", 15));

                ArrayList<Student> students = new ArrayList<>();
                students.add(new Student("zxc", 20));
                students.add(new Student("rty", 21));
                //  学生的集合 全部添加到 人的集合中
                // ? extends Person 只能填Person的子类
                // students.addAll(persons);
                persons.addAll(students);
                System.out.println(persons);

int … num

int ... num 相当于传入的参数是个数组,可以接受多个参数 但是只能是方法参数的最后一个

代码:
    public static void fun2(int ... num) {
        // 遍历
        for (int i = 0; i < num.length; i++) {
            System.out.println(num[i]);
        }
    }
    // 调用方式一 直接传入数组
    int[] array = {1, 3, 5, 7, 9};
    fun2(array);
    // 调用方式二 传入多个数
    fun2(1, 2, 3, 4, 5, 6, 7, 8, 9);

数组转集合

使用Arrays类方法把数组转换为集合:

        int[] array = {1, 3, 5, 7, 9};// 没有进行自动装箱
        // 把数组当做集合中的一个元素转为了集合
        List<int[]> asList = Arrays.asList(array);
        System.out.println(asList);

        Integer[] array2 = {1, 3, 5, 7, 9};
        List<Integer> asList2 = Arrays.asList(array2);
        System.out.println(asList2);

        String[] array3 = {"wanglong","wangwu"};
        // 使用asList数组转集合 得到一个集合
        List<String> asList3 = Arrays.asList(array3);
        boolean contains = asList3.contains("wanglong");
        System.out.println(asList3);
        System.out.println(contains);

注意:这个集合不允许进行添加或删除的操作,可以调用集合的其他方法

集合中的删除方法

1.不使用迭代器
        // 创建一个集合 
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        // 不使用迭代器 遍历
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).equals("b")) {
                // 先当参数传进去  在进行自减
                list.remove(i--);
            }
        }
        System.out.println(list);

2.使用迭代器
        // 创建一个集合 
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("b");
        list.add("d");
        list.add("e");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            if (iterator.next().equals("b")) {
                iterator.remove();
            }
        }
        System.out.println(list);