注:本内容为个人拉勾教育大数据训练营学习课程笔记
五、集合类库(一)
5.1 集合的概述
集合由来
- 当需要在Java程序中记录单个数据内容时,则声明一个变量
- 当需要在Java程序中记录多个类型相同的数据内容时,声明一个一维数组
- 当需要在Java程序中记录多个类型不同的数据内容时,则创建一个对象
- 当需要在Java程序中记录多个类型相同的对象数据时,创建一个对象数组
- 当需要在Java程序中记录多个类型不同 的对象数据时,则准备一个集合
集合的框架架构
- Java中集合框架顶层框架是:java.util.Collection 集合 和 java.util.Map 集合
- 其中 Collection 集合中存取元素的基本单位是:单个元素(相当于Python中的列表)
- 其中 Map 集合中存取元素的基本单位是:单对元素(相当于Python中的字典)
注:集合中不支持基本数据类型,要用引用数据类型(基本数据类型的包装类)
5.2 Collection集合(重点)
基本概念
- java.util.Collection接口是 List 接口、Queue 接口以及 Set 接口的父接口,因此该接口里定义的方法既可用于操作List集合,也可用于操作Queue集合和Set集合
- 功能上是集合,类型上是接口
- java.util.Collection接口无法实例化对象,可以使用ArrayList等实现类,以多态方式来创建对象,如:
- Collection c1 = new ArrayList(); // 多态
常用方法
增加元素
方法声明 | 功能介绍 |
---|
boolean add(E e) | 向集合中添加对象(单个元素) |
boolean addAll(Collection<? extends E> c) | 用于将参数指定集合c中的所有元素添加到当前集合中 (多个元素) |
使用案例
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest {
public static void main(String[] args) {
Collection c1 = new ArrayList();
System.out.println("集合中的元素有:" + c1);
boolean b1 = c1.add(new String("one"));
System.out.println("b1 = " + b1);
System.out.println("集合中的元素有:" + c1);
b1 = c1.add(Integer.valueOf(2));
System.out.println("b1 = " + b1);
System.out.println("集合中的元素有:" + c1);
b1 = c1.add(new Person("LanceMai", 20));
System.out.println("b1 = " + b1);
System.out.println("集合中的元素有:" + c1);
Collection c2 = new ArrayList();
c2.add("three");
c2.add(4);
System.out.println("c2 = " + c2);
b1 = c1.addAll(c2);
System.out.println("b1 = " + b1);
System.out.println("c1 = " + c1);
}
}
判断是否包含元素
方法声明 | 功能介绍 |
---|
boolean contains(Object o) | 判断是否包含指定对象 |
boolean containsAll(Collection<?> c) | 判断是否包含参数指定的所有对象 |
使用案例
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class CollectionTest {
public static void main(String[] args) {
Collection c1 = new ArrayList();
List list = Arrays.asList("one", 2, new Person("LanceMai", 20), "three", 4);
c1.addAll(list);
b1 = c1.contains(new String("one"));
System.out.println("b1 = " + b1);
b1 = c1.contains(new String("two"));
System.out.println("b1 = " + b1);
b1 = c1.contains(Integer.valueOf(2));
System.out.println("b1 = " + b1);
b1 = c1.contains(Integer.valueOf(3));
System.out.println("b1 = " + b1);
b1 = c1.contains(new Person("zhangfei", 30));
System.out.println("b1 = " + b1);
System.out.println("---------------------------------------------");
System.out.println("c1 = " + c1);
Collection c3 = new ArrayList();
c3.add(4);
System.out.println("c3 = " + c3);
b1 = c1.containsAll(c3);
System.out.println("b1 = " + b1);
c3.add("five");
System.out.println("c3 = " + c3);
b1 = c1.containsAll(c3);
System.out.println("b1 = " + b1);
System.out.println("c2 = " + c2);
b1 = c1.containsAll(c2);
System.out.println("b1 = " + b1);
b1 = c1.contains(c2);
System.out.println("b1 = " + b1);
}
}
解析:28-29行代码
- contains方法的工作原理是:
- 调用**Objects.equals(o, e)**方法,其中o代表contains方法的形式参数,e代表集合中的每个元素,也就是contains的工作原理就是拿着参数对象与集合中已有的元素依次进行比较,比较的方式调用Objects中的equals方法
- 而该方法equals的工作原理如下:
- 当Person类中没有重写equals方法时,则调用从Object类中继承下来的equals方法,比较两个对象的地址 false
- 当Person类中重写equals方法后,则调用重写以后的版本,比较两个对象的内容 true
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
实现交集计算
方法声明 | 功能介绍 |
---|
boolean retainAll(Collection<?> c) | 保留当前集合中存在且参数集合中存在的所有对象 |
使用案例
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class CollectionTest {
public static void main(String[] args) {
Collection c2 = new ArrayList();
c2.add("three");
c2.add(4);
System.out.println("c2 = " + c2);
Collection c3 = new ArrayList();
c3.add(4);
c3.add("five");
System.out.println("c3 = " + c3);
System.out.println("c2 = " + c2);
System.out.println("c3 = " + c3);
b1 = c2.retainAll(c2);
System.out.println("b1 = " + b1);
System.out.println("c2 = " + c2);
b1 = c2.retainAll(c3);
System.out.println("b1 = " + b1);
System.out.println("c2 = " + c2);
System.out.println("c3 = " + c3);
}
}
删除元素
方法声明 | 功能介绍 |
---|
boolean remove(Object o) | 从集合中删除对象 |
boolean removeAll(Collection<?> c) | 从集合中删除参数指定的所有对象 |
使用案例
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class CollectionTest {
public static void main(String[] args) {
Collection c1 = new ArrayList();
List list = Arrays.asList("one", 2, new Person("LanceMai", 20), "three", 4);
c1.addAll(list);
Collection c3 = new ArrayList();
c3.add(4);
c3.add("five");
System.out.println("c1 = " + c1);
b1 = c1.remove(1);
System.out.println("b1 = " + b1);
System.out.println("c1 = " + c1);
b1 = c1.remove("one");
System.out.println("b1 = " + b1);
System.out.println("c1 = " + c1);
b1 = c1.remove(new Person("zhangfei", 30));
System.out.println("b1 = " + b1);
System.out.println("c1 = " + c1);
System.out.println("c3 = " + c3);
b1 = c1.removeAll(c3);
System.out.println("b1 = " + b1);
System.out.println("c1 = " + c1);
System.out.println("c3 = " + c3);
b1 = c1.remove(c3);
System.out.println("b1 = " + b1);
System.out.println("c1 = " + c1);
}
}
其他
方法声明 | 功能介绍 |
---|
void clear() | 清空集合 |
int size() | 返回包含对象的个数 |
boolean isEmpty() | 判断是否为空 |
boolean equals(Object o) | 判断是否相等 |
int hashCode() | 获取当前集合的哈希码值 |
Object[] toArray() | 将集合转换为数组 |
Iterator iterator() | 获取当前集合的迭代器 |
使用案例
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class CollectionTest {
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add(4);
c1.add("five");
System.out.println("集合中元素的个数为:" + c1.size());
System.out.println(0 == c1.size() ? "集合已经空了": "集合还没有空");
System.out.println(c1.isEmpty()? "集合已经空了": "集合还没有空");
c1.clear();
System.out.println("集合中元素的个数为:" + c1.size());
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);
Collection c5 = new ArrayList();
c5.add(1);
c5.add(2);
System.out.println("c5 = " + c5);
b1 = c4.equals(c5);
System.out.println("b1 = " + b1);
System.out.println("----------------------------------------------");
Object[] objects = c5.toArray();
System.out.println("数组中的元素有:" + Arrays.toString(objects));
Collection objects1 = Arrays.asList(objects);
System.out.println("集合中的元素有:" + objects1);
}
}
数组和集合间转换
方法声明 | 功能介绍 |
---|
Object[] toArray() | 将集合转换为数组 |
Iterator iterator() | 获取当前集合的迭代器 |
使用案例
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class CollectionTest {
public static void main(String[] args) {
Collection c5 = new ArrayList();
c5.add(1);
c5.add(2);
c5.add(3);
Object[] objects = c5.toArray();
System.out.println("数组中的元素有:" + Arrays.toString(objects));
Collection objects1 = Arrays.asList(objects);
System.out.println("集合中的元素有:" + objects1);
}
}
5.3 Iterator接口
基本概念
- java.util.Iterator接口主要用于描述迭代器对象,可以遍历Collection集合中的所有元素
- java.util.Collection接口继承Iterator接口,因此所有实现Collection接口的实现类都可以使用该迭代器对象。
常用方法
方法声明 | 功能介绍 |
---|
boolean hasNext() | 判断集合中是否有可以迭代/访问的元素 |
E next() | 用于取出一个元素并指向下一个元素 |
void remove() | 用于删除访问到的最后一个元素 |
使用案例
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
public class CollectionPrintTest {
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("one");
c1.add(2);
c1.add(new Person("zhangfei", 30));
System.out.println("c1 = " + c1);
Iterator iterator1 = c1.iterator();
while (iterator1.hasNext()) {
System.out.println("获取到的元素是:" + iterator1.next());
}
iterator1 = c1.iterator();
while (iterator1.hasNext()) {
Object obj = iterator1.next();
if("one".equals(obj)) {
iterator1.remove();
}
}
System.out.println("删除后集合中的元素有:" + c1);
}
}
注:当集合被迭代时,不允许修改
迭代器实现toString
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
public class CollectionPrintTest {
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("one");
c1.add(2);
c1.add(new Person("zhangfei", 30));
StringBuilder sb1 = new StringBuilder();
sb1.append("[");
while (iterator1.hasNext()) {
Object obj = iterator1.next();
if (!iterator1.hasNext()) {
sb1.append(obj).append("]");
} else {
sb1.append(obj).append(",").append(" ");
}
}
System.out.println("c1 = " + sb1);
}
}
5.4 for each循环(重点)
基本概念
- Java5推出了增强型for循环语句,可以应用数组和集合的遍历
- 是经典迭代的“简化版” (迭代器的简化版)
语法格式
for(元素类型 变量名 : 数组/集合名称) {
循环体;
}
123
执行流程
- 不断地从数组/集合中取出一个元素赋值给变量名并执行循环体,直到取完所有元素为止
使用案例
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
public class IteratorTest{
punlic static void main(String[] args){
Collection c1 = Arrays.asList("one", 1, "Person{name='zhangfei', age=30")
for (Object obj : c1) {
System.out.println("取出来的元素是:" + obj);
}
int[] arr = new int[]{1, 2, 3, 4, 5};
for (int i : arr) {
System.out.println("i = " + i);
i = 66;
}
System.out.println("数组中的元素有:" + Arrays.toString(arr));
}
}
5.5 List集合
基本概念
- java.util.List集合是Collection集合的子集合,该集合中允许有 重复的元素 并且有 先后放入次序
- 该集合的主要实现类有:ArrayList类、LinkedList类、Stack类、Vector类
- ArrayList类的底层是采用动态数组进行数据管理的,下标访问方便,增删元素不方便,动态扩容
- LinkedList类的底层是采用双向链表进行数据管理的,下标访问不方便,增删元素方便
- 可以认为ArrayList和LinkedList的方法在逻辑上完全一样,只是在性能上有一定的差别,ArrayList更适合于访问而LinkedList更适合于插入和删除;在性能要求不是特别苛刻的情形下可以忽略这个差别
- Stack类的底层是采用动态数组进行数据管理的,该类主要用于描述一种具有 后进先出 特征的数据结构,叫做栈 (last in first out LIFO)
- Vector类的底层是采用动态数组进行数据管理的,该类与ArrayList类相比属于线程安全的类,效率比较低,以后开发中基本不用
ArrayList类的解析
使用案例
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class ListTest {
public static void main(String[] args) {
List lt1 = new ArrayList();
lt1.add("one");
System.out.println("lt1 = " + lt1);
}
}
LinkedList类的解析
使用案例
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class ListTest {
public static void main(String[] args) {
List lt2 = new LinkedList();
lt2.add("one");
System.out.println("lt2 = " + lt2);
}
}
常用方法
方法声明 | 功能介绍 |
---|
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(和原集合共用一个空间) |
使用案例
import java.util.LinkedList;
import java.util.List;
public class ListMethodTest {
public static void main(String[] args) {
List lt1 = new LinkedList();
System.out.println("lt1 = " + lt1);
lt1.add(0, "one");
System.out.println("lt1 = " + lt1);
lt1.add(1, 3);
System.out.println("lt1 = " + lt1);
lt1.add(1, "two");
System.out.println("lt1 = " + lt1);
String str1 = (String) lt1.get(0);
System.out.println("获取到的元素是:" + str1);
StringBuilder sb1 = new StringBuilder();
sb1.append("[");
for (int i = 0; i < lt1.size(); i++) {
Object obj = lt1.get(i);
if (lt1.size()-1 == i) {
sb1.append(obj).append("]");
}
else {
sb1.append(obj).append(",").append(" ");
}
}
System.out.println("one第一次出现的索引位置为:" + lt1.indexOf("one"));
lt1.add("one");
System.out.println("lt1 = " + lt1);
System.out.println("one反向查找第一次出现的索引位置是:" + lt1.lastIndexOf("one"));
Integer it1 = (Integer) lt1.set(2, "three");
System.out.println("被修改的元素是:" + it1);
System.out.println("修改后集合中的元素有:" + lt1);
String str2 = (String) lt1.set(3, "four");
System.out.println("被修改的元素是:" + str2);
System.out.println("修改后集合中的元素有:" + lt1);
for (int i = lt1.size()-1; i >= 0; i--) {
System.out.println("被删除的元素是:" + lt1.remove(i));
}
System.out.println("最终集合中的元素有:" + lt1);
List lt2 = lt1.subList(1, 3);
System.out.println("lt2 = " + lt2);
str2 = (String) lt2.remove(0);
System.out.println("被删除的元素是:" + str2);
System.out.println("删除后lt2 = " + lt2);
System.out.println("删除后lt1 = " + lt1);
}
}
注意
- subList方法取得的子集合与当前集合共用同一块内存空间,既对子集合的元素的修改,会同步对当前集合元素的修改—参考上方代码74-82行
Stack类
- Stack类的底层是采用动态数组进行数据管理的,该类主要用于描述一种具有 后进先出 特征的数据结构,叫做栈 (last in first out LIFO)
常用方法
方法声明 | 功能介绍 |
---|
boolean empty() | 判断此栈是否为空 |
E peek() | 查看此栈顶元素,而不是将其从堆栈中删除 |
E pop() | 移除此堆栈顶部的对象,并将此对象作为返回值 |
E push() | 将项目推到此堆栈顶部 |
int search(Object o) | 返回对象在此堆栈上的从1开始的位置 |
案例题目
- 准备一个Stack集合,将数据11、22、33、44、55依次入栈并打印,然后查看栈顶元素并打印,然后将栈中所有数据依次出栈并打印。
- 再准备一个Stack对象,将数据从第一个栈中取出来放入第二个栈中,然后再从第二个栈中取出并打印
import java.util.Stack;
public class StackTest {
public static void main(String[] args) {
Stack s1 = new Stack();
Stack s2 = new Stack();
System.out.println("s1 = " + s1);
System.out.println("s2 = " + s2);
System.out.println("-----------------------------------------------");
for (int i = 1; i <= 5; i++) {
Object obj = s1.push(i * 11);
System.out.println("入栈的元素是:" + obj);
}
System.out.println("-----------------------------------------------");
System.out.println("-----------------------------------------------");
int len = s1.size();
for (int i = 1; i <= len; i++) {
Object to = s1.pop();
s2.push(to);
}
System.out.println("-----------------------------------------------");
System.out.println("-----------------------------------------------");
len = s2.size();
for (int i = 1; i <= len; i++) {
Object to = s2.pop();
System.out.println("出栈的元素是:" + to);
}
}
}
注:经过两次入栈和出栈(使用两个栈)后就是原始存储顺序,变成先进先出
5.6 Queue集合
基本概念
- java.util.Queue集合是Collection集合的子集合,与List集合属于平级关系
- 该集合的主要用于描述具有 先进先出 特征的数据结构,叫做队列(first in first out FIFO)
- 该集合的主要实现类是LinkedList类,因为该类在增删方面比较有优势
常用方法
方法声明 | 功能介绍 |
---|
boolean offer(E e) | 将一个对象添加至队尾,若添加成功则返回true |
E poll() | 从队首删除并返回一个元素 |
E peek() | 返回队首的元素(但并不删除) |
使用案例
import java.util.LinkedList;
import java.util.Queue;
public class QueueTest {
public static void main(String[] args) {
Queue queue = new LinkedList();
System.out.println("队列中的元素有:" + queue);
System.out.println("-----------------------------------------------");
for (int i = 1; i <= 5; i++) {
boolean b1 = queue.offer(i * 11);
System.out.println("队列中的元素有:" + queue);
}
System.out.println("------------------------------------------------");
System.out.println("对首元素是:" + queue.peek());
System.out.println("------------------------------------------------");
int len = queue.size();
for (int i = 1; i <= len; i++) {
System.out.println("出队的元素是:" + queue.poll());
}
System.out.println("-------------------------------------------------");
System.out.println("队列中的元素有:" + queue);
}
}
注:本内容为个人拉勾教育大数据训练营学习课程笔记