Java 集合(一)——Collection集合接口、Iterator 迭代器和泛型

一、前言

因为明年三四月份想换工作,也为了对 Java 语言有更深的理解,所以想重新学一遍 Java,把以前没有注意到的细节再巩固一下,因为现在时间还是有的,所以我决定重新的过一遍 Java 的知识点(至少比粗暴的刷 Java 面试题好)。我这里准备的学习资料主要有十大章,我们来看一下每章的目录名称(用的 Java 版本是目前用的最多的版本 Java 8):

  1. Java 基础语法;
  2. 面向对象和封装;
  3. 常用 API 第一部分;
  4. 继承与多态;
  5. 常用 API 第二部分;
  6. 集合;
  7. 异常与多线程;
  8. File 类与 IO 流;
  9. 网络编程;
  10. JDK 8 新特性。

但是我不打算从第一章开始看,我决定从第 6 章 集合 开始,等 6 到 10 章学完,再学 1 到 5 章,我们来看一下集合这一章的目录:

  1. Collection 集合;
  2. 泛型;
  3. 综合案例 1;
  4. List 集合;
  5. Set 集合;
  6. Collections 工具类;
  7. Map 集合;
  8. 综合案例 2;

集合这一章的内容确实有点多,所以我们分三部分来讲解,让我们开始。

二、Collection 集合

2.1、集合概述

集合是 Java 中提供的一种容器,可以用来存储多个数据。集合和数组都是容器,它们的区别如下:

  • 数组的长度是固定的,集合的长度是可变的。
  • 数组中存储的是统一类型的元素,可以存储基本数据类型,也可以存储对象。集合存储的都是对象,不可以存储基本数据类型,而且对象的类型可以不一致。

2.2、集合框架

集合的框架如下所示,需要注意的点有:

  1. TreeSet 与 HashSet 是无序的,即存和取的元素的顺序有可能不一致,但是 LinkedHashSet 是有序的。
  2. 顶层不是接口就是抽象类,无法创建对象使用,需要底层的子类创建对象使用。

集合框架

2.3、Collection 集合常用功能

Collection 是所有单列集合的父接口,因此在 Collection 中定义了单列集合(List 和 Set)通用的一些方法,这些方法可用于操作所有的单列集合,方法如下:

  • public boolean add(E e):把给定的对象添加到当前集合中。
  • public void clear():清空集合中的所有元素。
  • public boolean remove(E e):把给定的对象在当前集合中删除。
  • public boolean contains(E e):判断当前集合中是否包含给定的对象。
  • public boolean isEmpty():判断当前集合是否为空。
  • public int size():返回集合中元素个数。
  • public Object[] toArray():把集合转化成数组。

Collection 常用功能代码演示如下所示,输出结果大家可以自己复制到 Intellij IDEA 中查看。

public class CollectionDemo01 {

    public static void main(String[] args) {
        // 创建集合对象
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll); // 重写了toSting() 方法

        /**
         * public boolean add(E e):把给定的对象添加到当前集合中。
         * 返回值是一个 boolean 值,一般都返回 true,可以不用接收
         */
        boolean b1 = coll.add("张三");
        System.out.println("b1:" + b1); // b1:true
        System.out.println(coll); // [张三]
        coll.add("李四");
        coll.add("王五");
        coll.add("赵六");
        coll.add("田七");
        System.out.println(coll); // [张三, 李四, 王五, 赵六, 田七]
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        /**
         * public boolean remove(E e):把给定的对象在当前集合中删除。
         * 返回值是一个 boolean 值,集合中存在元素,删除元素,返回 true,集合中不存在的话,删除失败,返回 false
         */
        boolean b2 = coll.remove("赵六");
        System.out.println("b2:" + b2); // b2:true
        boolean b3 = coll.remove("赵四");
        System.out.println("b3:" + b3); // b3:false
        System.out.println(coll); // [张三, 李四, 王五, 田七]
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        /**
         * public boolean contains(E e):判断当前集合中是否包含给定的对象。
         * 包含返回 true,不包含返回 false
         */
        boolean b4 = coll.contains("李四");
        System.out.println("b4:" + b4); // b4:true
        boolean b5 = coll.contains("赵四");
        System.out.println("b5:" + b5); // b5:false
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        /**
         * public boolean isEmpty():判断当前集合是否为空。
         */
        boolean b6 = coll.isEmpty();
        System.out.println("b6:" + b6); // b6:false
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        /**
         * public int size():返回集合中元素个数。
         */
        int size = coll.size();
        System.out.println("size:" + size);
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        /**
         * public Object[] toArray():把集合转化成数组。
         */
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        /**
         * public void clear():清空集合中的所有元素。
         * 但是不删除集合,集合还存在
         */
        coll.clear();
        System.out.println(coll); // []
        System.out.println(coll.isEmpty()); // true
    }
}

