Java集合类库（上）

一、集合的概述

1.集合的由来

• 当需要在Java程序中记录单个数据内容时，则声明一个变量
• 当需要在Java程序中记录多个类型相同的数据内容时，声明一个一维数组
• 当需要在Java程序中记录多个类型不同的数据内容时，则创建一个对象
• 当需要在Java程序中记录多个类型相同的对象数据时，创建一个对象数组
• 当需要在Java程序中记录多个类型不同的对象数据时，则准备一个集合

2.集合的框架结构

• Java中集合框架顶层框架是：java.util.Collection集合 和 java.util.Map集合
• 其中Collection集合中存取元素的基本单位是：单个元素
• 其中Map集合中存取元素的基本单位是：单对元素
  

二、Collection集合

1.基本概念

java.util.Collection接口是List接口、Queue 接口以及Set接口的父接口，因此该接口里定义的方法
既可用于操作List集合，也可用于操作Queue集合和Set集合

2.常用方法

方法声明	功能介绍
boolean add(E e)	先集合中添加对象
boolean addAll(Collection<? extends E> c)	用于将参数指定集合c中的所有元素添加到当前集合中
boolean contains(Object o)	判断是否包含指定对象
boolean containsAll(Collection<?> c)	判断是否包含参数指定的所有对象
boolean retainAll(Collection<?> c)	保留当前集合中存在且参数集合中存在的所有对象
boolean remove(Object o)	从集合中删除对象
boolean removeAll(Collection<?> c)	从集合中删除参数指定的所有对象
void clear()	清空集合
int size()	返回包含对象的个数
boolean isEmpty()	判断是否为空
boolean equals(Object o)	判断是否相等
int hashCode()	获取当前集合的哈希码值
Object[] toArray()	将集合转换为数组
Iterator iterator()	获取当前集合的迭代器

三、Iterator接口

1.基本概念

• java.util.Iterator接口主要用于描述迭代器对象，可以遍历Collection集合中的所有元素
• java.util.Collection接口继承Iterator接口，因此所有实现Collection接口的实现类都可以使用该迭代器对象

2.常用方法

方法声明	功能介绍
boolean hasNext()	判断集合中是否有可以迭代/访问的元素
E next()	用于取出一个元素并指向下一个元素
void remove()	用于删除访问到的最后一个元素

四、for each 循环

1.基本概念

Java5推出了增强型for循环语句，可以应用数组和集合的遍历，是经典迭代的“简化版”

2.语法格式

for(元素类型 变量名 : 数组/集合名称) {
	循环体;
}

3.执行流程

不断地从数组/集合中取出一个元素赋值给变量名并执行循环体，直到取完所有元素为止

五、Collection相关方法测试

		//1.准备一个Collection集合并打印
        //接口类型的引用指向实现类的对象，形成多态
        Collection c1 = new ArrayList();
        //自动调用toString方法，调用ArrayList类中的toString方法，默认打印格式为：[元素值1, 元素值2, ...]
        System.out.println("集合中的元素有：" + c1); //[]

        //2.向集合中添加单个元素并打印
        boolean b1 = c1.add(new String(("one")));
        System.out.println("b1 = " + b1);
        System.out.println("集合中的元素有：" + c1); //[one]
        b1 = c1.add(Integer.valueOf(2));
        System.out.println("b1 = " + b1); //b1 = true
        System.out.println("集合中的元素有：" + c1); //[one, 2]
        b1 = c1.add(new Person("zhangfei", 30));
        System.out.println("b1 = " + b1); //b1 = true
        System.out.println("集合中的元素有：" + c1); //[one, 2, Person{name='zhangfei', age=30}]

        //3.向集合中中添加多个元素并打印
        Collection c2 = new ArrayList();
        c2.add("three");
        c2.add(4);
        System.out.println("c2 = " + c2); //[three, 4]
        //将c2中的所有元素全部添加到集合c1中，也就是将集合c2中的元素一个一个依次添加到集合c1中
        b1 = c1.addAll(c2);
        //表示将集合c2整体看做一个元素添加到集合c1中
