不冷博客

Java迭代器与collection接口-11月11日讲课内容

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);
    }
}

当前页面是本站的「Google AMP」版。查看和发表评论请点击:完整版 »