目录
思维导图
1 Collection
1.1 集合知识回顾
集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变
1.2 集合类体系结构
1.3 Collection 集合概述和使用
Collection集合概述
● 是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
● JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现
创建Collection集合对象
● 多态的方式
● 具体的实现类 ArrayList
示例代码：
public class test {
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);
}
}1.4 Collection 集合常用方法
补充：Alt + 7 可以打开一个 窗口，可以看到所有类的信息
示例代码：
public class Test_01 {
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");
//boolean remove(Object o):从集合中移除指定的元素
// System.out.println(c.remove("world"));
// System.out.println(c.remove("javaee"));
//void clear():清空集合中的元素
// c.clear();
//boolean contains(Object o):判断集合中是否存在指定的元素
// System.out.println(c.contains("world"));
// System.out.println(c.contains("javaee"));
//boolean isEmpty():判断集合是否为空
// System.out.println(c.isEmpty());
//int size():集合的长度，也是集合中元素的个数
System.out.println(c.size());
//输出集合
System.out.println(c);
}
}
1.5 Collection 集合的遍历
Iterator：迭代器，集合的专用遍历式
● Iterator<E> iterator() ：返回集合中元素的迭代器，通过集合的iterator()方法得到
● 迭代器是通过集合的iterator()方法得到的，所有我们说它是依赖于集合而存在的
Iterator中的常用方法
● E next()：判断集合中是否存在指定的元素
● boolean hasNext()：如果迭代具有更多元素。则返回true
示例代码：
public class Test_02 {
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");
Iterator<String> it = c.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
}
1.6 集合的使用步骤
案例：Collection 集合存储对象并遍历
需求：创建一个存储学生对象的集合，存储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;
}
}
//测试类
public class Test {
public static void main(String[] args) {
Collection<Student> students = new ArrayList<Student>();
Student s1 = new Student("jack",20);
Student s2 = new Student("mary",21);
Student s3 = new Student("jane",22);
students.add(s1);
students.add(s2);
students.add(s3);
Iterator<Student> s = students.iterator();
while(s.hasNext()){
Student student = s.next();
System.out.println(student.getName() + "," + student.getAge());
}
}
}
2 List
2.1 List集合的概述和特点
List集合概述
● 有序集合（也称为序列），用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
● 与Set集合不同，列表通常允许重复的元素
List集合特点
● 有序：存储和取出的元素顺序一致
● 可重复：
特点的示例代码：
public class Test {
public static void main(String[] args) {
List<String> ls = new ArrayList<String>();
ls.add("hello");
ls.add("world");
ls.add("java");
ls.add("world");
System.out.println(ls);
Iterator<String> it = ls.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
}
运行结果：
2.2 List集合特有方法
案例：List集合存储学生对象并遍历
需求：创建一个存储学生对象的集合，存储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;
}
}
//测试类
public class Test {
public static void main(String[] args) {
List<Student> students = new ArrayList<Student>();
Student s1 = new Student("jack",20);
Student s2 = new Student("mary",21);
Student s3 = new Student("jane",22);
students.add(s1);
students.add(s2);
students.add(s3);
//迭代器
System.out.println("-------------迭代器--------------");
Iterator<Student> it = students.iterator();
while (it.hasNext()){
Student student = it.next();
System.out.println(student.getName() + "," + student.getAge());
}
System.out.println("---------------------------------");
//for循环
for (int i = 0; i < students.size(); i++) {
Student s = students.get(i);
System.out.println(s.getName() + "," + s.getAge());
}
}
}
运行结果：
2.3 并发修改异常
出现原因：
迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际修改值不一致，则会出现：ConcurrentModificationException
解决办法：
用for循环遍历，然后用集合对象做对应的操作即可
示例代码：
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List<String> list = new ArrayList<String>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//遍历集合，得到每一个元素，看有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现
// Iterator<String> it = list.iterator();
// while (it.hasNext()) {
// String s = it.next();
// if(s.equals("world")) {
// list.add("javaee");
// }
// }
for(int i=0; i<list.size(); i++) {
String s = list.get(i);
if(s.equals("world")) {
list.add("javaee");
}
}
//输出集合对象
System.out.println(list);
}
}2.4 ListIterator
ListIterator：列表迭代器
● 通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
● 用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置
ListIterator中的常用方法
● E next()：返回迭代中的下一个元素
● boolean hasNext()：如果迭代具有更多元素，则返回true
● E previous()：返回列表中的上一元素
● boolean hasPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
● void add(E e)：将指定元素插入列表
2.5 增强for循环
增强for：简化数组和Collection集合的遍历
● 实现Iterator接口的类允许其对象成为增强型for语句的目标
● 它是JDK5之后出现的，其内部原理是一个Iterator迭代器
增强for的格式
● 格式
for(元素数据类型 变量名:数组或者Collection集合){
//在此使用变量即可，该变量就是元素
}案例：List集合存储学生对象用三种方式遍历
需求：创建一个存储学生对象的集合，存储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;
}
}
//测试类
public class Test {
public static void main(String[] args) {
List<Student> ls = new ArrayList<Student>();
Student s1 = new Student("jack", 20);
Student s2 = new Student("mary", 21);
Student s3 = new Student("jane", 22);
ls.add(s1);
ls.add(s2);
ls.add(s3);
//迭代器
System.out.println("-------------迭代器--------------------");
Iterator<Student> it = ls.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "," + s.getAge());
}
System.out.println("--------------------------------------");
System.out.println("-------------for循环--------------------");
for (int i = 0; i < ls.size(); i++) {
Student s = ls.get(i);
System.out.println(s.getName() + "," + s.getAge());
}
System.out.println("--------------------------------------");
System.out.println("----------------增强for------------------");
for (Student s : ls){
System.out.println(s.getName() + "," + s.getAge());
}
}
}
2.6 数据结构
数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或者多种特定关系的数据元素的集合
通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率
2.7 常见的数据结构之栈
栈是一种数据先进后出的模型
2.8 常见数据结构之队列
队列是一种数据先进先出的模型
2.9 常见的数据结构之数组
数组是一种查询快，增删慢的模型
查询数据通过索引定位，查询任意数据耗时相同，查询效率高
删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低
添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低
2.10 常见的数据结构之链表
链表是一种增删快的模型（对比数组）
链表是一种查询慢的模型（对比数字）
2.11 List集合子类特点
List集合常用子类：ArrayList，LinkedList
● ArrayList：底层数据结构是数组，查询快，增删慢
● LinkedList：底层数据结构是链表，查询慢，增删快
练习：
分别使用ArrayList和LinkedList完成存储字符串并遍历
示例代码：
public class Test {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>();
array.add("hello");
array.add("world");
array.add("java");
System.out.println("****************ArrayList****************");
System.out.println("----------增强for----------");
for (String s : array){
System.out.println(s);
}
System.out.println("----------迭代器-----------");
Iterator<String> it = array.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
System.out.println("----------for循环----------");
for (int i = 0; i < array.size(); i++) {
String s = array.get(i);
System.out.println(s);
}
System.out.println("******************************************");
LinkedList<String> linkedList = new LinkedList<String>();
linkedList.add("hello");
linkedList.add("world");
linkedList.add("java");
System.out.println("****************LinkedList****************");
System.out.println("----------增强for----------");
for (String s : linkedList){
System.out.println(s);
}
System.out.println("----------迭代器-----------");
Iterator<String> lit = linkedList.iterator();
while (lit.hasNext()){
String s = lit.next();
System.out.println(s);
}
System.out.println("----------for循环----------");
for (int i = 0; i < linkedList.size(); i++) {
String s = linkedList.get(i);
System.out.println(s);
}
System.out.println("******************************************");
}
}
案例：ArrayList集合存储学生对象用三种方式遍历
需求：创建一个存储学生对象的集合，存储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;
}
}
//测试类
public class Test {
public static void main(String[] args) {
ArrayList<Student> array = new ArrayList<Student>();
Student s1 = new Student("jack",10);
Student s2 = new Student("mary",11);
Student s3 = new Student("jane",12);
array.add(s1);
array.add(s2);
array.add(s3);
System.out.println("-------------迭代器----------------");
Iterator<Student> it = array.iterator();
while (it.hasNext()){
Student s = it.next();
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());
}
System.out.println("-------------增强for---------------");
for (Student s : array){
System.out.println(s.getName() + "," + s.getAge());
}
}
}
运行结果：