三、Iterator 迭代器

3.1、Iterator 接口概述

在程序开发中,经常需要遍历集合中的元素,针对这种需求,JDK 专门提供了一个接口 Iterator。Iterator 接口也是 Java 集合中的一员,主要用于迭代访问(即遍历)Collection 中的元素,因为 Iterator 对象也被称为迭代器,是一种通用的取出集合中元素的方式

3.2、Iterator 接口常用方法

常用方法有一下两个:

  • public boolean hasNext():如果仍有元素,则返回 true。
  • public E next():返回迭代的下一个元素。

3.3、迭代器的使用步骤

由于 Iterator 迭代器是一个接口,我们无法直接使用,需要使用 Iterator 接口的实现类对象,通过 Collection 接口中的 iterator() 方法返回迭代器的实现类对象。使用步骤如下:

  1. 使用集合中的 iterator() 方法获得迭代器的实现类对象,使用 Iterator 接口接收;
  2. 使用 Iterator 中的方法 hasNext() 判断还有没有下一个元素;
  3. 使用 Iterator 中的方法 next() 取出集合中的元素。

注意:Iterator 接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型。

3.4、增强 for 循环

增强 for 循环(也称 forEach 循环)是 JDK 1.5以后出来的一个高级 for 循环,专门用来遍历数组和集合,它的内部原理其实是个 Iterator 迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。

格式:for(集合/数组的数据类型 变量名 : 集合名/数组名)
for(int i : arr)

Iterator 和增强 for 循环遍历集合代码演示如下所示,输出结果大家可以自己复制到 Intellij IDEA 中查看。

public class IteratorDemo02 {

    public static void main(String[] args) {
        // 创建集合对象
        Collection<String> coll = new ArrayList<>();
        coll.add("乔丹");
        coll.add("詹姆斯");
        coll.add("奥尼尔");
        coll.add("艾佛森");
        coll.add("科比");

        /**
         * 1、使用集合中的 iterator() 方法获得迭代器的实现类对象,使用 Iterator 接口接收;
         *      注意:Iterator<E> 接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型
         * 2、使用 Iterator 中的方法 hasNext() 判断还有没有下一个元素
         * 3、使用 Iterator 中的方法 next() 取出集合中的元素。
         */
        Iterator<String> it = coll.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        // 利用 for 循环改写 while 循环
        for ( Iterator<String> it1 = coll.iterator();it1.hasNext();) {
            System.out.println(it1.next());
        }
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        // 可以用增强 for 循环遍历(不能用普通 for 循环遍历)
        for (String s : coll) {
            System.out.println(s);
        }
    }
}

3.5、迭代器的工作原理

  1. Iterator it = coll.iterator():获取迭代器的实现类对象,并把引用(可以理解成指针)指向集合中的 -1 索引;
  2. it.hasNext():判断集合中还有没有下一个元素;
  3. it.next():取出下一个元素,并把指针(这里用指针来说明好理解一点)向后移动一位。

四、泛型

4.1、泛型概述

