今日内容

• Collection集合
• 迭代器
• 泛型
• 数据结构

Collection集合[重点]

集合的介绍,集合和数组的区别

• 集合是数据的容器
• 数组:
  数据类型[] 变量名 = new 数据类型[数组的长度]
  集合:
  ArrayList<数据类型> 变量名 = new ArrayList<数据类型>
• 区别
  1.数组的长度是固定的,集合的长度是可以改变的
  2.数组中的元素类型可以是基本类型或引用类型. 集合的元素类型必须是引用类型或包装类

集合常用类的继承体系[重要]

• 两类集合接口特点
  List 的特点是元素有索引,有序,元素可重复
  Set 的特点是无索引,无序,元素不可重复。

  
  
  

Collection 中的通用方法

• 增

public    boolean    add(E e);  添加元素,返回值表示添加成功

• 删

public    boolean    remove(E e);  删除元素, 返回值表示是否删除成功

• 改(无)

 因为List接口有索引和Set接口无索引. 所以根接口无改方法

• 查(无)

根接口中没有

• 其他

public   boolean  contais(object  obj);判断集合中是否包含某个元素

public  void  clear(); 清空集合(把集合中元素全部删除, 不是把集合置为null)

public  boolean isEmpty();判断集合是否为空

public  int size();返回集合中的元素个数

public  Object[]  toArray();将集合转为数组

Iterator迭代器[重点]

集合迭代器的介绍和使用

(因为set接口的实现类集合无索引, 没有办法使用fori来遍历)

• 迭代器: 用来遍历集合的对象(遍历集合不需要索引),就是Iterator
• 迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续再判断，如果还有就再取出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
• 使用步骤:
  1.创建Iterator对象(使用集合对象.iterator()的方法, 这个方法写在Collection中返回一个迭代器对象)
  2.使用调用对象.hasNext()方法(是否有元素, 有返回true)
  3.使用调用对象.next()方法

     Iterator<String> it = coll.iterator();
        //  泛型指的是 迭代出 元素的数据类型
     while(it.hasNext()){ //判断是否有迭代元素
            String s = it.next();//获取迭代出的元素
            System.out.println(s);
        }

• 迭代器的注意事项(两个异常)
  1.NoSuchElementException; 没有元素异常
  出现原因:没有元素了,还是用迭代器的next()方法, 就会出现异常
  2.ConcurrentModificationException; 并发修改异常
  出现原因: Java迭代器规定, 在使用迭代器过程中,无法使用增删元素(无法更改集合长度)
  但是可以使用迭代器本身的 remove方法是可以删除的(迭代器本身没有增加方法)

注意:
1.使用迭代器时,必须先使用hasNext方法判断,且结果为true,才能调用next方法
2.使用迭代器时,尽量只做遍历,不允许在使用过程中,用了增加或删除元素的操作
3.迭代器遍历一次之后,就结束了,再使用的时候需要重新使用 list.iterator() 获取新的迭代器

迭代器原理

迭代器底层使用了"指针原理"

增强for循环[重点]

• 什么是增强for循环
  实际上是一种简便格式(语法糖).内部原理是迭代器的简便格式

• 使用方法

for(数据类型  变量名:集合/数组){
    System.out.println(变量名);
}//遍历一次集合/数组, 取出一个元素赋值给变量名;

• 注意事项:
  1.增强for循环必须有被遍历的目标，目标只能是Collection或者是数组；
  2.增强for（迭代器）仅仅作为遍历操作出现，不能对集合进行增删元素操作，否则抛出ConcurrentModificationException并发修改异常

泛型

概述

• 是jdk1.5之后的新特性
• 什么是泛型:
  是一种不确定的类型,程序员使用时再确定下来
• 泛型的格式
  <E>
  <K,V>

使用泛型的好处

• 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
• 避免了类型强转的麻烦。

泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型。

如何定义和使用泛型[理解]

泛型可以定义在类上,方法上,接口上
泛型在定义的时候不具体，使用的时候才变得具体。在使用的时候确定泛型的具体数据类型。

定义不具体,使用的时候具体

• 泛型类(泛型定义在类上)
  在创建对象的时候确定类型

泛型类的定义

class ArrayList<E>{ 
    public boolean add(E e){ }
    public E get(int index){ }
    ....
}

