集合Collection及迭代器介绍

集合介绍

数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少

数组和集合的区别

区别1 :

数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
区别2:
数组长度是固定的,不能自动增长
集合的长度的是可变的,可以根据元素的增加而增长

数组和集合什么时候用

如果元素个数是固定的推荐用数组
如果元素个数不是固定的推荐用集合
集合继承体系图

Collection

单列集合的根接口

Collection集合的基本功能测试

用了别人的图片
其中 ArrayList 和 Vector 都是数组实现，LinkedList是链表实现

Conllection接口的方法功能

set和List接口都是继承于Conllection接口
所以我们使用ArraysList来实现方法

//增加元素
Collection c = new ArrayList();//1.5版本后要加泛型
//public boolean add(Object a)
    public boolean add(E e) {// 当然这是ArrayList 重写的
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;//返回值为Boolean
    }

在List中（继承实现体系中，返回值都是true）而在Set（继承实现体系中，返回值都是false）

//删除指定元素
c.remove("a");

//清空集合
c.clear()

//判断是否包含
c.contains("a");

//判断是否为空
c.isEmpty()

//获取元素个数
c.size()

集合数组的转化

集合转化为数组

Object [] arr = c.toArray();//注意这个时候已经是向上提上了。

集合与集合之间

//集合和集合之间加减
//若c1和c2都是集合ArrayList,那么
c1.add(c2);//将c2当一个元素添加到集合c1中
c1.addAll(c2);//将c2全部添加到c1中

//删除的是交集，有删除返回true，无删除返回false
c1.removeAll(c2);

//判断c1是否包含c2
c1.containsAll(c2)

//保留交集  有交集没有交集没关系
// 如果调用的集合改变了返回true ，反之返回false 
c1.retainAll(c2);

集合中的遍历–迭代

List 列表不但继承了Collection接口还继承了Iterable接口

//注意 不但是ArrayList()可用，其他的，只要实现了Iterator接口的可使用（接口是制定一种规则）
Conllection<String>  c  = new ArrayList<>();
c.add("a");
c.add("a");
c.add("b");
c.add("c");
Iterator it = c.iterator();     //获取迭代器
// boolean hasNext() 如果还可迭代返回true
boolean c1 = it.hasNext();     //判断集合中是否有元素
// <E>  next() 返回迭代的下一个元素
String s1 = it.next();		
//void remove()从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）

迭代器原理

迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,
第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,
第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可
我们寻找ArrayList中的迭代器

//823行
    public Iterator<E> iterator() {//Iterator()是一个接口不可直接创建对象，用方法返回 联系Iterator it = c.iterator();
        return new Itr();//new 了一个成员内部类
    }
    
 private class Itr implements Iterator<E> {//写在ArrayList中的内部类
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        public boolean hasNext() {//
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

这里我也是懵比状态，它用iterator()创造对象后，但构造函数并没有对参数进行初始化，如何就使用起来了，我表示很懵。以后再来修改吧，我先看看别人的想法。