泛型

一、泛型

1、泛型定义

​ 泛型（generics）是JDK5.0以后的特性，提供了编译期间安全监测机制，它是将数据类型参数化的一种方式。 例如：在对方法进行编写参数列表时，以前我们需要知道方法的参数类型 ，现在使用泛型机制可以将方法的参数类型也作为 “未知的类型” ，在调用该方法时传递该类型。

2、泛型的使用

2.1 泛型类（generic class）

​ 它是一种具有一个或多个类型变量的类，（一个变量可以有多种类型）

​ 语法

  public  class  类{
      // 类里面的数据类型 和 方法返回值，以及方法的参数都可以使用T  
      // <>里面可以是任意大写字母
      
  }

public class People<T> {
    private T name;
    private T sex;

    public T getName() {
        return name;
    }
       public People(T name,T sex){
        this.name= name;
        this.sex = sex;
    }
    public People(){

    }
}

       // 创建没有指定泛型的对象 ，它默认是Object类型
        People  obj= new People();
        obj.setName("李四");
        System.out.println(obj);
        System.out.println(((String)obj.getName()).length());

        // 创建泛型类的对象
        People<String> people = new People<String>("张三","男");
        System.out.println(people);
        System.out.println(people.getName().length());

定义泛型的字母

T ： Type： 变量类型

K： Key ： 任意键的类型

V： Value ： 任意值的类型

E：ELement 用于定义集合的元素类型

2.2 泛型接口（generic interface）

​ 在接口中定义泛型，使接口的方法可以使用该泛型，实现类实现该接口时需要指定接口的类型、

语法：

public interface Genarator<T> {
    public T getValue();

    public void setValue(T s);


}

public class StringGenarator implements  Genarator<String> {
   private String name;

    @Override
    public String getValue() {
        return name;
    }

    @Override
    public void setValue(String s) {
        this.name=s;
    }

public class StudentGenarator implements Genarator<Student> {
    private Student  stu;

    @Override
    public Student getValue() {
        return stu;
    }

    @Override
    public void setValue(Student s) {
        this.stu = s;
    }
}

泛型接口的好处：

​ 让接口的方法的返回值或参数类型 也参数化 （泛型）

2.3 泛型方法

​ a、为什么会使用泛型方法

​ 当一个类中 只有某个方法需要使用泛型，而不是类的全部方法使用泛型，这时可以将泛型定义的范围缩小，通常我们可以定义进行泛型方法。

b、定义泛型方法

​ 语法：

  public  class 普通类{
      
      public   T  getValue(){
          
      }
      
      public  void setValue(T t){
          
      }  
      
  }

public class Convert {
    /**
     * 转成字符串的方法
     * @param  ： 任意类型

     * @return
     */
    public <T> String convertString(T t){
        return  t.toString();
    }

    public <K,V> V converted(K k){
        return (V)k;// 强转的前提 是k -v 有关系
    }

泛型的好处：

​ 1、 可以对类的数据类型 写通用类型，提高代码的复用性 和 可扩展性

2.4 泛型通配符

​ 在定义泛型时除了可使用大写字母表示一种泛型类以外，还可以使用通配符表示泛型类型，如下三种表示方法

:表示一种通用的泛型类，与相似 :表示 泛型类型是T的子类，或者是T : 表示泛型类型是T的父类，或者是T 问题： 与 的区别

  T t = new T() // 语法满足
  ? t = new ?()  // 语法不满足

​ 是一种确定的类型 ， 可以表示定义泛型类或泛型方法

是一种不确定的类型， 不能定义泛型类或泛型方法， 通常用于作为方法的形参

public class Dept<T> {
    // 第一个员工
     private T first;
     // 第二个员工
     private T second;

public class Employee {
    private String ename;

    public String getEname() {
        return ename;
    }

public class Manager extends  Employee {

    // 通过经理对象 给经理赋值名称
    public Manager(String ename){
        super(ename);
    }

// 使用不确定的泛型类型 

    /**
     *
     * 这里的部门的泛型可以是任意类型
     */
    public void showInfo(Dept<?> dept){

        System.out.println(dept.getFirst());

    }

    /**
     * @param dept 的泛型可以是Employee  或者继承自Employee
     * @param dept
     */
    public void showInfo2(Dept<? extends Employee> dept){

        System.out.println(dept.getFirst());
        System.out.println(dept.getSecond());

    }

    /**
     *
     * @param dept 的泛型必须是 Manager 或者 Manager的父类
     */
    public void showInfo3(Dept<? super Manager> dept){

        System.out.println(dept.getFirst());
        System.out.println(dept.getSecond());

    }

