泛型续，数据结构，List集合

泛型续：

    泛型的通配符：

           目标：了解泛型的通配符 ，表达泛型通配符的作用

                  当使用泛型类或者泛型接口，传递的数据中，泛型的类型不确定，可以通过通配符<?>表示。一旦程序当中使用泛             型通配符后，只能使用Object类的共性方法。集合当中元素自身方法无法使用。

           通配符的基本使用：

                   不知道使用什么类型来接收的时候，可以使用？，？代表未知的通配符。 此时只能接收数据，不能往该集合当中存储数据。

          

public static void main(String[]  args){

   //k可以存储整数的集合，
/*
 
    泛型的通配符：
        ?: 代表任意的数据类型
    使用方式：
        不能创建对象使用
        只能作为方法的参数使用
        如果使用泛型作为参数传递时，不写，系统默认添加?
        添加？之后，系统会集合当中的元素解析成Object类型
        如果显示的定义Object类型，程序是无法接收其他的数据类型，只能接收Object类型
        泛型没有继承概念。
*/

   Collection<Integer>  list01 = new ArrayList<Integer>();
   //此时list01可以存储整数的数据
   //展示list01集合当中的数据
     getElement(list01);
   //可以存储String字符串的集合
    Collection<String>  list02 = new ArrayList<String>();
   //此时list02可以存储字符串的数据
    getElement(list02)//Collection<Object>  不可以 
   //此时如果换成泛型通配符？，就可以接收
     getElement2(list02);//可以
     getElement2(list01);//可以
 

}
public static void getElement(Collection<Integer> coll){
 //只能接收Integer类型的数据

 }

public static void getElement2(Collection<?> coll){
 
         //遍历coll集合
        Iterator iterator=coll.iterator();
        while(iterator.hasNext())
        {
            Object next = iterator.next();
            System.out.println(next);
        }


}

 备注：泛型不存在继承关系Collection<Object> list=new ArrayList<String>();这是一种错误的此写法。

    泛型的上下限：通配符的高级用法（受限泛型）

               目标：能够理解泛型的上下限

             之前设置泛型的时候，实际是可以任意设置的，但是在Java的泛型当中还可以指定一个泛型的上限和下限

           泛型的上限： 

               格式：类型名称<? extends 类名>对象名称

               意义：只能接收该类型及子类

           泛型的下限：

               格式：类型名称<?  super  类名>对象名

                意义：只能接收该类类型及其父类类型

          比如说：已知的顶级父类Object,String, Number,Integer,其中Number是Integer的父类

public static void main(String[] args){
/*
       泛型的上限限定： ? extends E  代表使用的泛型只能是E类型或者E类型的子类
       泛型的下限限定： ? super E    代表使用的泛型只能是E类型或者E类型的父类类型
 */

    //初始化四个集合
    Collection<Integer> list01=new ArrayList<>();
    Collection<String> list02=new ArrayList<>();
    Collection<Number> list03=new ArrayList<>();
    Collection<Object> list04=new ArrayList<>();
        get(list01);
        get(list02);
        get(list03);
        get(list04);
        get1(list01);//Integer
       // get1(list02);//String不能接收
        get1(list03);//Number
        //get1(list04);//Object不能接收
        //get2(list01);//Integer不能接收
        //get2(list02);//String不能接收
        get2(list03);//Number
        get2(list04);//Object

}

//定义方法  此时可以接收任意数据类型
public static void get(Collection<?> coll){
  
  //.....
}
//定义方法  此时只可以接收数字类型    Number类型或者Number的子类
public static void get1(Collection<? extends Number> coll){
  
  //.....
}
//定义方法  此时只可以接收Number类型及其以上的类型
public static void get2(Collection<? super Number> coll){
  
  //.....
}

数据结构：

     目标：

           能够说出常见的数据结构

           能够说出队列的结构特点

           能够说出单向链表结构的特点

 常见的数据结构：

        数据存储的常用结构：栈，队列，数组，链表，红黑树

    栈：

        stack,又称堆栈，是运算受限的线性表结构。仅允许在标的的一端进行插入和删除操作，不允许在其他位置进行添加。查找，删除操作。简单地说，采用该结构的集合，对元素的存取有以下特点：

•       先进后出（存进去的元素，要在他后面的元素依次取出后，才能取出该元素）。例如：子弹压进弹夹和子弹从弹夹弹出的的动作
•       栈的入口，出口都是栈的顶端位置。
•       空栈：栈顶=栈底
•       压栈：就是存储元素，把元素存储到栈的顶端位置，栈中已有的元素依次向栈底方向移动一个位置
•       弹栈：就是取出元素，把栈的顶端位置元素取出，栈中已有的元素依次向栈顶方向移动一个位置。
• 

  队列：

       queue,简称队，它与堆栈几乎是一样的，也是一种运算受限的线性表结构，它的限制是仅允许在标的的一端进行插入，在标的的另一端进行删除。简单地说，采用该结构的集合，对元素的存取有以下特点：