泛型类的使用

ArrayList<String> list = new ArrayList<String>();

• 泛型方法(泛型定义在方法上)

泛型方法的定义

public <MVP> void show(MVP mvp) {
        System.out.println(mvp.getClass());
    }

泛型方法的使用

public class Dog{
    public <E> void show(E num){
        System.out.println(num);
  }
}
public class TestDog{
  public static void main(){
    Dog dd= new Dog();
    dd.show("Java");
    dd.show(10);
    dd.show(10.33);  
  }  
}

• 泛型接口(定义在接口上)
  1.在实现类中实现该接口时,确定具体类型
  2.在实现类中实现该接口时,保留泛型相当于继承父类泛型

泛型接口的定义

public interface MyGenericInterface<E>{
    public abstract void add(E e);
    
    public abstract E getE();  
}

泛型接口的使用

1.定义类时确定泛型的类型

public class MyImp1 implements MyGenericInterface<String> {
    @Override
    public void add(String e) {
        // 省略...
    }
 
    @Override
    public String getE() {
        return null;
    }
}

2.始终不确定泛型的类型，直到创建对象时，确定泛型的类型

定义泛型
public class MyImp2<E> implements MyGenericInterface<E> {
    @Override
    public void add(E e) {
         // 省略...
    }
 
    @Override
    public E getE() {
        return null;
    }
}
确定泛型：
/*
 * 使用
 */
public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

小结：泛型是一种未知的数据类型，定义在类上的泛型，使用类的时候会确定泛型的类型，定义在方法上的泛型，会在使用方法的时候确定泛型，定义在接口上的泛型，需要使用接口的时候确定泛型。

泛型的通配符

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

 void method(ArrayList<?> arr){
//表示任何引用类型的集合都可以作为形参传递
}

泛型的上下限[重点]

• <?> 什么泛型都可以
• <? extent Animal>,是泛型的上限,表示该泛型必须是Animal本类或其子类
• <? super Student>,叫做泛型的下限, 表示该泛型必须是Student本类或者其父类

数据结构

介绍

是容器保存数据的方式(数据用什么样的方式组合在一起)

常见的数据结构[重点]

栈结构

• 介绍
  又称堆栈，它是运算受限的线性表

• 理解
  栈结构可以看做只有一端开口的容器
  1.压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。
  2.弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。

• 特点:
  1.先进后出
  2.栈的入口、出口的都是栈的顶端位置。

队列结构

• 介绍
  简称队，它同堆栈一样，也是一种运算受限的线性表

• 理解
  队列结构可以看做是 两端都有开口的容器(一端进一端出)

• 特点
  1.先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，小火车过山洞，车头先进去，车尾后进去；车头先出来，车尾后出来。
  2.队列的入口、出口各占一侧。

数组结构

• 介绍
  数组:Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。
• 特点:
  1.查找元素快：通过索引，可以快速访问指定位置的元素
  2.增删元素慢

链表结构

• 介绍
  在链表结构中,每一个元素成为节/结点(Node)
  每个节点至少有两部分内容,一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

• 特点
  链表结构在内存中可以是分散的
  1.多个结点之间，通过地址进行连接。
  2.查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素。
  3.增删元素快：

  
  

树结构

红黑树查询效率很高

今日总结

1.Collection 集合根接口【重点】
    i.集合继承体系
    ii. Collection中定义的通用方法
    iii.明白集合和数组的区别
    
2.迭代器【重点】
    i.迭代器使用的三个步骤: 获取迭代器,判断有没有下一个,取出下一个元素
    ii.增强for循环使用(底层使用就是迭代器)   
    iii.迭代器和增强for使用过程 不能增删元素   
        
3.泛型【理解】
    i.泛型怎么写 <E>
    ii.泛型类,泛型接口,泛型方法怎么定义和使用
    iii.泛型通配符以及上下限【重点】
        <?> 代表任意泛型均可
        <? extends 类名> 上限
        <? super 类名> 下限
4.数据结构【重点】
    栈结构: 先进后出
    队列结构: 先进先出
    数组结构: 增删慢,查询快
    链表结构: 增删快,查询慢
    红黑树: 查询效率非常恐怖!!  【记住结论即可】