Collection

1.1集合概述 ————————————————————————————————————————

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

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

• 数组的长度是固定的。集合的长度是可变的。
• 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象，而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

1.2 集合框架 ———————————————————————————————————————— JAVASE提供了满足各种需求的API,在使用这些API之前，先了解其继承与接口操作的架构，才能了解何时采用哪个类，以及类之间如何彼此合作，从而达到灵活应用。

集合按照其存储结构可以分为两大类，分别是单列集合 java.util. Collection和双列集合java.util.Map。

Collection: 单列集合类的接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。其中，List的特点是元素有序，元素可以重复。Set的特点是元素无序，而且不可重复。List接口的实现类有java.util.ArrayList和java.Util.LinkedList,Set接口的实现类有java.util.HashSet和java.util.TreeSet。

集合本身是一个工具，它存放在java.util包中。在Collection接口定义着单列集合框架中最共性的内容。

1.3 Collection常用功能 ———————————————————————————————————————— Collection是所有单列集合的父接口，因此在Collection接口中定义着单列集合（List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：

• public boolean add(E e):把给定的对象添加到当前集合中。
• public void clear():清空集合中所有的元素
• public boolean remove(E e):把给定的对象在当前集合中删除
• public boolean contains(E e):判断当前集合中是否包含给定的对象
• public boolean isEmpty():判断当前集合是否为空
• public int size():返回集合中元素的个数
• public Object[] toArray()：把集合中的元素，存储到数组中。

public class Demo1Collection {
    public static void main(String[] args) {
        //创建集合对象
        //使用多态形式
        Collection<String> coll = new ArrayList<>();
        //使用方法

        //添加
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        System.out.println(coll);

        //Object[] toArray()转换成一个数组
        Object[] objects = coll.toArray();
        //遍历数组
        for (Object obj : objects) {
            System.out.println(obj);
        }

    }
}

Iterator迭代器

2.1Iterator接口

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口 java.util.Iterator。Iterator接口也是java集合中的一员，但她与Collection,Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。

想要遍历Collection集合，那么就要获取该集合对应的迭代器，下面介绍一下获取迭代器的方法：

• public Iterator iterator():获取集合对应的迭代器，用来遍历集合中的元素的

下面介绍一下迭代的概念：

• 迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

Iterator接口的常用方法如下：

• public E next():返回迭代的下一个元素。
• public boolean hasNext():如果仍有元素可以迭代，则返回true。

接下来我们通过案例学习如何使用Iterator迭代集合中元素：

public class IteratorDemo {
    public static void main(String[] args) {
        //使用多态方式，创建对象
        Collection<String> coll = new ArrayList<String>();

        //添加元素到集合
        coll.add("串串星人");
        coll.add("吐槽星人");
        coll.add("汪星人");

        //遍历
        //使用迭代器 遍历 每个集合对象都有自己的迭代器
        Iterator<String> it = coll.iterator();
        //泛型指的是迭代出元素的数据类型
        
        while (it.hasNext()) {//判断是否有迭代元素
            String s = it.next();
            System.out.println(s);
            
        }
    }
}

注意：在进行集合元素取出的时候，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。

2.2 迭代器的实现原理

我们在之前案例已经完成了Iterator遍历集合的整个过程。当遍历集合的时候，首先通过调用t集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已经到达了集合末尾，停止遍历元素。

Iterator迭代器对象在遍历集合的时候，内部采用指针的方式来跟踪集合中的元素。在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法之后迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法的时候，迭代器的索引会指向第二个元素并将该元素返回，以此类推，直到hasNext方法返回false，表示达到了集合的末尾，终止对元素的遍历。

2.3 增强for

增强for循环（也称foreach循环）是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部实现原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

格式：

for(元素的数据类型 变量：Collection集合or数组）{
//写操作代码
}

它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

练习1：遍历数组

 public static void main(String[] args) {
        int[] arr = {3, 5, 6, 7};

        //使用增强型for遍历数组
        for (int a : arr) {
            //a代表数组中的每一个元素
            System.out.println(a);
        }
    }

练习2：遍历集合

 public void forCol() {
        Collection<String> coll = new ArrayList<String>();
        coll.add("小河神");
        coll.add("老河神");
        coll.add("神婆");
        
        //使用增强for遍历
        for (String s : coll) {
            //接收变量s代表，代表被遍历到的集合元素
            System.out.println(s);
        }
    }

注意：新的for循环必须有被遍历的目标。目标只能是Collection或者数组。新式for仅仅作为遍历操作出现。

泛型

3.1 泛型概述

在前面的学习集合中，我们都已经知道集合中是可以存放任意对象的，只要把对象存储在集合后，那么这时它们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

大家观察下面的代码：

public class GenericDemo {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add("abc");
        coll.add("itcast");
        coll.add(5);//由于集合没有做任何的限定，任何类型都可以在其中存放

        Iterator it = coll.iterator();
        while (it.hasNext()) {
            //需要打印每个字符串的长度，就要把迭代出来的对象转换成String类型
            String str = (String) it.next();
            System.out.println(str.length());
        }
    }
}