//        b1 = c1.add(c2);
        System.out.println("b1 = " + b1); //true
        // b1 = c1.addAll(c2); => [one, 2, Person{name='zhangfei', age=30}, three, 4]
        // b1 = c1.add(c2); => [one, 2, Person{name='zhangfei', age=30}, [three, 4]]
        System.out.println("c1 = " + c1);

        //4.判断集合中是否包含参数指定的单个元素
        b1 = c1.contains(new String("one"));
        System.out.println("b1 = " + b1); //true

        b1 = c1.contains(new String("two"));
        System.out.println("b1 = " + b1);//false

        /*contains方法的工作原理：
        实际上是通过调用 Objects.equals(o, e)，将集合中的已有元素与参数对象依次进行比较，其中 o代表contains方法的形式参数，e代表集合中的每个元素
        比较的方式是调用Objects中的equals方法，而该方法的工作原理如下：
            a就是上述的形式参数（也就是contains中传入的形式参数），b表示集合中的已有元素
            public static boolean equals(Object a, Object b) {
                return (a == b) || (a != null && a.equals(b));
                元素包含的第一种方式：a对象和b对象的地址相同
                         第二种方式：a对象不为空，则a对象调用equals()方法与集合中已有元素比较
                                当a对象没有重写equals()方法时，默认调用从Object类中继承下来的，也是比较两个对象的地址
                                当a对象重写equals()时，调用自己重写后的equals()方法
            }
        * */
        b1 = c1.contains(new Person("zhangfei", 30));
        System.out.println("b1 = " + b1); //fasle  Person中没有重写equals()


        //5.判断当前集合中是否包含参数指定集合的所有元素
        Collection c3 = new ArrayList();
        c3.add(4);
        System.out.println("c3 = " + c3); //[4]
        //判断集合c1中是否包含集合c3中的所有元素，只有集合c3中的所有元素都在集合c1中出现才会返回true，否则都是false
        b1 = c1.containsAll(c3);
        System.out.println("b1 = " + b1); //true
        c3.add("five");
        System.out.println("c3 = " + c3); //[4, five]
        b1 = c1.containsAll(c3);
        System.out.println("b1 = " + b1); //false

        //笔试考点
        //注意containsAll()和contains()的区别
        System.out.println("c2 = " + c2); // [three, 4]
        //判断集合c1中是否拥有集合c2中的所有元素
        b1 = c1.containsAll(c2);
        System.out.println("b1 = " + b1); //true
        //判断集合c1中是否拥有集合c2这个整体为单位的元素
        b1 = c1.contains(c2);
        System.out.println("b1 = " + b1); //false

        //6.计算两个集合的交集并保留到当前集合中
        System.out.println("c2 = " + c2); // [three, 4]
        System.out.println("c3 = " + c3); //[4, five]
        //让集合自己与自己取交集，还是自己，也就是当前集合中的元素没有发生改变
        b1 = c2.retainAll(c2);
        System.out.println("b1 = " + b1); //false 表示当前集合中的元素没有发生改变
        System.out.println("c2 = " + c2); // [three, 4]
        //计算集合c2和c3的交集并保留到集合c2中，取代集合c2中原有的数值
        b1 = c2.retainAll(c3);
        System.out.println("b1 = " + b1); //true 表示当前集合中的元素发生改变
        System.out.println("c2 = " + c2); // [4]
        System.out.println("c3 = " + c3); //[4, five]

        //7.实现集合中单个元素的删除操作
        System.out.println("c1 = " + c1); //[one, 2, Person{name='zhangfei', age=30}, three, 4]
        b1 = c1.remove(1);
        System.out.println("b1 = " + b1); //false
        b1 = c1.remove("one");
        System.out.println("b1 = " + b1); //true
        System.out.println("c1 = " + c1); //[2, Person{name='zhangfei', age=30}, three, 4]
        //要先找到这个元素才能删除，所以也需要重写equals()方法
        b1 = c1.remove(new Person("zhangfei", 30));
        System.out.println("b1 = " + b1); //true
        System.out.println("c1 = " + c1); //[2, three, 4]

        //8.实现集合中所有元素的删除操作
        System.out.println("c3 = " + c3); //[4, five]
        //从集合c1中删除集合c3的所有元素，本质上就是一个一个元素进行删除，有元素则删除，否则不删除
        b1 = c1.removeAll(c3);
        System.out.println("b1 = " + b1); //true
        System.out.println("c1 = " + c1); //[2, three]
        System.out.println("c3 = " + c3); //[4, five]

        //9.实现集合中其他方法的测试
        System.out.println("集合中元素的个数为：" + c1.size()); //2
        System.out.println(0 == c1.size() ? "空" : "未空");  //未空
        System.out.println(c1.isEmpty() ? "空" : "未空"); //未空
        //清空集合中的所有元素
        c1.clear();
        System.out.println("集合中元素的个数为：" + c1.size()); // 0
        System.out.println(0 == c1.size() ? "空" : "未空");  //空
        System.out.println(c1.isEmpty() ? "空" : "未空");  //空

        //准备两个集合并判断是否相等
        Collection c4 = new ArrayList();
        c4.add(1);
        c4.add(2);
        System.out.println("c4 = " + c4);//[1, 2]
        System.out.println(c4.hashCode());
        Collection c5 = new ArrayList();
        c5.add(1);
        c5.add(2);
        System.out.println("c5 = " + c5); //[1, 2]
        System.out.println(c5.hashCode());
        //判断是否相等
        b1 = c4.equals(c5);
        System.out.println("b1 = " + b1); //true

        //10. 实现集合和数组类型直接的转换  通常认为：集合是用于取代数组的结构
        //集合 => 数组
        Object[] objects = c5.toArray();
        System.out.println(Arrays.toString(objects)); //[1, 2]
        //数组 => 集合
        Collection objects1 = Arrays.asList(objects);
        System.out.println(objects1); //[1, 2]

        //11.遍历集合中的元素
        //方式一：自动调用toString()方法 String类型的整体
        Iterator iterator1 = c5.iterator();
        //方式二：使用迭代器来遍历集合中的所有元素
        while (iterator1.hasNext()) {
            System.out.println("获取到的元素是：" + iterator1.next());
        }
        //方式三：使用for each结构实现集合和数组的遍历，是迭代器的简化版
        for (Object obj : c5) {
            System.out.println("获取到的元素是：" + obj);
        }