泛型是一种未知的数据类型,当我们不知道用什么数据类型的时候,可以使用泛型,泛型也可以看成是一个变量,用来接收数据类型。ArrayList 集合在定义的时候(源码中就是利用泛型的),不知道集合中都会存储什么类型的数据,所以使用泛型。

4.2、使用泛型的优点与弊端

集合不使用泛型,默认的类型就是 Object 类型,可以存储任意类型的数据,但是同时也使得集合变得不安全,容易引发异常,所有使用泛型的优点有:

  1. 避免了类型转化的麻烦;
  2. 把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候就会报错)。

使用泛型创建集合和不使用泛型创建集合代码演示如下所示,输出结果大家可以自己复制到 Intellij IDEA 中查看。

public class GenericDemo01 {

    public static void main(String[] args) {
    	// 不使用泛型
        //show01();
        // 使用泛型
        show02();
    }

    /**
     * 创建集合对象,不使用泛型
     * 好处:
     *      集合不使用泛型,默认的类型就是 Object 类型,可以存储任意类型的数据
     * 弊端:
     *      不安全,容易引发异常
     */
    private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);

        // 使用迭代器遍历
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Object obj = it.next();
            System.out.println(obj);


            String s = (String) obj;
            // 运行后,会有异常
            System.out.println(s.length()); // java.lang.ClassCastException: Integer cannot be cast to String
        }
    }

    /**
     * 创建集合对象,使用泛型
     * 好处:
     *      1、避免了类型转化的麻烦
     *      2、把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候就会报错)
     * 弊端:
     *      泛型是什么类型,只能存储什么类型的数据
     */
    private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");

        // 使用迭代器遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
            System.out.println(s.length());
        }
    }
}

4.3、定义含有泛型的类

含有泛型的类定义如下代码所示:

public class GenericDemo02<E> {

    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }

    public static void main(String[] args) {
        GenericDemo02<String> g1 = new GenericDemo02();
        g1.setName("testGeneric");
        System.out.println(g1.getName());

        GenericDemo02<Integer> g2 = new GenericDemo02();
        g2.setName(123);
        System.out.println(g2.getName());
    }
}

4.4、定义含有泛型的方法

定义含有泛型的方法,泛型需要定义在方法的修饰符和返回值类型之间,定义格式如下所示:

修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型))

public <E> void method01(E e) {
    System.out.println(e);
}

// 静态方法
public static <E> void method2(E e) {
    System.out.println(e);
}

4.5、定义并使用含有泛型的接口

含有泛型的接口如下所示:

public interface GenericInterface04<I> {
    public abstract void method(I i);
}

含有泛型的接口的使用方式有两种:

  1. 在定义接口的实现类的时候指定接口的泛型。
    public class GenericInterface04Impl1 implements GenericInterface04<String> {
        @Override
        public void method(String s) {
            System.out.println(s);
        }
    }
    
  2. 接口使用什么泛型,实现类就使用什么泛型,类跟着接口走。就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型;
    public class GenericInterface04Impl2<I> implements GenericInterface04<I> {
        @Override
        public void method(I i) {
            System.out.println(i);
        }
    }
    

4.6、泛型通配符

当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符 <?> 表示,但是使用通配符只能作为方法的参数传递,不能定义对象。泛型通配符的使用如下所示:

public class GenericDemo05 {

    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("a");
        list2.add("b");