    public static void main(String[] args) {
         TestDept obj = new TestDept();

         //创建部门对象
        Dept<String> dept = new Dept();
        dept.setFirst("员工1");
        dept.setSecond("员工2");
         obj.showInfo(dept);

         // 在部门中添加 员工对象
        Dept<Employee> dept2 = new Dept();
        dept2.setFirst(new Employee("小强"));
        dept2.setSecond(new Employee("小花"));
        //这里的dept2的泛型是 Employee
        obj.showInfo2(dept2);

        Dept<Manager> dept3 = new Dept();
        dept3.setFirst(new Manager("张经理"));
        dept3.setSecond(new Manager("王经理"));
        //这里的dept3的泛型是  Manager
        obj.showInfo2(dept3);

        //  调用时 参数的泛型必须是 Manager 或Manager的父类
        obj.showInfo3(dept3);
        obj.showInfo3(dept2);
    }

二、集合框架

1、为什么会有集合？

存储多个元素我们以前学过数组类型， 由于数组类型特点是 相同类型且长度固定 ，如果需要存储某一天的新闻数据，用数组不合理 ，无法确定当天数量。 Java中提供可变长度的存储多个元素的数据类型，还可以存储不同数据结构的数据。这样的类型 就是“集合类型”

​ 数组和集合的区别？

​ a、数组的长度固定，集合的长度可自动扩容

​ b、数组的数据类型固定，集合可以存储任意类型 ，集合可以支持泛型

​ c、数组没有方法，而集合提供大量的方法

​ d、Java中提供一个动态数组 集合类型，或其他结合类型

2、集合的分布图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4k7pYXBR-1603451282376)(assets/1591347967566.png)]

2.1 集合的顶级接口： Collection

​ Collection属于单列集合的根接口，它扩展的主要子接口包括 java.util.List 和 java.util.Set接口，

List接口特点存储有序 且 可重复的元素， 而Set接口特点存储无序且不可重复的元素，其中List下扩展常用的实现类包括 java.util.ArrayList 和java.util.LinkedList 和Vector ， 其中Set接口下扩展的实现类包括 java.util.HashSet 和 java.util.TreeSet .

​ 集合接口的常用方法：

• public void add(E) : 把给定的元素添加到集合中

• public void clear():清空集合中的所有元素

• public boolean remove(E):删除集合中指定的元素，删除成功返回true

• public boolean contains(E):判断该元素是否存在集合中

• public boolean isEmpty():判断是否为空集合对象 null会报异常

• public int size():获取几个元素的大小

• publict Object toArray() : 将集合元素转成对象数组

    public static void main(String[] args) {
           //通过接口创建实现类 ， 可指定存储的泛型
  
          Collection<String> collection = new ArrayList<String>();
          // 集合中指定了元素的类型  String
          collection.add("hello");  // 默认添加到末尾
          collection.add("hi");
          collection.add("哈哈");
          System.out.println("元素大小："+ collection.size());
          // 删除集合元素  （后面的原始往前 移动）
          collection.remove("hi");
          System.out.println("元素大小："+collection.size());
          System.out.println("第一个元素："+((ArrayList<String>) collection).get(0));
          System.out.println("第二个元素："+((ArrayList<String>) collection).get(1));
  
          // 判断元素是否存在
          System.out.println("是否存在哈哈："+collection.contains("哈哈"));
          // 转成数组对象
          Object [] objs = collection.toArray();
          //遍历元素
          for(Object obj : objs){
              System.out.println("数组的元素："+obj);
          }
          //清空元素  clear
          collection.clear();
          // 大小
          System.out.println("清空后元素的大小（对象依然存在，只能内容为空）"
                  +collection.size());
          // 判断对象中是否是空集合
          System.out.println(collection.isEmpty());
  
        
      }

Iterator 集合遍历接口

    // 直接对集合元素遍历   泛型只能是包装类
          Collection<Integer> scores = new ArrayList<>();
          scores.add(90);
          scores.add(88);
          scores.add(92);
          scores.add(91);
          //遍历集合  使用   ，
          // 再遍历集合时 不能一边遍历集合一边删除集合元素，这样会改变它的遍历的模式
          Iterator<Integer> is = scores.iterator();
          //判断是否有下一个元素   ，如果true ，则可以通过next获取值 
           while(is.hasNext()){
               Integer score = is.next();
               System.out.println(score);
           }
  

• 2.2 ArrayList类

  ​ java.util.ArrayList是一个数组结构的集合，实现动态数组的功能，扩展所有Collection的方法

  数组结构的本质： 线性结构的顺序结构，ArrayList中使用连续的内存空间存储， 访问时通过下标（元素所在的位置）访问

2.2 ArrayList类：

​ java.util.ArrayList是一个数组结构的集合，实现动态数组的功能，扩展所有Collection的方法

数组结构的本质： 线性结构的顺序结构，ArrayList中使用连续的内存空间存储， 访问时通过下标（元素所在的位置）访问

ArrayList的数据结构

分析一个类的时候，数据结构往往是它的灵魂所在，理解底层的数据结构其实就理解了该类的实现思路，具体的实现细节再具体分析。

ArrayList的数据结构是：

说明：底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。我们对ArrayList类的实例的所有的操作底层都是基于数组的。

​ 源码分析参考：https://www.cnblogs.com/zhangyinhua/p/7687377.html#_lab2_0_1

public static void main(String[] args) {
         //  通过ArrayList 创建集合对象
        // 还可以存储自定义对象  默认容量是 10
        ArrayList<String> list = new ArrayList<String>();
        // 存储有序集合
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        // 将元素插入到指定位置
        list.add(1,"ddd");
        //直接 遍历元素  get（Index） 通过下标访问元素
        for(int i = 0 ;i<list.size();i++){
            System.out.println("集合元素："+ list.get(i));
        }
        // 设置集合的最小容量
        list.ensureCapacity(20);



    }