• 泛型的使用

       1.JDK 5 新增的特性

       2.在集合中使用泛型：
      总结：
       ①集合接口或集合类在JDK 5 时都修改为带泛型的结构。
      ②在实例化集合类时，可以指明具体的泛型类型
       ③指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）
      使用到类的泛型的位置，都指定为实例化的泛型类型。
       比如：add(E e) ——>实例化以后：add(Integer e)
      ④注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
       ⑤如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。

       3.如何自定义泛型结构：泛型类、泛型接口；泛型方法。 见GenericTest2.java

       ```java package com.atguigu.java1;

    import org.junit.Test;

    import java.util.*;

    /**

    • 泛型的使用 *
    • 1.JDK 5 新增的特性 *
    • 2，在集合中使用泛型：
    • 总结：
    • ①集合接口或集合类在JDK 5 时都修改为带泛型的结构。
    • ②在实例化集合类时，可以指明具体的泛型类型
    • ③指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）
    • 使用到类的泛型的位置，都指定为实例化的泛型类型。
    • 比如：add(E e) ——>实例化以后：add(Integer e)
    • ④注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
    • ⑤如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。 *
    • 3.如何自定义泛型结构：泛型类、泛型接口；泛型方法。 见GenericTest2.java
    • @author Dxkstart

    • @create 2021-05-25 20:12 */ public class GenericTest {

      //在集合中使用泛型之前的情况： @Test public void test1() {

      1.  ArrayList list = new ArrayList();
      2.  //需求：存放学生的成绩
      3.  list.add(78);
      4.  list.add(89);
      5.  list.add(79);
      6.  list.add(98);
      7.  //问题一：类型不安全
      8.  list.add("Tom");
      10.  for (Object obj : list) {
      11.      //问题二；强转时，可能出现ClassCastException
      12.      int score = (Integer) obj;
      13.      System.out.println(score);
      14.  }

      }

    1. //在集合中使用泛型的情况：以ArrayList举例
    2. @Test
    3. public void test2() {
    4.     ArrayList<Integer> list = new ArrayList<Integer>();
    6.     list.add(1233);
    7.     list.add(123);
    8.     list.add(42);
    9.     list.add(345);
    10.     //编译时，就会进行类型检查，保证数据的安全

    // list.add(“Tom”);

    1.     //方式一：
    2.     for (Integer score : list) {
    3.         //避免了强转操作
    4.         int stu = score;
    5.         System.out.println(stu);
    6.     }
    8.     //方式二：
    9.     Iterator<Integer> iterator = list.iterator();
    10.     while (iterator.hasNext()) {
    11.         int stuScore = iterator.next();
    12.         System.out.println(stuScore);
    13.     }
    15. }
    17. //在集合中使用泛型的情况：以ArrayList举例
    18. @Test
    19. public void test3(){
    20.     HashMap<String, Integer> map = new HashMap<>();
    22.     map.put("Tom",123);
    23.     map.put("Jerry",1543);
    24.     map.put("Mack",673);

    // map.put(324,”Tom”);

    1.     //泛型的嵌套
    2.     Set<Map.Entry<String, Integer>> entry = map.entrySet();
    3.     Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
    5.     while (iterator.hasNext()){
    6.         Map.Entry<String, Integer> e = iterator.next();
    7.         String key = e.getKey();
    8.         Integer value = e.getValue();
    9.         System.out.println(key + "***" + value);
    10.     }
    12. }

    }

    ```