Collection，泛型

今日内容：【Collection，泛型】

collection集合

迭代器

增强for循环

泛型

学习目标

能够说出集合和数组的区别

能够使用并说出Collection集合的常用功能

能够使用迭代器对集合进行取元素

能够说出集合的使用细节

能够使用存储自定义的类型

能够使用foreach循环遍历集合

能够使用泛型定义集合对象

能够理解泛型集合对象

能够理解泛型的上下限

能够阐述泛型通配符的作用

Collection集合

集合概述

前面我们已经学习过ArrayList集合了，那么集合它到底是一个什么呢？

集合：集合是java中提供的一种容器，可以用来存储多个数据。

集合和数组既然都是容器，他们有啥区别？

数组的长度是固定的，集合的长度是可变的

数组中存储的是同一种数据类型的元素，可以存储基本数据类型也可以存储引用数据类型

集合存储的都是对象，而且对象的数据类型可以不一致。在开发当中一般当对象较多的时候，使用集合来存储对象

集合的框架

JAVASE提供了满足各种需求的API，我们在使用API的时候，先了解其继承与接口操作的框架，才能知道何时使用哪个类，以及类与类之间是如何彼此合作的，从而达到灵活的应用。

集合根据其存储结构把它分为两大类：分别是单列集合java.util.collection和双列集合java.util.Map,今天

我们主要讲单列集合Collection集合

集合：LIst《Vector ArrayList LInkedList》 Set接口：《TreeSet HashSet LinkedHashSet》

继承：子类供型抽取，形成父类(父接口)

LIst接口

1.有序的集合（存储和取出元素的顺序相同）

2.允许存储重复性的元素

3.有索引，可以普通的for循环遍历

Set接口

1.不允许存储重复性的元素

2.没有索引（不能使用普通的for循环）

3.无序集合HashSet集合 有序集合LInkedHashSet集合

Collection接口：

1.定义的是所有的单列集合中共性的API方法，所有的单列集合都可以使用共性的方法

2.没有带索引的方法

List和Set是Colllection接口

学习集合的目标

1.会使用集合存储数据

2.能够遍历集合，把元素从集合当中取出

3.掌握每种集合的独自特性。

集合框架体系的学习方法：

1.学习集合框架的顶层：掌握接口或者抽象类当中的共性的方法，所有的子类都可以使用。

2.使用底层的集合框架：顶层不是接口就是抽象类，需要使用地城的子类创建对象来使用集合

Collection：它是单列集合的根接口，用于粗出一些列符合某种规则的元素，他有两种重要的子接口，分别是java.util.List和jaa.util.Set.其中，List接口集合特点运输元素有序，元素可重复，含有索引。Set接口集合特点元素布重复，没有索引。List接口的主要实现类有ARrayList和LInkedList，Set接口的主要实现类有：java.util.HashSet和java.util.TreeSet

备注：绿色是底层实现类，蓝色都是接口类型

Collection集合常用功能

Collection集合是所有单列集合的父接口，在Collection集合当中敌营所有单列集合的共性的API方法，这些方法适用于所有的单列集合，增删改查功能 crud操作

public boolean add(E e):把给定的对象添加到当前的集合当中

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

public boolean remove(E e):把给定的对象从当前集合当中删除掉。

public boolean contains(E e):判断当前集合当中是否包含给定的对象元素

public boolean isEmpty():判断当前集合是否为空。null 空

public int size():获取当前集合元素的个数 capacity() lenth()

public Object[] toArray():把当前集合中的元素，存储到一个数组当中。

代码测试：

有关该接口当中的其他api方法，大家可以自行查看api帮助文档

迭代器Iterator接口

迭代器Iterator接口

在程序开发过程中，经常需要遍历集合当中的所有元素，针对这种情况，JDK官方又提供了一个接口java.util.Iterator。iterato接口它也是集合当中的一员，但是它与Map Collection接口不同，Collection接口和Map接口它主要是用于存储元素的，而iterato主要用于迭代访问Collection与Map接口当中的元素。因此我们也经常把iterator对象成为迭代器

想要遍历Collection集合当中的元素，首先需要获取该集合的迭代器，通过迭代器完成迭代 操作

获取迭代器的方法：

public Interator interator():获取集合对应的迭代器，用于遍历结合当中的元素。

迭代的概念

迭代：Collection集合元素的通用获取方式。具体实现：在每次取元素之前首先判断集合当中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就在一次取出来，一直把集合当中的所有元素全部取出来。我们把这种取出方式在专业术语称为迭代。

Iterator接口的常用api方法：

public E next():获取迭代的下一个元素

public boolean hasNext():如果集合当中扔有元素可以迭代，则返回true,如果没有元素，则返回false

迭代器步骤

//创建一个集合对象
		Collection<String> coll=new ArrayList<>();
		coll.add("美国");
		coll.add("英国");
		coll.add("法国");
		coll.add("中国");
		coll.add("日本");
//使用while循环
//三步：1.获取迭代器 2.判断是否有下一个元素  3.取出元素
Iterator<String> iterator =coll.iterator();
		while(iterator.hasNext()) {//判断集合当中是否有下一个元素
			String str=iterator.next();//做了两两件事：1.取出元素 2.会把指针向后移动一位
			System.out.println(str);
		}

