集合
1. 概念
- 集合提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变;
2. 分类
- 集合按照存储的数据不同,可以分为单列集合和双列集合;
3. 体系结构
Collection
1. 概念
- 是单列集合的顶层接口,它表示一组对象，这些对象也称为Collection的元素;
- JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现;
2. 结构
- 子接口: List
- 实现类:ArrayList;
- 实现类:LinkedList;
- 子接口:Set
- 实现类:HashSet;
- 实现类:LinkedHashSet;
3. 常用方法
- boolean add(E e) 添加元素
- boolean addAll(Collection<? extends E> c) 将指定 collection 中的所有元素都添加到此 collection 中
- boolean remove(Object o) 从集合中移除指定的元素
- void clear() 移除此 collection 中的所有元素
- boolean contains(Object o) 判断集合中是否存在指定的元素
- boolean isEmpty() 判断集合是否为空
- int size() 集合的长度，也就是集合中元素的个数
- iterator() 返回在此 collection 的元素上进行迭代的迭代器
4. Iterator迭代器
①: 介绍
- 操作集合的通用方式,可以通过迭代器对象逐个获取集合中的元素;
② 获取方式
- 通过集合的iterator()方法得到
③ 使用方式
public class IteratorDemo {
public static void main(String[] args) {
//创建集合对象
Collection<String> c = new ArrayList<>();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
c.add("javaee");
//Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
Iterator<String> it = c.iterator();
//用while循环进行元素的判断和获取
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
}
}
注意: 在迭代器迭代集合的过程中,不能使用集合自身的方法改变集合的长度;
List
1. 概述
- 有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
- 与Set集合不同，列表通常允许重复的元素
2. 特点
- 有索引
- 可以存储重复元素
- 元素存取有序
3. 特有方法
- void add(int index,E element) 在此集合中的指定位置插入指定的元素
- E remove(int index) 删除指定索引处的元素，返回被删除的元素
- E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
- E get(int index) 返回指定索引处的元素
4. 案例
- 创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
// 学生类
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;
}
}
// 测试类
public class ListDemo {
public static void main(String[] args) {
//创建List集合对象
List<Student> list = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("张曼玉", 35);
Student s3 = new Student("王祖贤", 33);
//把学生添加到集合
list.add(s1);
list.add(s2);
list.add(s3);
//迭代器方式
Iterator<Student> it = list.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "," + s.getAge());
}
System.out.println("--------");
//for循环方式
for(int i=0; i<list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getName() + "," + s.getAge());
}
}
}
5. 并发修改异常(ConcurrentModificationException)
① 出现的原因
- 迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际修改值不一致，则会出现：ConcurrentModificationException
② 解决方案
- 用for循环遍历，然后用集合对象做对应的操作即可;
6. ListIterator
① 介绍
- 通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
- 用于允许程序员沿任一方向遍历的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置
② 代码演示
public class ListIteratorDemo {
public static void main(String[] args) {
//创建集合对象
List<String> list = new ArrayList<String>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//获取列表迭代器
ListIterator<String> lit = list.listIterator();
while (lit.hasNext()) {
String s = lit.next();
if(s.equals("world")) {
lit.add("javaee");
}
}
System.out.println(list);
}
}
7. 增强for循环
① 定义格式
for(元素数据类型 变量名 : 数组/集合对象名) {
循环体;
}
② 示例
public class ForDemo {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
for(int i : arr) {
System.out.println(i);
}
System.out.println("--------");
String[] strArray = {"hello","world","java"};
for(String s : strArray) {
System.out.println(s);
}
System.out.println("--------");
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java");
for(String s : list) {
System.out.println(s);
}
//内部原理是一个Iterator迭代器
}
}
8. 数据结构
① 栈结构
- 先进后出
② 队列结构
- 先进先出
③ 数组结构
- 查询快、增删慢
④ 链表结构
- 查询慢、增删快
9. List集合的实现类
① 子类的特点
-
ArrayList集合(详见"Java基础复习_day07_ArrayList集合")
底层是数组结构实现，查询快、增删慢 -
LinkedList集合
底层是链表结构实现，查询慢、增删快
② LinkedList集合的特有功能
- public void addFirst(E e) 在该列表开头插入指定的元素
- public void addLast(E e) 将指定的元素追加到此列表的末尾
- public E getFirst() 返回此列表中的第一个元素
- public E getLast() 返回此列表中的最后一个元素
- public E removeFirst() 从此列表中删除并返回第一个元素
- public E removeLast() 从此列表中删除并返回最后一个元素
Set
1. 概念
- set集合是一种存储不重复元素的集合;
2. 特点
- 元素存取无序
- 没有索引、只能通过迭代器或增强for循环遍历
- 不能存储重复元素
3. 常用实现类
① HashSet
② TreeSet
③ LinkedHashSet
4. HashSet
① 特点
- 底层数据结构是哈希表
- 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
- 没有带索引的方法，所以不能使用普通for循环遍历
- 由于是Set集合，所以是不包含重复元素的集合
② 代码示例
public class HashSetDemo01 {
public static void main(String[] args) {
//创建集合对象
HashSet<String> hs = new HashSet<String>();
//添加元素
hs.add("hello");
hs.add("world");
hs.add("java");
hs.add("world");
//遍历
for(String s : hs) {
System.out.println(s);
}
}
}
运行结果:
③ HashSet集合保证元素唯一性的图解
注意: Hashset集合判断元素唯一性, 依赖hashCode方法和equals方法共同作用,缺一不可!!!
5. LinkedHashSet
① 特点
- 哈希表和链表实现的Set接口，具有可预测的迭代次序
- 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
- 由哈希表保证元素唯一，也就是说没有重复的元素
② 代码示例
public class LinkedHashSetDemo {
public static void main(String[] args) {
//创建集合对象
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
//添加元素
linkedHashSet.add("hello");
linkedHashSet.add("world");
linkedHashSet.add("java");
linkedHashSet.add("world");
//遍历集合
for(String s : linkedHashSet) {
System.out.println(s);
}
}
}
运行结果:
6. TreeSet
① 概述
- 元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法
- TreeSet()：根据其元素的自然排序进行排序
- TreeSet(Comparator comparator) ：根据指定的比较器进行排序
- 没有带索引的方法，所以不能使用普通for循环遍历
- 由于是Set集合，所以不包含重复元素的集合
② 代码示例
public class TreeSetDemo01 {
public static void main(String[] args) {
//创建集合对象
TreeSet<Integer> ts = new TreeSet<Integer>();
//添加元素
ts.add(10);
ts.add(40);
ts.add(30);
ts.add(50);
ts.add(20);
ts.add(30);
// 输出集合对象
System.out.println(ts);// [10, 20, 30, 40, 50]
}
}
③ 比较器排序Comparator的使用
- 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
// 学生类
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
// 测试类
public class Test {
public static void main(String[] args) {
// 创建treeSet集合对象, 比较器方式排序
TreeSet<Student> students = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
// 比较规则
// 1. 按照年龄从小到大排序
int res = s1.getAge()-s2.getAge();
// 2. 如果年龄相同,按照姓名的字母顺序排序
res = res == 0 ? s2.getName().compareTo(s1.getName()) : res;
return res;
}
});
// 向集合中添加元素
students.add(new Student("张无忌", 25));
students.add(new Student("赵敏", 19));
students.add(new Student("周芷若", 20));
students.add(new Student("郭靖", 40));
students.add(new Student("黄蓉", 22));
students.add(new Student("赵敏", 22));
// 遍历集合, 输出元素
for (Student s : students) {
System.out.println(s);
}
}
}
运行结果:
