Java集合框架（二）泛型

Java集合框架（二）泛型

目录

• Java集合框架（二）泛型
  • 泛型
    • 什么是泛型
    • 泛型的常见形式
    • 泛型的语法
    • 代码实例
      • 泛型类
      • 泛型接口
      • 泛型方法
    • 泛型的好处
  • 泛型与集合框架

泛型

什么是泛型

• 参数化类型：将类型作为参数传递

泛型的常见形式

• 泛型类
• 泛型接口
• 泛型方法

泛型的语法

• <T,........> 其中T称为类型占位符(在实际使用的时候这里会填入类型)，它表示一种引用类型

代码实例

泛型类

• 类名<T,T...>

• T表示引用类型，不能是基础类型，如果表示多个引用类型则用逗号隔开

• 泛型不能用new实例化，因为不能保证

• 举例1：

  泛型类：

  public class Room<T> {
      //T代表一种数据类型，在使用的时候为T赋值（使用的时候再决定T做什么数据类型）
      //使用泛型T
      //创建变量
      T t;
      //添加方法
      public void show(T t){
          System.out.println(t);
      }
      //泛型作为方法的返回值
      public T getT(){
          return t;
      }
  }
  

  使用泛型类

  主函数：

  public class Demo07 {
      public static void main(String[] args) {
          //使用泛型类创建对象
          Room<String> room = new Room<>();
          //将占位符T命为String，则Room类里面的T代表String类型
          //所以t是String类型
          room.t = "史小鹏";
          System.out.println(room.getT());
      }
  }
  //输出：
  史小鹏
  

• 举例2：

  泛型类：

  public class Room2<A,B>{
      A s1;
      B s2;
      public A getS1(){
          return s1;
      }
      public B getS2(){
          return s2;
      }
  }
  

  使用泛型类

  主函数：

  public class Demo08{
      public static void main(String[] args) {
          //使用泛型类创建对象
          //<>里只能写引用对象，不能写基础对象，例如int是基础对象所以不能写
          /*
          1、Integer是int的包装类，int则是java的一种基本数据类型
          2、Integer变量必须实例化后才能使用，而int变量不需要
          3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值
          */
          Room2<String, Integer> room2 = new Room2<>();
          room2.s1="史小鹏";
          room2.s2=18;
          System.out.println(room2.getS1()+":"+room2.getS2());
      }
  }
  //输出：
  史小鹏:18
  

泛型接口

• 由于接口不能实例，所以接口没有实例变量，默认都是常量（必须赋值）

• 由于T（泛型）不能实例化，所以没有泛型常量，不能直接赋初值

• 举例1（实现类里指明T的泛型类型）：

  泛型接口：

  public interface Room3<T> {
      String name = "史小鹏";
      T server(T t);//方法
  }
  

  实现类：

  //接口Room3的实现类
  public class Room3_1 implements Room3<String>{
      String t;
      public String server(String t){
          this.t=t+"242";
          return this.t;
      }
  }
  

  主函数：

  public class Demo09 {
      public static void main(String[] args) {
          Room3_1 room3_1 = new Room3_1();
          System.out.println(room3_1.name);
          //使用实现类的方法
          System.out.println(room3_1.server("工作"));
      }
  }
  //输出：
  史小鹏
  工作242
  

• 举例2（实现类也是泛型类，不指明T泛型类型）：

  泛型接口：

  public interface Room3<T> {
      String name = "史小鹏";
      T server(T t);//方法
  }
  

  实现类：

  //接口Room3的实现类
  //泛型类的类型是什么，则泛型接口的类型就是什么
  public class Room3_1<T> implements Room3<T>{
      public T server(T t){
          return t;
      }
  }
  

  主函数：

  public class Demo09 {
      public static void main(String[] args) {
          Room3_1<String> room3_1 = new Room3_1<>();
          System.out.println(room3_1.server("sxp史小鹏"));
      }
  }
  //输出：
  sxp史小鹏
  

泛型方法

• 方法中的类型不用传递，它会根据你所传入的数据自动判断类型

• 举例：

  泛型方法：

  public class Room4 {
      public <T> void show(T t){
          System.out.println("泛型方法"+t);
      }
      public <A> A show2(A a){
          return a;
      }
  }
  

  主函数：

  //调用泛型方法
  public class Demo10 {
      public static void main(String[] args) {
          Room4 room4 = new Room4();
          //类型不用传递，它会根据你所传入的数据自动判断类型
          room4.show("abc");
          System.out.println(room4.show2(200));
      }
  }
  //输出：
  泛型方法abc
  200
  

泛型的好处

• 提高代码的重用性
• 防止类型转换异常，提高代码的安全性

泛型与集合框架

• 集合框架中是带有泛型的,不使用泛型的话默认是Object类型，但会导致其中的数据元素都是Object类型

• 举例1：

  public class Demo11 {
      public static void main(String[] args) {
          ArrayList<Integer> list = new ArrayList<>();
          list.add(10);
          list.add(20);
          System.out.println(list.get(0)+list.get(1));
      }
  }
  //输出：
  30
  

• 举例2：

  学生类：

  public class Student {
      private String name;
      private int age;
  
      public Student() {
      }
  
      public Student(String name, int age) {
          this.name = name;
          this.age = age;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public int getAge() {
          return age;
      }
  
      public void setAge(int age) {
          this.age = age;
      }
      //重写toString方法
      public String toString(){
          return this.name+" "+this.age;
      }
  }
  

  主函数：

  import java.util.ArrayList;
  import java.util.Iterator;
  
  public class Demo12 {
      public static void main(String[] args) {
          ArrayList<Student> arrayList = new ArrayList<>();
          Student s1 = new Student("张三",18);
          Student s2 = new Student("李四",19);
          Student s3 = new Student("王五",20);
          Student s4 = new Student("赵六",21);
          //添加元素
          arrayList.add(s1);
          arrayList.add(s2);
          arrayList.add(s3);
          arrayList.add(s4);
          Iterator iterator = arrayList.iterator();
          while(iterator.hasNext()){
              System.out.println(iterator.next());
          }
      }
  }
  //输出：
  张三 18
  李四 19
  王五 20
  赵六 21