JAVA集合继承关系图介绍和Collection接口深刻理解

集合【必须掌握】

集合引出：

由于前面我们保存数据使用的是数组，那么数组不足的地方，我们分析如下：

1. 长度开始时必须指定，而且一旦指定，不能更改
2. 保存的必须为同一类型的元素
3. 使用数组进行增加、删除元素时比较麻烦

写出Person数组扩容示意代码：

Person[]  persons = new Person[1];//大小是1
persons[0] = new Person();


//增加新的Person对象
Person[] persons2 = new Person[persons.length+1];//新创建数组
//使用 for拷贝
persons2[persons2.length-1] = new Person();//添加新的对象

集合的好处

1. 可以动态保存任意多个对象，使用比较方便
2. 提供一系列方便的操作对象的方法【add remove set get等】
3. 使用集合添加，删除新元素方便

注意是集合存放的是引用数据类型，基本数据会自动装箱成引用数据类型

集合继承体系图

Collection接口 特点 方法

Collection接口的子接口：List实现类：

ArrayList LinkedList Vector

Collection接口的子接口：Set实现类 ：HashSet LinkedHashSet

Map接口 特点 方法 遍历方式

Map接口的实现类 ：HashMap Hashtable等

Collections工具类的使用

JAVA集合主要为两大类：【单例集合 双例集合】【必须记住】

Collection

实现Collection接口的类或子接口，都可以使用迭代器的方式来遍历集合，迭代器的方法来住于Iterable接口

Map

Collection接口 和 常用方法

Collection接口实现类的特点

public interface Collection<E>  extends iterable<E>{}

特点：

1. Collection实现子类可以存放多个元素，每个元素可以是Object
2. 有些Collection的实现类，可以存放重复的元素，有些不可以
3. 有些Collection的实现类，有些是有序的【List】，有些是无序的【Set】
4. Collection接口没有直接的实现子类，是通过它的子接口Set 和 List来实现的

Collection接口常用方法

1.  add：添加单个元素
2.  remove：删除指定元素
3.  contaions：查找元素是否为空
4.  size：获取元素个数 
5.  isEmppty：判断是否为空
6.  clear：清空
7.  addAll：添加多个元素
8.  contaionsAll：查找多个元素是否都存在
9.  removeAll：删除多个元素
10. toArray：返回Object[]

Modifier and Type	Method and Description
boolean	add(E e) 确保此集合包含指定的元素（可选操作）。
boolean	addAll(Collection<? extends E> c) 将指定集合中的所有元素添加到此集合（可选操作）。
void	clear() 从此集合中删除所有元素（可选操作）。
boolean	contains(Object o) 如果此集合包含指定的元素，则返回 true 。
boolean	containsAll(Collection<?> c) 如果此集合包含指定 集合中的所有元素，则返回true。
boolean	isEmpty() 如果此集合不包含元素，则返回 true 。
Iterator<E>	iterator() 返回此集合中的元素的迭代器对象。
boolean	remove(Object o) 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
boolean	removeAll(Collection<?> c) 删除指定集合中包含的所有此集合的元素（可选操作）。
int	size() 返回此集合中的元素数。
Object[]	toArray() 返回一个包含此集合中所有元素的数组。

Collection常见方法案例代码

package collection_.collectionP;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * @author: 海康
 * @version: 1.0
 */
public class Collection01 {
    public static void main(String[] args) {
        List c = new ArrayList();
        // 注意是集合存放的是引用数据类型，基本数据会自动装箱成引用数据类型
        // 添加元素
        c.add("海康");
        c.add(1.68);//基本数据类型会自动装箱

        // remove 删除元素 [删除元素有两种方式是重载的]
        // 一个是传入索引 返回Object 对象
        // 一个是传入对象名 返回布尔值
//        boolean r = c.remove("海康");
//        Object remove = c.remove(0);

        // contains 查找元素是否存在
        boolean b = c.contains(1.68);//传入的是对象名
        System.out.println(b);

        // size 获取元素个数
        int size = c.size();
        System.out.println("获取元素的个数="+size);

        //　isEmpty 判断集合是否为空
        boolean empty = c.isEmpty();
        System.out.println("判断集合是否为空="+empty);

        // clear 清空
//        c.clear();//清空集合中所有元素

        // addAll 添加多个元素
        Collection c2 =new ArrayList();
        c2.add("湛江");
        c2.add("湛江");
        boolean b1 = c.addAll(c2);
        System.out.println(c);
        
        // containsAll 判断多个元素是否存在
        boolean b2 = c.containsAll(c2);
        System.out.println(b2);
        
        // removeAll 删除多个元素
        boolean b3 = c.removeAll(c2);
        System.out.println(b3);
        
        // toArray 返回Object[] 数组
        Object[] objects = c.toArray();
        
    }
}

