【大数据】学习笔记 1 Java SE 第13章泛型 13.5 类型通配符

短命女 2024-03-22 14:07 74阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第13章 泛型
             *   *  13.5 类型通配符
                 *   *  13.5.1 Java泛型指定限制问题
                     *  13.5.2 类型通配符
                     *  13.5.3 类型通配符的三种使用形式
                     *  13.5.4 使用类型通配符来指定类型参数的问题

![在这里插入图片描述][a04cba95932646efbc16c2bcef9263a6.png_pic_center]

#### 1 Java SE ####

##### 第13章 泛型 #####

###### 13.5 类型通配符 ######

###### 13.5.1 Java泛型指定限制问题 ######

声明一个方法，形参是Collection，但是元素类型不确定，怎么办？

package com.dingjiaxiong.wildcard;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestProblem
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:39
     */
    
    public class TestProblem {
        
        public static void m1(Collection<Object> coll) {
        
            for (Object o : coll) {
        
                System.out.println(o);
            }
        }
    
        public static void m2(Collection coll) {
        
            for (Object o : coll) {
        
                System.out.println(o);
            }
        }
    
        public static <T> void m3(Collection<T> coll) {
        
            for (T o : coll) {
        
                System.out.println(o);
            }
        }
    
        public static void main(String[] args) {
        
            m1(new ArrayList<Object>());//Collection<Object> coll = new ArrayList<Object>();
            m1(new ArrayList<>());//Collection<Object> coll = new ArrayList<>();//与上面完全等价
            m1(new ArrayList());//Collection<Object> coll = new ArrayList();//有警告
    //        m1(new ArrayList<String>());//Collection<Object> coll = new ArrayList<String>();//错误
    
            //编译看左边，左边泛型擦除，此处泛型按照Object处理，右边泛型指定啥都没用
            m2(new ArrayList<Object>());//Collection coll = new ArrayList<Object>();
            m2(new ArrayList<>());//Collection coll = new ArrayList<>();//与上面完全等价
            m2(new ArrayList());//Collection coll = new ArrayList();//泛型擦除
            m2(new ArrayList<String>());//Collection coll = new ArrayList<String>();
    
            m3(new ArrayList<Object>());//Collection<Object> coll = new ArrayList<Object>();
            m3(new ArrayList<>());//Collection<> coll = new ArrayList<>();//与上面完全等价
            m3(new ArrayList());//Collection<Object> coll = new ArrayList();//有警告
            m3(new ArrayList<String>());//Collection<String> coll = new ArrayList<String>();
        }
    }

###### 13.5.2 类型通配符 ######

当我们声明一个变量/形参时，这个变量/形参的类型是一个泛型类或泛型接口，例如：Comparator类型，但是我们仍然无法确定这个泛型类或泛型接口的类型变量的具体类型，此时我们考虑使用类型通配符 ? 。

package com.dingjiaxiong.wildcard;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestWildcard
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:40
     */
    
    public class TestWildcard {
        
        public static void m4(Collection<?> coll) {
        
            for (Object o : coll) {
        
                System.out.println(o);
            }
        }
    
        public static void main(String[] args) {
        
            //右边泛型指定为任意类型或不指定都可以
            m4(new ArrayList<Object>());//Collection<?> coll = new ArrayList<Object>();
            m4(new ArrayList<>());//Collection<?> coll = new ArrayList<>();
            m4(new ArrayList());//Collection<?> coll = new ArrayList();
            m4(new ArrayList<String>());//Collection<?> coll = new ArrayList<String>();
        }
    }

###### 13.5.3 类型通配符的三种使用形式 ######

类型通配符 ? 有三种使用形式：

*  <?>：完整形式为：类名<?> 或接口名<?>，此时?代表任意类型。
 *  <? extends 上限>：完整形式为：类名<? extends 上限类型> 或接口名<? extends 上限类型>，此时?代表上限类型本身或者上限的子类，即?代表 <= 上限的类型。
 *  <? super 下限>：完整形式为：类名\\<? super 下限类型> 或接口名\\<? super 下限类型>，此时?代表下限类型本身或者下限的父类，即?代表>= 下限的类型。

案例：

声明一个集合工具类MyCollections，要求包含：

*  public static boolean different(Collection<?> c1, Collection<?> c2)：比较两个Collection集合，此时两个Collection集合的泛型可以是任意类型，如果两个集合中没有相同的元素，则返回true，否则返回false。
 *  public static void addAll(Collection<? super T> c1, T… args)：可以将任意类型的多个对象添加到一个Collection集合中，此时要求Collection集合的泛型指定必须>=元素类型。
 *  public static void copy(Collection<? super T> dest,Collection<? extends T> src)：可以将一个Collection集合的元素复制到另一个Collection集合中，此时要求原Collection泛型的类型<=目标Collection的泛型类型。

package com.dingjiaxiong.wildcard;
    
    import java.util.Collection;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: MyCollections
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:40
     */
    
    public class MyCollections {
        
        public static boolean different(Collection<?> c1, Collection<?> c2) {
        
            for (Object o : c1) {
        
                if (c2.contains(o)) {
        
                    return false;
                }
            }
            return true;
        }
    
        public static <T> void addAll(Collection<? super T> c1, T... args) {
        
            for (int i = 0; i < args.length; i++) {
        
                c1.add(args[i]);
            }
        }
    
        public static <T> void copy(Collection<? super T> dest, Collection<? extends T> src) {
        
            for (T t : src) {
        
                dest.add(t);
            }
        }
    
    }

测试类

package com.dingjiaxiong.wildcard;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: MyCollectionsTest
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:41
     */
    
    public class MyCollectionsTest {
        
        public static void main(String[] args) {
        
            Collection<Integer> c1 = new ArrayList<Integer>();
            MyCollections.addAll(c1, 1, 2, 3, 4, 5);
            System.out.println("c1 = " + c1);
    
            Collection<String> c2 = new ArrayList<String>();
            MyCollections.addAll(c2, "hello", "java", "world");
            System.out.println("c2 = " + c2);
    
            System.out.println("c1 != c2 " + MyCollections.different(c1, c2));
    
            Collection<Object> c3 = new ArrayList<>();
            MyCollections.copy(c3, c1);
            MyCollections.copy(c3, c2);
            System.out.println("c3 = " + c3);
        }
    }

![在这里插入图片描述][cd614087838f4359afc54c26158bd4e5.png_pic_center]

###### 13.5.4 使用类型通配符来指定类型参数的问题 ######

package com.dingjiaxiong.wildcard;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestWildcardProblem
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:42
     */
    
    public class TestWildcardProblem {
        
        public static void main(String[] args) {
        
            Collection<?> c1 = new ArrayList<>();
    //        c1.add(new Object());
    //        c1.add("hello");
    //        c1.add(1);
            //不能添加，c1只读
    
    
            Collection<? extends Object> c2 = new ArrayList<>();
    //        c2.add(new Object());
    //        c2.add("hello");
    //        c2.add(1);
            //不能添加，c2只读
    
            Collection<? super Number> c3 = new ArrayList<>();
    //        c3.add(new Object());
    //        c3.add("hello");
            c3.add(1);
            //可以添加Number对象或Number子类对象
        }
    }

[a04cba95932646efbc16c2bcef9263a6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/f159c17fde6748c6be578a69d27d0ea1.png
[cd614087838f4359afc54c26158bd4e5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/7ec94dad894b4fa7a6e37775864afe33.png