一、集合的概述
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 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
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 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));
// }
//第二种
//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);