•     先进先出(存进去的元素，要在它前面的元素依次取出后，才能取出该元素)。例如：火车过山洞，火车头先进先出。车尾后进后出。
•     队列的入口，出口各占一侧。
• 

  数组：

         Array,是有序的元素序列，在内存中开辟的是一段连续的空间，并在此空间内存储元素，例如：酒店的房间号是连续的。简单地说，采用此结构的集合，对元素的存取有以下特点:

•  查找元素快：通过索引，可以快速的访问到指定位置的元素。
•  增删元素慢：

         1.指定索引位置添加元素，需要创建一个新数组，将指定的新元素存储到指定的索引位置，再把源数组元素根据它原来的索引，复制到新数组对应的索引位置。

         2.指定索引位置删除元素：需要创建一个新数组，把源数组当中的元素根据索引，复制到新数组对应的索引位置，源数组中指定的索引位置元素不复制到新数组当中。

链表结构：

       linked list:有一系列结点node（链表当中的每个元素称为结点）组成，节点可以在运行时动态生成。每个结点中包含两个部分：一个是用来存储数据元素的数据域，另一个是用来存储下一个结点地址的指针域，我们常说链表结构有单向链表和双向链表。

       简单地说，采用此结构的集合，对元素的存取有以下特点：

• 多个结点之间，通过地址进行链接。比如：多个人玩丢手绢，每个人右手拉住下一个人的左手，上一个人的左手拉住该人的右手。依次类推，多个人就被连接起来。

• 查找元素比较慢：想要查找某个元素，需要通过连接的结点，依次向后查询指定的元素。

• 删除元素比较快：

  1. 增加一个元素：只需要修改连接下个元素的地址即可。

  2. 删除一个元素：只需要修改连接下一个元素的地址即可。

• 

红黑树：

   二叉树：binary tree ,每个节点数不超过2的树（tree）

   简单的理解：就是类似于我们生活中的树的结构，只不过每个节点上都最多只能有两个子节点。

   顶上的节点称为根节点，两边的被称为“左子树”和“右子树”

   在二叉树中有一种比较特殊树结构叫做红黑树，红黑树本身就是一个二叉树

   红黑树的约束：

1. 节点可以是红色的也可以是黑色的
2. 根节点是黑色的
3. 叶子节点（空节点）是黑色的
4. 每个红色节点的子节点都是黑色的
5. 任何一个节点到其每一个叶子节点的所有的路径上的黑色节点数目相同的

查询速度非常快，趋近于平衡树，查找叶子元素最小和最大不能超过2倍。

List集合：

     目标：能够说出List集合的特点

      介绍：java.util.List接口继承自Collection接口，是单列集合的一个重要分支，在List集合当中允许出现重复的元素，所有的元素都是以一种线性方式进行存储的，在List集合当中基本我们可以通过索引来访问集合当中的元素，另外List集合还有一个特点就是元素是有序的，指的是存取元素顺序相同。

 List接口当中的常用API方法：

      除了继承Collection接口当中的方法外，还增加了一些根据元素索引来操作集合的特定方法：

•   public void add(int index ,E element):将指定的元素，添加到给定的集合中的指定位置上
•   public E get (int index):根据指定的索引获取对应位置上的元素
•   public E remove(int index):通过索引删除索引对应位置上的元素
•   public E set(int index ,E element)：在指定的索引位置上替换成给定的元素，并返回更新前的元素。

List集合的子类

   ArrayList集合：

        有索引，有序，元素可重复，长度可变的数组，可以存储null 元素，元素增删慢，查询快

 LinkedList集合：

        java.util.LinkedList集合数据存储的结构采用的是链表结构，方便元素的添加和删除操作。

        是一个双向链表，增删快，查询慢。在LinkedList集合当中，封装了大量的关于首节点和尾节点的元素操作的方法。

方法如下：

public void addFirst(E e):将指定元素插入到首节点位置

public void addLast(E e):将指定的元素插入到尾节点的位置上

public  E getFirst():获取首节点的元素

public  E getLast():获取尾节点的元素
public  E removeFirst（）:删除首节点元素

public  E removeLast():删除尾节点元素

public  E pop():从次列表所表示的堆栈中弹出一个元素

public void push(E e):将元素推入到此列表所表示的堆栈当中

public boolean isEmpty():如果此列表为空返回true.