4.17 集合

集合Conllection 迭代器Iterable

Collection常用方法

        // 创建一个集合对象
        Collection c1 = new ArrayList();
        // 判断是否为空
        System.out.println(c1.isEmpty());
        // 已添加元素的个数
        System.out.println(c1.size());
        // int 类型 先自动装箱为integer类型 然后发生多态
        c1.add(1);
        c1.add("a");
        System.out.println(c1.size());
        // 根据元素内容 删除元素
        c1.remove(1);
        System.out.println(c1);
        // 没有提供查询功能和修改功能
        // 遍历
        // 把集合转换为数组
        Object[] arr = c1.toArray();
        // 清空集合
        c1.clear();
        // 判断是否包含某个元素
        System.out.println(c1.contains("a"));

Collection实现子类ArrayList(底层实现数组，开始容量为10，不够时1.5倍扩容)，有序（插入时的顺序）可重复，因为是由数组实现，修改和查询效率高

public ArrayList(Collection<? extends E> c) {
        //数组
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // replace with empty array.
            elementData = EMPTY_ELEMENTDATA;
        }
    }



private Object[] grow(int minCapacity) {
        int oldCapacity = elementData.length;
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth */
                    oldCapacity >> 1           /* preferred growth */);
            return elementData = Arrays.copyOf(elementData, newCapacity);
        } else {
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }

    private Object[] grow() {
        return grow(size + 1);
    }

ArrayList可以使用迭代器或下标遍历

//迭代器遍历        
//像创建迭代器对象
Iterator it = c1.iterator();
//利用Iterator中提供的方法hasNext()判断集合中是否还有数据
//注意：创建迭代器对象后使用增加，删除时不能使用集合提供的方法，必须使用迭代器提供的增加、删除方法
while (it.hasNext()) {
//利用next()方法查询数据
       System.out.println(it.next());
}

LinkedList底层实现时由双向链表，链表中保存节点，prev指向前节点的地址，item保存本身数据，next指向后节点的地址，增加和删除效率高

LinkedList,ArrayList中提供的方法都基本相同

public static void main(String[] args) {
// 创建ArrayList
        // List list = new ArrayList();
//创建LinkedList
        List list = new LinkedList();
        // 添加
        // 尾部添加
        list.add(1);
        list.add("b");
        // 插入到指定下标中
        list.add(0, "a");
        // 删除
        // 根据内容删除
        list.remove("a");
        // 如果传入的是int类型,则为根据下标删除
        list.remove(1);
        // 如果要根据内容删除,但是内容又是整数
        // 就需要转换一下,装箱
        list.remove(Integer.valueOf(1));

        list.add("a");
        list.add("b");
        list.add("c");
        // 查询
        System.out.println(list.get(1));
        // 修改
        // 索引 , 要修改的内容
        list.set(1, "bb");
        // 遍历
        System.out.println(list);
        // 迭代器遍历
        for (Object object : list) {
            System.out.println(object);
        }
        // for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }


    }

LinkedList实现

transient int size = 0;
transient Node<E> first;
transient Node<E> last;

Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }

//首节点添加(尾节点添加实现原理相视)
    private void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }