集合
集合类体系结构
结构图.png
Collection集合概述和使用
- 是单例集合的顶层接口，它表示一组对象，这些对象也被称为Collection的元素
- JDK不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现
创建Collection集合的对象 - 多态的方式
- 具体的实现类ArrayList
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo01 {
public static void main(String[] args) {
// 创建Collection集合的对象
Collection<String> c = new ArrayList<String>();
// 添加元素：boolean add(E e)
c.add("hello");
c.add("world");
c.add("Java");
// 输出对象
System.out.println(c);
}
}
代码运行截图.png
Collection集合常用方法
| 方法名 | 说明 |
|---|---|
| boolean add(E e) | 添加元素 |
| boolean remove(Object o) | 从集合中移除指定的元素 |
| void clear() | 清空集合中的元素 |
| boolean contains(Object o) | 判断集合中是否存在指定的元素 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 集合的长度，也就是集合中元素的个数 |
小tips:
若要查询源码：按住Ctrl+B跟进，使用Alt+7，可以打开一个窗口，能够看到类的所有信息
public class CollectionDemo01 {
public static void main(String[] args) {
// 创建Collection集合的对象
Collection<String> c = new ArrayList<String>();
// 添加元素：boolean add(E e)
c.add("hello");
c.add("world");
c.add("Java");
// 输出对象
System.out.println(c.add("nihao"));
System.out.println(c);
System.out.println(c.size());
System.out.println(c.remove("world"));
System.out.println(c.remove("sss"));
System.out.println(c);
System.out.println(c.contains("hello"));
c.clear();
System.out.println(c); // []
System.out.println(c.isEmpty()); // true
}
}
Collection集合的遍历
Iterator:迭代器，集合的专用遍历方式
- Iterator<E> iterator(): 返回此集合中元素的迭代器，通过集合的iterator()方法得到
- 迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的
Iterator中的常用方法 - E next(): 返回迭代中的下一个元素
- boolean hasNext(): 如果迭代具有更多的元素，则返回true
public class IteratorDemo {
public static void main(String[] args) {
// 创建集合对象
Collection<String> c = new ArrayList<String>();
// 添加元素到集合
c.add("hello");
c.add("world");
c.add("java");
// 通过集合对象获取迭代器对象
Iterator<String> it = c.iterator();
/*
* public Iterator<E> iterator() {
return new Itr();
}
*
* private class Itr implements Iterator<E> {
* }
* */
/*
System.out.println(it.next());
System.out.println(it.next());
System.out.println(it.next());
System.out.println(it.next()); // NoSuchElementException :表示被请求的元素不存在。
*/
// 用while循环改进判断
while (it.hasNext()) { // 通过迭代器对象的hasNext()方法判断是否还有元素
// System.out.println(it.next());
String s = it.next(); // 通过迭代器对象的next()方法获取下一个元素
System.out.println(s);
}
}
}
代码运行结果.png
案例：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
定义一个学生类：
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo01 {
public static void main(String[] args) {
Collection<Student> c = new ArrayList<Student>();
Student s1 = new Student("张曼玉",30);
Student s2 = new Student("林青霞",36);
Student s3 = new Student("张敏",32);
// 把学生添加到集合
c.add(s1);
c.add(s2);
c.add(s3);
// 遍历集合(迭代器方式)
Iterator<Student> it = c.iterator();
while(it.hasNext()) {
Student s = it.next();
System.out.println(s.getAge()+","+s.getName());
}
}
}
代码运行结果.png
List集合概述和 特点
List集合概述
- 有序集合（也称为序列），用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。
- 与Set集合不同，列表通常允许重复的元素
List集合的特点
- 有序：存储和取出的元素顺序一致
- 可重复： 存储的元素可以重复
List集合的特有方法
| 方法名 | 说明 |
|---|---|
| void add(int index, E element) | 在此集合中的指定位置插入指定的元素 |
| E remove(int index) | 删除指定索引处的元素，返回被删除的元素 |
| E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |
| E get(int index) | 返回指定索引处的元素 |
演示如下：
public class ListDemo01 {
public static void main(String[] args) {
// 创建集合对象
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("Java");
// 输出集合对象
// System.out.println(list);
// 迭代器的方式遍历
list.add(2, "heima");
System.out.println(list);
System.out.println(list.remove(1));
System.out.println(list.set(2, "javaee"));
System.out.println(list.get(2));
System.out.println("-----");
// System.out.println(list);
// 遍历集合
// System.out.println(list.get(0));
// System.out.println(list.get(1));
// System.out.println(list.get(2));
// 用for循环改进
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}
}
}
代码运行截图.png
遍历集合的两种方式（迭代器方式，for循环方式）
for (int i = 0; i < list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getName()+","+s.getAge());
}
System.out.println("-------");
Iterator<Student> it = list.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName()+","+s.getAge());
}
并发修改异常
并发修改异常
- ConcurrentModificationException
产生原因 - 迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致
解决方案 - 用for循环遍历，然后用集合对象做对应的操作即可
ListIterator
listIterator:列表迭代器
- 通过list集合的listIterator()方法得到，所以说它是List集合特有的迭代器
- 用于允许程序员沿任一方向遍历列表的列表的迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置。 与Iterator迭代器（仅仅可以从前往后遍历）不同
ListIterator的常用方法
- E next() : 返回迭代中的下一个元素
- boolean hasNext() : 如果迭代具有更多元素，则返回true
- boolean hasPrevious() : 如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
- void add(E e) ： 将指定的元素插入列表
ListIterator<String> lit = list.listIterator();
while (lit.hasNext()) {
String s = lit.next();
if(s.equals("world")) {
lit.add("javase");
}
}
// 可以实现对列表的修改，避免出现并发修改异常
// 源码分析：
try {
int i = cursor;
ArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount; // 把实际修改集合的字数赋值给预期修改集合的字数
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
增强for循环
增强for:简化数组和Collection集合的遍历
- 实现Iterable接口的类允许其对象成为增强型for语句的目标
- 它是JDK5之后出现的，其内部原理是一个Iterator迭代器
增强for的格式：
- 格式：
for(元素数据类型 变量名:数组或者Collection集合) {
// 在此处使用变量即可，该变量就是元素
} - 范例：
int[] arr = {1,2,3,4,5};
for(int i : arr ) {
System.out.println(i);
}
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("timlony");
for (String s : list) {
System.out.println(s);
}
for (Student s : list) {
System.out.println(s.getName()+","+s.getAge());
}
| 集合循环方式 | 区别 |
|---|---|
| 迭代器 | 集合特有的遍历方式 |
| 普通for | 带有索引的遍历方式 |
| 增强for | 最方便的遍历方式 |
数据类型.png
数据结构（B站视频av61085712 ___P235-236）
定义：是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合
常见的数据结构之栈
数据进入栈模型的过程称为：压/进栈
数据离开栈模型的过程称为：弹/出栈
栈是一种数据先进后出的模型
常见的数据结构之队列
数据从后端进入队列模型的过程称为：入队列
数据从前端进入队列模型的过程称为：出队列
队列是一种数据先进先出的模型
常见的数据结构之数组
数组是一种查询快，增删慢的模型
查询数据通过索引定位，查询任意数据耗时相同，查询效率高
删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低
添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低
常见的数据结构之链表
链表中的每个元素称为结点，结点的存储位置（地址）应该包含 1. 存储具体的数据、2.下一个结点的地址。
链表是一种增删快的模型（对比数组）
链表是一种查询慢的模型（对比数组）：需要从头开始查询
List集合子类特点：
List集合常用子类：ArrayList,LinkedList
- ArrayList ： 底层数据结构是数组，查询快，增删慢
- LinkedList：底层数据结构是链表，查询慢，增删快
案例：使用ArrayList集合存储学生对象三种方式
public class ListDemo {
public static void main(String[] args) {
// 创建集合对象Arraylist
ArrayList<Student> array = new ArrayList<Student>();
Student s1 = new Student("林青霞", 32);
Student s2 = new Student("张曼玉", 32);
Student s3 = new Student("王祖贤", 31);
array.add(s1);
array.add(s2);
array.add(s3);
// 增强for:最方便的遍历方式
for (Student s : array) {
System.out.println(s.getName() + "," + s.getAge());
}
System.out.println("--------");
// 普通for:带有索引的遍历方式
for (int i = 0; i < array.size(); i++) {
Student s = array.get(i);
System.out.println(s.getName() + "," + s.getAge());
}
// 迭代器，集合特有的遍历方式
Iterator<Student> it = array.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "," + s.getAge());
}
System.out.println("--------");
}
}
LinkedList集合的特有功能
| 方法名 | 说明 |
|---|---|
| public void addFirst(E e) | 在该列表开头插入指定的元素 |
| public void addLast(E e) | 将指定的元素追加到此列表的末尾 |
| public E getFirst() | 返回此列表中的第一个元素 |
| public E getLast() | 返回此列表中的最后一个元素 |
| public E removeFirst() | 从此列表中删除并返回第一个元素 |
| public E removeLast() | 从此列表中删除并返回最后一个元素 |
