Java 泛型详解

泛型

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

代码实现:
泛型类:

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

public class Worker<M> {
    // 利用泛型写成员变量
    private M m;
    // 利用泛型写set/get 方法
        public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public void work() {
        System.out.println("天天搬砖 一天能搬800块");
    }

    public void sayHi(M m) {
        System.out.println(m);
    }

    // 声明不同泛型的泛型方法 在调用泛型方法 指定泛型的类型
    //<Z> 声明泛型 只有声明过 才能使用
    public<Z> void print(Z z) {
        System.out.println(z);
    }

    // 静态方法 
    // 当你调用静态方法的时候 可能还没有对象 没有对象就没指定泛型 所以不能用类的泛型
    public static<W> void fun(W w) {
        System.out.println(w);
    }
}

interface InterA<A>{
        void fun(A a);
    }

class InterAImpl implements InterA<String>{
    @Override
    public void fun(String a) {
        System.out.println(a);
    }   
}   

//测试类
public class Demo01 {
    public static void main(String[] args) {
        //fun1();
        //fun2();       
        //fun3();
        // 创建实现类

    }

    /**
     * 泛类型
     */
    public static void fun3() {
        // 创建泛型类
        Worker<String> worker = new Worker<>();
        worker.setM("james");
        worker.sayHi("james");
        System.out.println(worker.getM());
        // 调用 方法时候 自动给定类型
        worker.print("Tom");    
        Worker.fun("haha");
    }

    /**
     * 泛型的好处和一些问题处理
     * 
     */
    public static void fun2() {
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("james", 18));
        list.add(new Student("Tom", 17));
        list.add(new Student("Jerry", 19));
        // 获取迭代器 设置泛型 可以把运行期的报错 转换到编译期报错
        Iterator<Student> iterator = list.iterator();
        Student next = iterator.next();
        System.out.println(next);
    }

    /**泛型的介绍
     * 保持字符串
     * 
     */
    public static void fun1() {
        // 创建一个集合 
        //<E> E 代表 要保存的元素类型
        // 后面的尖括号 要跟前面填的泛型 保持一致
        // JDK 1.7 后 菱形泛型 如果前面声明了泛型 后面的泛型可以省略不写
        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);
        }
    }
}

在以前学习的一些方法中 我们经常在文档中可以看到这样的说明

可以看到其中传入参数中包含 ” < ? extends E> c ” 这个表示什么呢?

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

有时候我们还能看到:? super E 它表示

? 是父类 E 是 子类 ? 只能是E类的 父类

代码示例:

public class Demo02 {
    public static void main(String[] args) {
        //fun1();
        // 调用1 传入数组
        //int[] array = new int[] {1,2,3,4,5};
        //fun2(array);
        // 调用2 直接传入数字
        //fun2(1,2,3,4,5);

        // 把数组转化为集合
        int[] array = new int[] {1,2,3,4,5};
        // 把数组 当做集合中的一个元素 转为了集合
        List<int[]> asList = Arrays.asList(array);
        System.out.println(asList);

        Integer[] array2 = {1,2,3,4,5};// 自动装箱
        List<Integer> asList2 = Arrays.asList(array2);
        System.out.println(asList2);

        String[] array3 = {"wanglong","jamesPengDil"};
        List<String> asList3 = Arrays.asList(array3);
        System.out.println(asList3);
        // 如果数组转集合 通过使用aslist 得到一个集合 注意这个集合 不允许添加或删除的操作
        //  虽然不能添加删除    但是可以调用集合其他方法
        boolean contains = asList3.contains("wanglong");
        System.out.println(contains);   
    }   
    // int ... num 相当于传入的参数是数组
    // int ... num  可以接收多个参数 只能是方法参数的最后一个
    public static void fun2(int ... num) {
        for (int i = 0; i < num.length; i++) {
            System.out.println(num[i]);
        }
    }
    /**
     *      ? extends E(向下限定)
     * 
     */
    public static void fun1() {
        /*
         * 创建一个保存人的集合 存2人
         * 创建一个保存学生的集合 存2人
         */
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("james", 19));
        list.add(new Person("Tom", 18));

        ArrayList<Student> list2 = new ArrayList<>();
        list2.add(new Student("Jerry", 17));
        list2.add(new Student("Mike",16));
        // 学生集合 添加到人当中
        // ? extends Person  只能填Person的子类
        list.addAll(list2);
        System.out.println(list);
    }
}

集合的删除操作

代码实现:

public class Demo03 {
    public static void main(String[] args) {
        //fun1();
        //fun2();
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        // 增强for循环只能用来遍历 也叫快速遍历
        // 双层遍历的时候 使用
        for (String string : list) {
            System.out.println(string);
        }   
    }

    /**
     * 迭代器删除
     */
    public static void fun2() {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        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);
    }

    /**
     * 集合删除
     */
    public static void fun1() {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        // 不使用迭代器 遍历
        // 如果集合中有b 就把b删除
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).equals("b")) {
                // 先当参数传进去 在进行自减
                list.remove(i--);
        }
        }
        System.out.println(list);
    }
}

集合中查找某些元素

代码实现:

public class Demo05 {
    public static void main(String[] args) {
        /*
         * 创建一个集合  java学科 学科中有两个班 班里有学生(使用泛型)
         * 遍历java学科中的学生
         */
        // 声明学科的集合
        ArrayList<ArrayList<Student>> subject = new ArrayList<>();
        // 声明班
        ArrayList<Student> subClass = new ArrayList<>();
        subClass.add(new Student("james",19));
        subClass.add(new Student("Tom",18));

        ArrayList<Student> subClass1 = new ArrayList<>();
        subClass1.add(new Student("Jerry",17));
        subClass1.add(new Student("Mike",16));
        //  班添加进学科
        subject.add(subClass);
        subject.add(subClass1);

        //遍历学科中的学生
            Iterator<ArrayList<Student>> iterator = subject.iterator();
            Iterator<Student> iterator2 = subClass.iterator();
            Iterator<Student> iterator3 = subClass1.iterator();
            while (iterator.hasNext()) {
                iterator.next();
                while (iterator2.hasNext()) {
                    System.out.println(iterator2.next());
                }
                while (iterator3.hasNext()) {
                    System.out.println(iterator3.next());
                }

            }   
        // 通过学科找到班
//      for (ArrayList<Student> list : subject) {
//          //通过班找到学生
//          for (Student student : list) {
//              System.out.println(student);
//          }
//      }
    }
}