Conllection接口遍历元素方式1-使用Iterator【迭代器】

基本介绍：

迭代的步骤：

1.先获取迭代器对象Interatior<E>

2.使用迭代器中的方法判断是否还有下一个元素【iteratior.hasNext()】

3.再使用迭代器中的方法返回集合中的元素【iteratior.next()】

在调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。若不调用，且下一条记录无效时，直接调用iterator.next()就会抛出异常NoSchElementException异常

Interatior接口中的方法

Modifier and Type	Method and Description
default void	forEachRemaining(Consumer<? super E> action) 对每个剩余元素执行给定的操作，直到所有元素都被处理或动作引发异常。
boolean	hasNext() 如果迭代具有更多元素，则返回 true 。
E	next() 返回迭代中的下一个元素。
default void	remove() 从底层集合中删除此迭代器返回的最后一个元素（可选操作）。

迭代器遍历方式：

package collection_.collectionP;

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

/**
 * @author: 海康
 * @version: 1.0
 */
public class Iterator01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(new Book("三国演义","罗",10.1));
        c.add(new Book("小李飞刀","古",10.2));

        System.out.println(c);//直接返回的是集合中的全部元素

        // 如果现在一个一个的遍历集合中的元素，就需要用到迭代器
        // 遍历集合的三步：
        //1.获取迭代器
        Iterator iterator = c.iterator();//获取迭代器对象
        //2.判断是否有下一个元素
//        while (iterator.hasNext()){
//            //3.返回指针指向当前的元素
//            Object obj = iterator.next();
//            System.out.println(obj);//默认调用toString方法【自动实现动态绑定机制】
//        }

        // 生成迭代器并遍历集合的快捷键 快速生成 while ==> itit
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }

        // 当退出 while 循环后，这时 iterator 迭代器，指向最后的元素,如果此时再想取元素，
        // 直接抛出 NoSuchElementException 异常
//        iterator.next();//NoSuchElementException

        // 如果此时再想取集合中的元素，就需要重置我们的迭代器
        iterator = c.iterator();
        // 再一次遍历
    }
}

class Book {
    private String name;
    private String author;
    private double price;

    public Book() {
    }

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

当退出 while循环后，这里iterator迭代器，指向最后一个元素，如果此时再想取元素直接就会抛出NoSuchElementException异常。这时就需要重置迭代器 ，iterator = collection.iterator()

Collection接口遍历对象方式2-for循环增加

增加for循环，可以代替iterator迭代器，特点：增加for就是简化版的iterator，本质是一样的，只能用于遍历集合或数组。

基本语法：

for(元素类型  元素名: 集合名或数组名){
	访问元素
}

案例演示【演示遍历Book，并使用Debug源码来证明】

package collection_.collectionP;

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

/**
 * @author: 海康
 * @version: 1.0
 */
public class For01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(new Book("三国演义","罗",10.1));
        c.add(new Book("小李飞刀","古",10.2));
        c.add(new Book("天涯明月","金",12.8));

        // 使用增加for循环【本质上还是使用了迭代器】
        for (Object book:
             c) {
            System.out.println(book);
        }
    }
}

package collection_.collectionP;

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

/**
 * @author: 海康
 * @version: 1.0
 */
public class CollectionExercise01 {
    /**
     * 创建 3个 Dog【name,age】 类对象，放入到ArrayList中，赋给 List 引用
     * 用迭代器和增加for循环两种方式来遍历
     * 重写Dog 的 toString方法，输出name和age
     */

    public static void main(String[] args) {
        Collection list = new ArrayList<Dog>();
        list.add(new Dog("小黄",8));
        list.add(new Dog("小明",5));
        list.add(new Dog("大黄",11));

        // 使用迭代器的方式遍历
        /**
         * 使用迭代器的方式遍历需要有三步：
         * 1.第一步是获取迭代器对象
         * 2.第二步判断是否有元素
         * 3.第三步获取元素
         */
        Iterator iterator = list.iterator();//获取迭代器对象
        while (iterator.hasNext()){
            Object dog = iterator.next();
            System.out.println(dog);//默认调用toString方法
        }

        // 使用增加 for循环
        for (Object dog:
             list) {
            System.out.println(dog);//默认调用toString方法
        }
    }
}
class Dog {
    private String name;
    private int age;

    public Dog() {
    }

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}