        printArray(list1);
        printArray(list2);
    }

    public static void printArray(ArrayList<?> list) {
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

4.7、受限泛型

泛型的上限限定:
格式:类型名称 <? extends E> 对象名称
意义:只能接受 E 类型及其子类。

泛型的下限限定:
格式:类型名称 <? super E> 对象名称
意义:只能接受 E 类型及其父类。

受限泛型代码演示如下所示,大家可以自己复制到 Intellij IDEA 中查看。

public class GenericDemo06 {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<>();
        Collection<String> list2 = new ArrayList<>();
        Collection<Number> list3 = new ArrayList<>();
        Collection<Object> list4 = new ArrayList<>();

        /**
         * Integer extends Number extends Object
         * String extends Object
         */

        getElement1(list1);
        getElement1(list2); // 报错
        getElement1(list3);
        getElement1(list4); // 报错

        getElement2(list1); // 报错
        getElement2(list2); // 报错
        getElement2(list3);
        getElement2(list4);
    }

    // 泛型的上限:此时的泛型?,必须是 Number 类型或者是 Number 类型的子类
    public static void getElement1(Collection<? extends Number> coll) {
    }

    // 泛型的下限:此时的泛型?,必须是 Number 类型或者是 Number 类型的父类
    public static void getElement2(Collection<? super Number> coll) {
    }
}

五、集合综合案例——斗地主

综合案例步骤:

  1. 准备牌:
    54 张牌存储到一个集合中;
    特殊牌:大王,小王;
    其他 52 张牌:
        定义一个数组,存储 4 种花色 ♥ ♦ \color{red}{♥ ♦} ♠ ♣ \color{black}{♠ ♣}
        定义一个数组,存储 13 个序号[2、A、K…3];
    循环嵌套遍历上面两个数组,组装 52 张牌[ ♥ 2 \color{red}{♥2} 2 ♦ A \color{red}{♦A} A ♥ K \color{black}{♥K} K ♣ Q \color{black}{♣Q} Q,…];
  2. 洗牌
    利用集合工具类 Collections.shuffle() 来随机打乱集合中元素的位置;
  3. 发牌
    发牌要求如下:
        一人 17 张牌,剩余 3 张作为底牌,一人一张轮流发牌(集合的索引 % 3);
        定义四个集合,存储 3 个玩家的牌和底牌;
  4. 看牌
    直接打印集合,遍历存储玩家和底牌的集合;

具体实现代码如下所示:

public class DouDiZhu {

    public static void main(String[] args) {
        // 1、准备牌
        // 定义一个存储 54 张牌的集合;
        ArrayList<String> poker = new ArrayList<>();
        // 定义两个集合,一个存储牌的花色,一个存储牌的序号
        String[] colors = {"♠", "♥", "♣", "♦"};
        String[] numbers = {"2", "A", "k", "q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};
        // 先把大王和小王存储到poker集合中
        poker.add("大王");
        poker.add("小王");
        // 循环嵌套两个数组,组装52张牌
        for (String number : numbers) {
            for (String color : colors) {
                // 把组装好的牌存到poker集合中
                poker.add(color + number);
            }
        }

        // 2、洗牌
        // 利用集合工具类 Collections.shuffle() 来随机打乱集合中元素的位置;
        Collections.shuffle(poker);

        // 3、发牌
        // 定义四个集合,存储 3 个玩家的牌和底牌;
        ArrayList<String> player01 = new ArrayList<>();
        ArrayList<String> player02 = new ArrayList<>();
        ArrayList<String> player03 = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();

        // 4、遍历poker集合,获取每一种牌
        // 使用poker集合的索引 % 3 给三个玩家轮流发牌,最后剩余三张牌给底牌
        for (int i = 0; i < poker.size(); i++) {
            String p = poker.get(i);
            if (i >= 51) {
                dipai.add(p);
            } else if (i % 3 == 0) {
                player01.add(p);
            } else if (i % 3 == 1) {
                player02.add(p);
            } else {
                player03.add(p);
            }
        }
		
		// 方便起见直接打印
        System.out.println("玩家1的牌:" + player01);
        System.out.println("玩家2的牌:" + player02);
        System.out.println("玩家3的牌:" + player03);
        System.out.println("底牌:" + dipai);
    }
}

打印结果如下所示:

结果1
结果2

六、小结

集合第一部分中我们讲了 Collection集合接口Iterator 迭代器泛型斗地主综合案例,下一节我们讲数据结构List 集合Set 集合

七、源码

文章中用到的所有源码已上传至 github,有需要的可以去下载。

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值