Java 集合与迭代器

集合

数组弊端:

1.只添加相同类型的元素(基本数据类型 和 引用数据类型 都能保存)

2. 长度一旦确定 就不能改变 要添加超出 数组长度个数的元素 操作比较复杂

集合的由来 因为数组操作数据的弊端 用来代替数组

集合特点 :

1. 能添加不同类型的元素

注意 : 集合中 只能添加 引用数据类型 (只能添加对象类型)

2. 长度可变

集合collection接口中的方法

集合可以保存不同数据类型的数据

保存基本数据类型是以自动装箱的形式 进行存储

注解 rawtypes 保持原有类型的注解
     unchecked 不检查插入数据类型
放到类上 整个类 不写泛型 都不会报黄
@SuppressWarnings({ "rawtypes", "unchecked" })

    public static void fun1() {
        // 创建一个集合 多态的声明方法

        Collection collection = new ArrayList();
        // 添加方法
        // 什么时候 会添加失败
        // ArrayList中的add 不可能返回 失败
        // 不能返回失败 为什么还要设计返回值呢? --- 思想
        // 适用所有的子类 子接口
        boolean b1 = collection.add("a");
        boolean b2 = collection.add("b");
        boolean b3 = collection.add("c");
        // 当你向集合当中添加基本数据类型的时候
        // 系统会帮你进行 自动装箱 把基本数据类型变成它的包装类
        boolean b4 = collection.add(10);
        boolean b5 = collection.add(true);
        // 打印集合
        System.out.println(collection.toString());
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b5);
        // 获取集合的长度
        System.out.println(collection.size());
        // 判断是否包含某个元素
        boolean b6 = collection.contains("b");
        System.out.println(b6);
        // 从集合中删除一个元素
        boolean b7 = collection.remove("b");
        System.out.println(b7);
        // 操作的是 原集合
        System.out.println(collection);
        // 判断集合是否为空
        boolean b8 = collection.isEmpty();
        System.out.println(b8);
        // 清空数组
        collection.clear();
        System.out.println(collection);
    }

    public static void fun2() {
        Collection collection = new ArrayList();
        // 添加 a b c d
        collection.add("a");
        collection.add("b");
        collection.add("c");
        collection.add("d");
        // 遍历集合中的每一个元素
        Object[] array = collection.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    public static void fun3() {
        /*
         * 创建一个集合
         * 保存三个学生
         * 遍历学生信息
         */

        Collection collection = new ArrayList();
        collection.add(new Student("张三", 18));
        collection.add(new Student("李四", 18));
        collection.add(new Student("王五", 18));
        // 集合转数组 (相当于 有一个 向上转型)
        Object[] array = collection.toArray();

        for (int i = 0; i < array.length; i++) {
            // array[i] 直接从数组中取出来是Object 类型
            // 要想使用 Student 类中的方法 需要强转
            // 必须是这个类型 你才能强转
            Student student = (Student)array[i];
            System.out.println(student.getName());
        }
    }

---

错误的强转方式

    public static void fun4() {
        Collection collection = new ArrayList();
        collection.add(new Student("张三", 18));
        collection.add(new Student("李四", 18));
        collection.add(new Student("王五", 18));
        // 集合转数组 (相当于 有一个 向上转型)
        // 对象调方法 强转注意 : 把数组中每一个对象进行强转
        // 而不是把保存对象的容器(数组)转化    
        Student[] array = (Student[])collection.toArray();

    }

---

    public static void fun5() {
        Collection c1 = new ArrayList();
        Collection c2 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");

        c2.add("x");
        c2.add("y");
        c2.add("z");


        boolean isaddAll = c1.addAll(c2);
        // 查看调用后的效果
        // 把c2集合每一个元素取出来 添加到c1集合末尾
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(isaddAll);
    }

    public static void fun6() {
        Collection c1 = new ArrayList();
        Collection c2 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");

        c2.add("x");
        c2.add("y");
        c2.add("c");
        // 这个方法 删除 将两个集合的重合元素 删除
        // 谁调用这个方法 就删除谁的元素 另一个集合不变
        // 只删除交集 重复也可以删
        boolean removeAll = c1.removeAll(c2);
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(removeAll);
    }

    public static void fun7() {
        Collection c1 = new ArrayList();
        Collection c2 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");

        c2.add("x");
        c2.add("y");
        c2.add("z");
        // 把两个集合的交集取出来 保存在c1(谁调的方法 保存在谁那)
        // 如果c1集合和c2集合 就出交集 放到c1 中
        // 如果c1和原来对比 不发生变化返回true
        // 如果c1和原来对比 发生变化返回false
        boolean retainAll = c1.retainAll(c2);
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(retainAll);
    }

迭代器(可以理解为遍历)

    public static void fun1() {
        // 测试迭代器中的方法
        Collection collection = new ArrayList();
        collection.add("a");
        collection.add("b");
        collection.add("c");
        collection.add("d");
        // 获取集合中的迭代器
        Iterator iterator = collection.iterator();
        // 先判断集合中是否有元素
        boolean isHasNext = iterator.hasNext();
        System.out.println(isHasNext);
        // 从集合中取出元素
        Object next = iterator.next();
        System.out.println(next);
    }

    /**
     * 遍历集合
     */
    public static void fun2() {
        Collection collection = new ArrayList();
        // 迭代 有一个指针 指向集合首位置
        // 每调用一次 next方法 这个指针 向下移一格
        collection.add("a");// 
        collection.add("b");// 
        collection.add("c");//
        collection.add("d");//
        // 遍历集合
        Iterator iterator = collection.iterator();
        // 如果有元素 就获取 没元素 就停止循环
        while (iterator.hasNext()) {
            // 注意: 迭代时 循环中 只能使用一次next()方法
            System.out.println(iterator.next());
        }
    }