程序在运行时发生了问题java.lang.ClassCastException。为什么会发生类型转换异常呢？我们来分析一下：由于集合中什么类型的元素都可以存储。导致取出的时候强转引发运行时ClassCastException。怎么来解决这个问题呢？Collection虽然可以存储各种对象，但实际上通常Collection只存储一类型对象。例如都是存储字符串类型的对象。因此在JDK5之后，新增了泛型（Generic)语法，让你在设计API时可以指定类或者方法支持泛型，这样我们使用API的时候也变得更为简洁，并得到编译时期的语法检查。

• 泛型：可以在类或者方法中预支的使用未知的类型。 注意：一般在创建对象的时候，将未知的类型确定具体的类型。当没有指定泛型的时候，默认类型为Object类型。

3.2 使用泛型的好处

上一节只是讲解了泛型的引入，那么泛型带来了哪些好处呢？

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

public class GenericDemo2 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("abc");
        list.add("itcast");
//        list.add(2);//当集合的类型明确后，存放类型不一样就会编译报错
        //集合已经明确具体的存放的元素类型，那么使用迭代器的时候，迭代器也同样会知道具体遍历元素的类型

        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String str = it.next();
            //当使用Iterator<String>控制元素类型之后，就不需要强转了。获取的元素直接就是String类型
            System.out.println(str.length());
            
        }
    }
}

注意：泛型是数据类型的一部分，我们将类名与泛型合并一起看作数据类型

3.3 泛型的定义与使用

我们在集合中中会大量使用泛型，这里来完整的学习泛型知识。

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

定义和使用含有泛型的类

定义格式： 修饰符 class类名<代表泛型的变量>{}

例如，API中的ArrayList集合：

class ArrayList<E>{
public boolean add(E e){}

public E get(int index){}

....
}

使用泛型：即什么时候确定泛型

在创建对象的时候确定泛型

例如，ArrayList list=new ArrayList(); 此时，变量E的类型就是String类型，那么我们类型就可以理解为：

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

再例如，ArrayList list=new ArrayList(); 此时，变量E的值就是Integer类型，那么我们的类型就可以理解为：

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

举例自定义泛型类

 public class MyGenericClass<MVP> {
    //没有MVP类型，在这里代表未知的一种数据类型，未来传递什么就是什么类型
    private MVP mvp;

    public MVP getMvp() {
        return mvp;
    }

    public void setMvp(MVP mvp) {
        this.mvp = mvp;
    }
}

使用：

  public class GenericClassDemo {
    public static void main(String[] args) {
        //创建一个泛型为String的类
        MyGenericClass<String> my = new MyGenericClass<>();
        my.setMvp("三分神射手");
        String mvp = my.getMvp();
        System.out.println(mvp);
        //创建一个泛型为Integer的类
        MyGenericClass<Integer> my2 = new MyGenericClass<>();
        my2.setMvp(123);
        System.out.println(my2.getMvp());
    }
}

含有泛型的方法

定义格式： 修饰符<代表泛型的变量>返回值类型 方法名（参数）{}

例如：

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

    }

    public <MVP> MVP show2(MVP mvp) {
        return mvp;
    }
}

使用格式：调用方法，确定泛型的类型

public class GenericMethodDemo {
    public static void main(String[] args) {
        //创建对象
        MyGenericMethod mm = new MyGenericMethod();
        //演示
        mm.show("aaa");
        mm.show(123);
        mm.show(12.23);

        System.out.println(mm.show2("aaaa"));
    }
}

含有泛型的接口

定义格式： 修饰符 interface接口名<代表泛型的变量>{}

例如：

  public interface MyGenericInterface<E>{
  publiic 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;
  }
  }

此时，泛型E的值就是String类型

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");
  }
  }

3.4 泛型通配符

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

通配符的基本使用

泛型的通配符：不知道使用什么类型来接收的时候，此时可以使用？，？表示未知通配符

此时只能接收数据，不能往该集合中存储数据。

public class GenericDemo3 {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<>();
        getElement(list1);
        Collection<String> list2 = new ArrayList<>();
        getElement(list2);
    }

    public static ArrayList getElement(Collection<?> collection) {
        
    }

通配符高级使用：受限泛型

之前设置泛型的时候，实际上可以是任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

• 格式： 类型名称<? extends 类>对象名称
• 意义：只能接收该类型及其子类

泛型的下限：

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

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