集合框架笔记（上）

第一章 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。

1.3Collection常用功能

Collection是所有集合的父接口，因此在Collection中定义了单列集合（List和Set）通用方法，这些方法可以用于操作所有单列集合。方法如下：

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

不是静态方法需要new一个对象再调用，可以使用多态

其他方法自行查API文档

第二章 Iterator迭代器

2.1 Iterator接口

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

方法式：

• public Iterator iterator（）：获取集合对应的迭代器，用来遍历集合中的元素（这个方法在Collection接口中）

概念：

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

Iterator接口的常用方法如下：

• public E next（）：返回迭代的下一个元素
• public boolean hasNext（）：判断是否还有下一个元素

package com.itheima.Iterator;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * java.util.Iterator 迭代器（对集合进行遍历）
 *      两个常用方法：
 *          public boolean hasNext（）：判断是否还有下一个元素
 *          public E next（）：返回迭代的下一个元素
 *  Iterator是一个接口，无法直接使用，需要调用Iterator接口的实现类。
 *  获取实现类的方法比较特殊，Collection接口中有一个方法叫做iterator（），这个方法返回的就是迭代器实现类的对象
 *
 *  迭代器的使用步骤（重点）：
 *      1.使用集合中的iterator方法获取迭代器的实现类对象，再使用Iterator接口来接收它  （多态）
 *      2.使用Iterator接口中的方法hasNext判断是否存在下一个元素，
 *      3.使用Iterator接口中的方法next取出集合中的下一个元素
 */
public class d1IteratorDemo1 {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection<String> coll =  new ArrayList<>();
        //往集合中添加元素
        coll.add("姚明");
        coll.add("科比");
        coll.add("詹姆斯");
        coll.add("库里");
        coll.add("乔丹");

        //1.使用集合中的iterator方法获取迭代器的实现类对象，再使用Iterator接口来接收它  （多态）
        //      注意：Iterator<E>接口也是有泛型的，迭代器的泛型跟着集合走
        Iterator<String> it = coll.iterator();

        while (it.hasNext()){
            String e = it.next();
            System.out.println(e);
        }
    }
}

2.2 for each 循环

专门用来遍历数组和集合的，其内部原理就是个迭代器，所以在遍历过程中不能进行增删操作。

第三章 泛型

3.1 泛型概述

3.2 使用泛型的好处

package com.itheima.Generic;

import java.util.ArrayList;
import java.util.Iterator;

public class d1GenericDemo1 {
    public static void main(String[] args) {
//        show01();

        show02();
    }

    /**
     * 创建集合对象，使用泛型
     * 好处：
     * 1.避免了类型转换的麻烦
     * 2.把运行期异常，提升到了编译期
     * 弊端：
     * 只能存储泛型类型的数据
     */
    private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        list.add("ghj");
        list.add("oie");
        list.add("555");

        //使用迭代器遍历list集合
        //获取迭代器
        Iterator<String> it = list.iterator();
        //使用迭代器中的方法hasNext和next遍历集合
        while (it.hasNext()) {
            //取出元素都是String类型
            String s = it.next();
            System.out.print(s + " ");
            System.out.println(s.length());
        }


        /**
         *      创建集合对象，不使用泛型
         *      好处：
         *          集合不使用泛型，默认的类型就是Object类型，可以存储任意类型数据
         *      弊端：
         *          不安全，会引发异常
         */
//    private static void show01() {
//        ArrayList list = new ArrayList();
//        list.add("abc");
//        list.add(1);
//
//        //使用迭代器遍历list集合
//        //获取迭代器
//        Iterator it = list.iterator();
//        //使用迭代器中的方法hasNext和next遍历集合
//        while (it.hasNext()){
//            //取出元素也是Object类型
//            Object obj =  it.next();
//            System.out.println(obj);
//
//            //想要使用String类型中特有的方法，Length获取字符串长度；不能使用， 多态 Object obj = “abd”；
//            //需要向下转型
//            //会抛出类型转换异常，不能把Integer转换为String类型
//            String s = (String) obj;
//            System.out.println(s.length());
//        }
    }
}

3.3 泛型的定义和使用

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

定义和使用含有泛型的类

定义格式：

​ 修饰符 class 类名<泛型变量>{ }

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

含有泛型的方法

定义格式：

​ 修饰符<泛型变量> 返回值类型 方法名（参数）{ }

含有泛型的方法，泛型在调用方法时确定数据类型

含有泛型的接口

含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型

第一个方法是在创建接口实现类中去确定泛型

/**
 * 含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型
 */
public class d1GenericInterfaceImpl1 implements d1GenericInterface<String>{
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

含有泛型的接口，第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走

第二个方法是在测试类中new实现类时，定义泛型类

/**
 * 测试含有泛型的接口
 */
public class d1GenericInterfaceDemo04 {
    public static void main(String[] args) {
        //创建d1GenericInterfaceImpl1对象
        d1GenericInterfaceImpl1 gi1 = new d1GenericInterfaceImpl1();
        gi1.method("代码写的脑壳痛");

        //创建d1GenericInterfaceImpl2对象
        d1GenericInterfaceImpl2<String> gi2 = new d1GenericInterfaceImpl2<>();
        gi2.method("代码写的脑壳痛");
		
        //在引用类型上定义泛型
        d1GenericInterfaceImpl2<Integer> gi3 = new d1GenericInterfaceImpl2<>();
        gi3.method(8848);
    }
}

​

3.4 泛型通配符

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

通配符基本使用

使用方式：

​ 不能时创建对象使用

​ 只能作为方法的参数使用

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

设置泛型

泛型的上限：

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

泛型的下限：

• 格式：类型名称<? super 类>对象名称
• 意义：只能接受该类型及其父类型