六、List集合

1.基本概念

• java.util.List集合是Collection集合的子集合，该集合中允许有重复的元素并且有先后放入次序
• 该集合的主要实现类有：ArrayList类、LinkedList类、Stack类、Vector类
• 其中ArrayList类的底层是采用动态数组进行数据管理的，支持下标访问，增删元素不方便
• 其中LinkedList类的底层是采用双向链表进行数据管理的，访问不方便，增删元素方便
• 可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别，ArrayList更适合于随机访问，而LinkedList更适合于插入和删除；在性能要求不是特别苛刻的情形下可以忽略这个差别
• 其中Stack类的底层是采用动态数组进行数据管理的，该类主要用于描述一种具有后进先出特征的
  数据结构，叫做栈(last in first out LIFO)
• 其中Vector类的底层是采用动态数组进行数据管理的，该类与ArrayList类相比属于线程安全的类，效率比较低，以后开发中基本不用

2.常用方法

方法声明	功能介绍
void add(int index, E element)	向集合中指定位置添加元素
boolean addAll(int index, Collection<? extends E> c)	向集合中添加所有元素
E get(int index)	从集合中获取指定位置元素
int indexOf(Object o)	查找参数指定的对象
int lastIndexOf(Object o)	反向查找参数指定的对象
E set(int index, E element)	修改指定位置的元素，返回被修改的元素
E remove(int index)	删除指定位置的元素，返回被删除的元素
List subList(int fromIndex, int toIndex)	用于获取子List

3.测试

		//1.声明一个List接口类型的引用，指向ArrayList类型的对象，形成了多态
        //由源码可知：当new对象时并没有申请数组的内存空间
        List lt1 = new ArrayList();
        //向集合中添加元素并打印
        //由源码可知：当调用add方法添加元素时会给数组申请长度为10的一维数组，扩容原理是：原始长度的1.5倍
        lt1.add("one");
        System.out.println("lt1 = " + lt1); //[one]


        //2.声明一个List接口类型的引用，指向LinkList类型的对象，形成了多态
        List lt2 = new ArrayList();
        lt2.add("one");
        System.out.println("lt2 = " + lt2); //[one]

        lt2.add("two");
        lt2.add("three");
        lt2.add("four");
        //3.使用remove方法将集合中的所有元素删除
        //第一种
//        for (int i = 0; i < lt2.size(); ) {
//            System.out.println("被删除的元素是：" + lt2.remove(0));
//        }
        //第二种
        /*for (int i = lt2.size() - 1; i >= 0; i--) {
            System.out.println("被删除的元素是：" + lt2.remove(i));
        }
        System.out.println("最终集合中的元素有：" + lt2);*/

        //4.获取当前集合中的子集合，也就是将集合中的一部分内容获取出来，子集合和当前集合共同使用一块内存空间
        //表示获取当前集合lt2中下标从1开始到3之间的元素，包含1但不包含3
        List list = lt2.subList(1, 3);
        System.out.println("list = " + list); //[two, three]
        System.out.println("删除后lt2 = " + lt2); //[one, two, three, four]
        System.out.println(list == lt2); //false
        //删除 list 中元素的数值
        String remove = (String) list.remove(0);
        System.out.println("删除的元素是：" + remove); // two
        System.out.println("删除后list = " + list); //[three]
        System.out.println("删除后lt2 = " + lt2); //[one, three, four]

七、Queue集合

1.基本概念

• java.util.Queue集合是Collection集合的子集合，与List集合属于平级关系
• 该集合的主要用于描述具有先进先出特征的数据结构，叫做队列(first in first out FIFO)
• 该集合的主要实现类是LinkedList类，因为该类在增删方面比较有优势

2.常用方法

方法声明	功能介绍
boolean offer(E e)	将一个对象添加至队尾，若添加成功则返回true
E poll()	从队首删除并返回删除元素
E peek()	返回队首的元素（但并不删除）

3.测试

		//1.准备一个Queue集合
        Queue queue = new LinkedList();
        System.out.println("queue = " + queue);
        //2.将数据11、22、33、44、55依次入队并打印
        for (int i = 1; i <= 5; i++) {
            boolean b1 = queue.offer(i * 11);
            System.out.println("队列中的元素有：" + queue);
        }
        //3.查看队首元素并打印
        System.out.println("队首的元素是：" + queue.peek());
        //4.将队列中所有数据依次出队并打印
        int len = queue.size();
        for (int i = 1; i <= len; i++) {
            System.out.println("出队的元素是：" + queue.poll());
        }
        //5.查看队列中最终的元素
        System.out.println("queue = " + queue);