迭代器的实现原理

在调用Iterator接口当中的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当前第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素边境该元素返回。当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，此类推，直到hasNext方法返回false时，表示迭代器达到了集合的末尾，终止对元素的遍历。如果强硬的再取集合的元素，此时程序就会抛出没有元素 java.util.NoSuchElementException

备注：Iterator<E>接口也有泛型的，迭代器的泛型是跟着集合走的，集合当中定义的什么类型，迭代器就是什么类型。

增强for循环

在JDK1.5之后出现了一个新的循环结构，foreach循环，一般也称为增强for循环，专门用来遍历数组和集合的。它的内部原理其实是有有个迭代器Iterator，在迭代器过程中，不能对集合当中的元素进行增删操作。

格式：

for(元素的数据类型 变量名：Collection集合或者数组){
    //操作代码
    //。。。。
}

主要用于遍历Collection集合或者数组。在遍历的过程中，一定不要进行增删操作

练习1：遍历数组

int[] arr={3,5,7,9,12};
for(int i:arr){
    System.out.println(i);
}

练习二：遍历集合

//Collection coll=new ArrayList<>();
Collection<String> colls=new ArrayList<>();
		colls.add("姚明");
		colls.add("科比");
		colls.add("马保国");
		colls.add("特朗姆");
		
		for (String i : colls) {
			System.out.println(i);
		}

备注：目标只能是Collection集合或者数组，增强for循环仅仅是作为遍历数组操作出现，简化迭代器的操作。

泛型：是一种未知的数据类型，当我们不知道用什么样的数据类型的时候，可以使用泛型。泛型我们可以把特看做是一个变量，用来接收数据类型

E e:Element元素

T t:Type 类型

ArryList在定义集合的时候，不知道在集合当中存储什么样的数据类型，所以类型使用泛型

E：未知的数据类型

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

创建集合对象的时候，就一定会确定泛型的数据类型

ArryList<String> list=new ArryList<E>();
public class ArraryList<String:泛型>{
    //泛型String 是Arry数组里面的String传进来的
    public boolean add(String e){}
    public String get(int index){}
}

泛型

泛型：可以在类或者方法当中预支的使用未知的数据类型

备注：一般在创建对象的时候，将未知的数据类型确定为具体的数据类型，当没有指定泛型时，默认类型为OBject类型

使用泛型的好处与坏处

好处：1.避免了类型转换的麻烦，存储的是什么样的数据类型，取出的就是什么样的数据类型 2.把运行期异常(代码运行后会抛出异常)提升到编译期阶段(写代码的时候就会报错）

弊端：泛型时是什么样的类型，只能存储什么样的数据

备注：泛型它其实是数据类型的一部分，一般我们将类名和泛型合并一起看做数据类型。

泛型的定义使用

泛型，用来灵活的将数据类型应用到不同的类，方法，接口当中。将数据类型作为参数进行传递

因为我们的集合框架体系中，大量的使用了泛型

定义和使用含有泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量>{
    
}

例如：

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

备注：定义的时候使用未知的泛型的变量，使用的时候（创建对象）确定的泛型的具体类型

定义并使用含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型  方法名 (参数列表){}

例如：

public class GenericMethod{
    //定义带有泛型的方法
    public <E> void show(E e){
        System.out.println(e);
          
    }
    //定义一个含有泛型的返回值
    public <E> E show2(E e){
        //......
        return e;
    }
    //定义测试类
    public class Test{
        public static vois main(String[] args){
            //创建对象
            CenericMethod gm=new GenericMethod();
            //调用带有泛型的方法
            gm.show("abc");//参数
            gm.show(123);
            gm.show(3.14);
        }
    }
}

定义并使用含有泛型的接口

定义格式：

修饰符 interface 接口名<代表泛型的变量>{}

例如：

public interface Collecttion<E>{
    public void add(E e);
    public Iterator<E> iterator();
}
//自定义一个泛型的接口
public interface MyGenericInterface<T>{
    public abstract void add(E e);
    public abstract E get();
    //...
}

使用格式：

1.定义实现类时可以确定泛型的类型

public class MyInterfaceImpl implements MyGenericInterface<String>{
    //重写
    public void ad(String e){
        
    }
    //重写
    public String get(){
        //...
    }
}

备注：此时泛型【T的值】就是String类型

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

例如：

public class MyInterfaceImpl<T> implements MyInterfaceImpl<T>{
    //重写
    public void add(T t){
      //....  
    }
    //重写
    public T get(){
     //.....   
    }
    
}

确定泛型

/*
使用泛型
*/
public class DemoGeneric{
       public static vois main(String[] args){
           MyInterface<String> my =new MyInterfaceImpl<String>();
           my.add("abc");
       }
    
}

泛型通配符（？）

通配符的高级使用--受限泛型（泛型的上限和下限）

思想题：泛型它其实也是一种数据类型 它能不能继承？ 不能继承

数据类型是有继承关系 能不能在泛型当中实现继承，不能的

Integer extends Number extends Object

List<Integer> extends List<Number> 不可以

List<Double> extends List<Number> 不可以