一、为什么会出现集合类
1. 集合的特点集合的 长度是 可变的,数组的长度是固定的.
数组可以存储基本数据类型, 也能存储引用数据类型
int[]arr = new int[2];
String[]sArr = new String[2];
集合只能存储引用数据类型 , 如果要存储基本数据类型需要对应的包装类 !
2. 为什么要有集合
集合是一个类, 类中就会提供一些方法对数据的操作.
Person[]pArr = new Pseron[2];
pArr[0]= new Pereon(" 张三",23);
pArr[1]= new Person(" 李四",24);
list.contains(); // 判断容器中是否包含传入的对象
3. 集合和数组的区别
B. 存储: 数组能存基本数据类型, 也能存储引用数据类型, 但是集合只能存储引用数据类型.
二、集合类体系结构图
三、创建Collection集合对象并添加元素
为什么要先学习Collection?Collection作为根接口, 内部具备的方法子类都是存在的.
创建集合对象的时候,<>代表什么?
泛型: 对类, 方法, 接口进行限定.
注意: 泛型当中只能编写引用数据类型.
<E>: 泛型如果没有指定元素的话, 默认是Object
泛型的出现可以提高代码的 安全性 .
泛型格式的使用
类名<数据类型> 对象名 = new 类名<数据类型>();
举例 : Collection<String> c = newArrayList<String>();
jdk1.7 版本之后, =右侧的泛型可以省略不写,称之为菱形泛型.
举例 : Collection<String> c = newArrayList<>();
四、Collection集合的成员方法
boolean add(E e):添加元素boolean remove(Object o):从集合中移除元素
void clear():清空集合中的元素
boolean contains(Object o):判断集合中是否存在指定的元素
boolean isEmpty():判断集合是否为空
int size():集合的长度，也就是集合中元素的个数
注意: remove和contains方法底层依赖于equals方法 !!!
示例代码:
publicstatic void main(String[] args) {
//1. 创建集合对象, 容器中存储的是Person对象
Collection<Person>c = new ArrayList<>();
//2. 向集合中添加Person对象.
c.add(newPerson("张三",23));
c.add(newPerson("李四",24));
c.add(newPerson("王五",25));
//注意: 如果添加的元素是自定义对象的话, 那么没有重写toString, 将打印地址值
System.out.println(c);
//3. 调用集合的删除方法, 删除张三
//注意 : remove方法底层依赖于equals方法.
c.remove(newPerson("张三",23));
System.out.println(c);
//4. 调用集合中判断是否包含的方法
//注意 : contains方法底层依赖于equals方法.
System.out.println(c.contains(newPerson("李四",24)));
//5. 调用集合的清空方法
c.clear();
//6. 调用集合判断是否为空的方法
System.out.println(c.isEmpty());
//7. 打印集合的长度
System.out.println(c.size());
}五、Collection集合的遍历
使用迭代器遍历集合的步骤1. 获取迭代器
2. 使用hasNext方法循环判断是否还有元素
3. 使用next方法将元素取出.
示例代码:
publicstatic void main(String[] args) {
Collection<Person>c = new ArrayList<>();
c.add(newPerson("张三",23));
c.add(newPerson("李四",24));
c.add(newPerson("王五",25));
//1. 获取迭代器对象
Iterator<Person>it = c.iterator();
//2. 循环判断集合中是否还有元素
while(it.hasNext()){
//3. 获取元素
Personp = it.next();
System.out.println(p);
}
}六、Collection集合的练习存储自定义对象并遍历
需求: 定义一个标准的学生类, 创建三个学生对象存储到集合容器中, 并遍历集合.public class Student {
private String name;
private int age;
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "Student [name=" + name + ", 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 Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
}
import java.util.ArrayList;
import java.util.Collection;
public class Test_Collection2 {
public static void main(String[] args) {
Collection<Person> c = new ArrayList<>();
c.add(new Person("张三", 23));
c.add(new Person("李四", 24));
c.add(new Person("王五", 25));
System.out.println(c);
c.remove(new Person("张三", 23));
System.out.println(c);
System.out.println(c.contains(new Person("李四", 24)));
}
}
七、List集合的特点
List集合有什么特点?1. 存取有序
2. 有索引
3. 可以存储重复的.
八、集合的特有成员方法
void add(int index, E element) :将元素添加到index索引位置上E get(int index) :根据index索引获取元素
E remove(int index) :根据index索引删除元素
E set(int index, E element):将index索引位置的的元素设置为element
九、List集合的普通for循环遍历
import java.util.LinkedList;
import java.util.ListIterator;
public class Test03_LinkedList {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
ListIterator<String> lit = list.listIterator();
while(lit.hasNext()){
System.out.println(lit.next());
}
System.out.println("--------");
while(lit.hasPrevious()){
System.out.println(lit.previous());
}
}
}十、List集合的练习存储自定义对象并遍历
定义一个标准的学生类, 创建三个学生对象存储到集合容器中, 并遍历集合.1. 普通for循环
for(int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
2. 迭代器
普通迭代器
Iterator<Person>it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
ListIterator 特有的迭代器
ListIterator<Person>listIt = list.listIterator();
while(listIt.hasNext()){
System.out.println(listIt.next());
}
十一、列表迭代器的特有功能
方法摘要:1.booleanhasPrevious() : 判断集合是否还有上一个元素
2.Eprevious() : 获取集合中的上一个元素.
注意: 此迭代器只能用于List集合.
List<Person>list = new ArrayList<>();
list.add(newPerson(" 张三",23));
list.add(newPerson(" 李四",24));
list.add(newPerson(" 王五",25));
//1. 获取列表迭代器
ListIterator<Person>it = list.listIterator();
//2. 循环判断是否还有元素
while(it.hasNext()){
//3. 使用next方法获取元素
System.out.println(it.next());
}
System.out.println("----------------------");
while(it.hasPrevious()){
System.out.println(it.previous());
}
十二、并发修改异常产生的原因及解决方案
什么情况下会产生并发修改异常?当使用迭代器遍历集合的过程中, 使用集合自身的添加删除的方法就会产生并发修改异常
List<String>list = new ArrayList<>();
list.add("Java 基础语法");
list.add(" 面向对象");
list.add(" 集合");
list.add("IO");
ListIterator<String>it = list.listIterator();
while(it.hasNext()){
Strings = it.next();
if(" 集合".equals(s)){
list.add("Mysql"); // 产生的原因!!!
}
}
System.out.println(list);
如何解决?
不让使用集合的添加和删除的方法, 就使用迭代器自身的添加或删除的方法
List<String>list = new ArrayList<>();
list.add("Java 基础语法");
list.add(" 面向对象");
list.add(" 集合");
list.add("IO");
ListIterator<String>it = list.listIterator();
while(it.hasNext()){
Strings = it.next();
if(" 集合".equals(s)){
it.add("Mysql");
}
}
System.out.println(list);
细节:
ListIterator: 具备删除和添加的方法
Iterator : 只具备删除的方法.
扩展:
如果用集合的remove方法删除的是倒数第二个元素的时候, 则不会报出并发修改异常(了解)
原因: 略过了编译器的检查.
十三、增强for的概述和使用
增强for循环的格式是?for( 数据类型 变量名 : 要遍历的数组或集合){
}
fore alt + /
增强for循环底层依赖于什么技术实现?
十四、增强for的练习List集合存储自定义对象并遍历
public static voidmain(String[] args) {
List<Person>list = new ArrayList<>();
list.add(newPerson("张三",23));
list.add(newPerson("李四",24));
list.add(newPerson("王五",25));
for(Personp : list){
System.out.println(p);
}
}十五、常见数据结构之栈和队列
栈内存结构什么特点?
1: 先进后出 -> 手枪弹夹
队列内存结构什么特点?
十六、常见数据结构之数组和链表
数组采用该结构的集合，对元素的存取有如下的特点：
查找元素快：通过索引，可以快速访问指定位置的元素
增删元素慢 ,每次添加元素需要移动大量元素或这创建新的数组
数组结构: 查询快,修改快, 增删慢.
因为有索引, 所以查询和修改比较快.
增删慢是因为每一次的添加或删除都需要大批量的移动元素.
链表
采用该结构的集合，对元素的存取有如下的特点：
A: 多个节点之间，通过地址进行连接。
例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。
B: 查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
C: 增删元素快：
增加元素：只需要修改连接下个元素的地址即可。
删除元素：只需要修改连接下个元素的地址即可
链表结构: 查询慢, 修改慢, 增删快.
十七、List集合子类特点及ArrayList集合存储字符串并遍历
ArrayList集合的特点, 完成什么样的功能较为合适? -> 查询修改 ArrayList<String>list = new ArrayList<>();
list.add("abc");
list.add("111");
list.add("222");
list.add("333");
for(int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("-------------");
Iterator<String>it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("--------------------");
for(Strings : list){
System.out.println(s);
}十八、ArrayList集合的练习存储自定义对象并遍历
3种集合的迭代方式三种遍历是否能删除元素.
1. 迭代器: 可以删除, 但是在调用remove方法之前必须调用next方法
2. 普通for : 可以删除, 但是索引需要--
3. 增强for : 不能删, 因为会产生并发修改异常
案例演示LinkedList集合的使用.
publicstatic void main(String[] args) {
//底层是链表结构
LinkedList<String>list = new LinkedList<>();
//调用从Collection中继承下来的add方法添加元素
list.add("1");
list.add("2");
list.add("3");
//LinkedList特有的方法: 在头部添加元素
list.addFirst("4");
list.addFirst("5");
//LinkedList特有的方法: 在尾部添加元素
list.addLast("6");
//LinkedList特有的方法: 删除第一个元素
list.removeFirst();
//LinkedList特有的方法: 删除最后一个元素
list.removeLast();
System.out.println(list);
}1. 会查看要查找的元素, 离头近还是离尾近, 如果离头近, 就从头开始找, 反之, 就从尾开始找.
2. LinkedList虽然是链表结构, 但是底层也有索引 !
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
