collection 接口

查

int size();
    有效元素个数

boolean isEmpty();
    判断当前集合是否为空，是否存在有效元素

boolean contains(Object obj);
    判断指定元素是否在当前集合中存在

boolean containsAll(Collection<?> c);
    判断传入的参数集合是不是当前集合的子集合

Object[] toArray();
    返回集合中所有保存元素的Object类型数组

案例代码

public class TestGet {
    public static void main(String[] args) {
        Collection<String> collection1 = new ArrayList<String>();
        Collection<String> collection2 = new ArrayList<String>();

        collection1.add("Java");
        collection1.add("Hello");

        collection2.add("Java");
        collection2.add("Hello");
        collection2.add("World");

        System.out.println(collection1.size());    // 2

        System.out.println(collection1.isEmpty());    // fasle

        System.out.println(collection1.contains("Java"));    //true

        System.out.println(collection2.containsAll(collection1));    // true

        Object[] array = collection1.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

迭代器

是用来获取集合中元素的另一种方式（遍历），依赖于集合存在

获取迭代器的方法

Iterator<E> iterator();
    获取迭代器对象，泛型对应的具体数据类型和集合中约束的泛型具体数据类型一致。

其他方法

boolean hasNext();
    判断当前集合中是否可以继续得到元素，继续遍历
        
E next();
    1. 获取迭代器当前指向的元素
    2. 将迭代器指向下一个元素
        
void remove();
    删除通过next方法获取到元素
        【注意】
        1、remove方法只能删除next方法获取到元素
        2、remove方法只能在next方法之后执行，且不能跨过一个next执行
        3、没有next不能使用remove

案例代码

public class Test {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();

        c.add("雪花纯生");
        c.add("修道院啤酒");
        c.add("1664");
        c.add("泰山精酿");
        c.add("时光精酿");
        
        /*
         * 根据当前集合，获取对应的迭代器对象
         * 
         * 得到的迭代器对象会依据，当前集合中的所有元素进行一个规划操作。
         * 迭代器对于整个集合中的元素都是存在预期。
         */
        Iterator<String> iterator = c.iterator();
        
        /*
         * 迭代器遍历，利用迭代器的特征进行遍历操作
         */
        while (iterator.hasNext()) {
            // 获取每一个迭代器指向元素，并且展示
            String string = iterator.next();
            System.out.println(string);
            
            /*
             * 通过集合对象本身删除1664，对于迭代器而言，一脸懵逼，原本的规划
             * 没有了！！！并且集合没有告知迭代器数据发生了改变，迭代器继续按照
             * 原本的规划路径操作，保存！！！
             * 
             * 对于集合在内存中占用的空间而言
             *     1. 集合对应的引用数据类型变量可以操作对应空间
             *     2. 迭代器可以操作对应的空间
             * 
             * 对于集合和迭代器而言，【集合在内存中占用的空间】共享资源，在操作
             * 共享资源过程中，我们要多多考虑共享资源的冲突问题。
             * 后面课程中会讲到【多线程】
             */
            c.remove("1664");
        }
        
        /*
         Exception in thread "main" java.util.ConcurrentModificationException
                at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
                at java.util.ArrayList$Itr.next(ArrayList.java:859)
                at com.qfedu.b_iterator.Demo3.main(Demo3.java:30)
         */
    }
}

List

概述

有序的 collection ，可以根据索引操作元素，数据可重复

ArrayList

​ 可变长数组

LinkedList

​ 双向链表

Vector

​ 线程安全的可变长数组

增加方法

boolean add(E e);    
    List接口继承Collection接口 add方法，使用操作和Collection一致，并且这里采用的添加方式是【尾插法】
    
boolean add(int index, E e);
    List接口【特有方法】，在指定位置，添加指定元素。
    
boolean addAll(Collection<? extends E> c);
    List接口继承Collection接口 addAll方法，使用操作和Collection一致，并且这里采用的添加方式是【尾插法】
    
boolean addAll(int index, Collection<? extends E> c);
    List接口【特有方法】，在指定下标位置，添加另一个集合中所有内容

public class Test {
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<String>();

        arrayList.add("Hello");
        arrayList.add("World");
        arrayList.add("Android");

        arrayList.add(0, "Java");
        System.out.println(arrayList);

        List<String> al = new ArrayList<String>();

        al.add("ArrayList是线程不安全的可变长数组");
        al.add("LinkedList是双向链表：增删快，查询慢");

        al.addAll(arrayList);

        System.out.println(al);

        arrayList.addAll(0, al);

        System.out.println(arrayList);
    }
}

删除方法

E remove(int index);
    List接口【特有方法】，获取指定下标位置的元素并删除。

boolean remove(Object obj);
    List接口继承Collection接口方法。删除集合中的指定元素
    
boolean removeAll(Collection<?> c);
    List接口继承Collection接口方法。删除当前集合中和参数集合重复元素
    
boolean retainAll(Collection<?> c);
    List接口继承Collection接口方法。保留当前集合中和参数集合重复元素
    
clear();
    List接口继承Collection接口方法。清空整个集合中的所有元素

public class TestRemove {
    public static void main(String[] args) {
        List<Integer> al = new ArrayList<Integer>();

        al.add(1);
        al.add(2);
        al.add(3);
        al.add(4);

        System.out.println("删除指定下标位置为0的元素： " + al.remove(0));

        System.out.println("al : " + al);

        List<Integer> al1 = new ArrayList<Integer>();

        al1.add(4);
        al1.add(5);
        al1.add(6);

        System.out.println("al.removeAll(al1) : " + al.removeAll(al1));
        System.out.println("al : " + al);

        List<Integer> al2 = new ArrayList<Integer>();

        al2.add(5);
        al2.add(7);
        al2.add(6);

        System.out.println("al1.reatinAll(al2) : " + al1.retainAll(al2));

        System.out.println("al1 ： " + al1);

        al2.clear();

        System.out.println("al2.clear() ： " + al2);
    }
}