Java集合框架(一)
什么是集合框架
Java语言的设计者对常用的数据结构和算法做了一些规范(接口)和实现(实现接口的类)。所有抽象出来的数据结构和操作(算法)统称为集合框架
集合与数组的区别
- 数组长度固定,集合长度不固定
- 数组可以存储基本类型和引用类型,集合只能存储引用类型
Collection体系
Collection 接口
特点:代表一组任意类型的对象,无序、无下标、不能重复。JDK不提供此接口的任何直接实现:它提供了更具体的子接口的实现,如Set和List 。
创建集合: Collection collection = new ArrayList();
(使用Collection 接口的 ArrayList 实现类来调用 Collection 的方法。)
Collection是 List 接口和 Set 接口的父接口,通常情况下不被直接使用。所以Collection 接口定义了一些通用的方法,通过这些方法可以实现对集合的基本操作。因为 List 接口和 Set 接口继承自 Collection 接口,所以也可以调用这些方法。
常用方法
方法 | 描述 |
---|---|
add(E e) | 向集合中添加一个元素,E指的是e元素的数据类型 |
int size() | 返回集合中元素的个数,也叫集合的大小 |
addAll(Collection c) | 向集合中添加集合 c 中的所有元素 |
remove(Object o) | 删除一个指定元素 |
removeAll(Collection c) | 删除指定集合中包含的所有此集合的元素 |
clear() | 清除所有元素 |
contains(Object o) | 判断集合中是否包含指定元素 |
containsAll(Collection c) | 判断集合中是否包含集合 c 中的所有元素 |
isEmpty() | 判断集合是否为空 |
retainAll(Collection c) | 仅保留集合 c 中出现的元素 |
Iterato < E >iterator() | 返回一个 Iterator 对象,用于遍历集合中的元素 |
Iterator接口(迭代器)
方法 | 描述 |
---|---|
boolean hasNext() | 如果迭代具有更多元素,则返回 true |
E next() | 返回迭代中的下一个元素 |
default void remove() | 从底层集合中删除此迭代器返回的最后一个元素(可选操作)。 |
add()方法、size()方法、addAll方法、remove()方法、removeAll()方法、clear()方法
【演示】
package com.gather.collection;
import java.util.ArrayList;
import java.util.Collection;
/*
add()方法、size()方法、addAll方法
remove()方法、removeAll()方法、clear()方法
*/
public class Demo01 {
public static void main(String[] args) {
Collection cet1 = new ArrayList();// 创建集合cet1
Collection cet2 = new ArrayList();// 创建集合cet2
cet1.add(1);// 向cet1中添加元素
cet1.add(2);
cet1.add(3);
cet1.add(4);
cet2.add(8);// 向cet2中添加元素
cet2.add(9);
System.out.println("cet1中元素个数="+cet1.size());// 返回集合的大小
System.out.println("cet1中的元素:"+cet1.toString());
cet2.addAll(cet1);// 将cet1中所有元素添加到cet2中
cet2.remove(3);// 删除集合cet2中的元素3
System.out.println("cet2中的元素:"+cet2.toString());
cet2.removeAll(cet1);// 删除cet2中包含的所有cet1中的元素
System.out.println("cet2删除c包含et1中元素的元素:"+cet2.toString());
cet2.clear();// 清除cet2中的所有元素
}
}
执行结果:
cet1中元素个数=4
cet1中的元素:[1, 2, 3, 4]
cet2中的元素:[8, 9, 1, 2, 4]
cet2删除c包含et1中元素的元素:[8, 9]
contains()方法、containsAll()方法、isEmpty()方法、retainAll()方法
【演示】
package com.gather.collection;
import java.util.ArrayList;
import java.util.Collection;
/*
contains()方法、containsAll()方法、isEmpty()方法、retainAll()方法
*/
public class Demo02 {
public static void main(String[] args) {
Collection cet1 = new ArrayList();// 创建集合cet1
Collection cet2 = new ArrayList();// 创建集合cet2
cet1.add(1);// 向cet1中添加元素
cet1.add(2);
cet1.add(3);
cet1.add(4);
cet2.add(8);// 向cet2中添加元素
cet2.add(9);
System.out.println(cet1.contains(2));// 判断cet1中是否包含2
System.out.println(cet2.containsAll(cet1));// 判断cet2中是否包含集合cet1中的所有元素
System.out.println(cet2.isEmpty());// 判断集合cet2是否为空
cet2.addAll(cet1);// 将cet1中所有元素添加到cet2中
cet2.retainAll(cet1);// cet2中仅保留cet1中所出现的元素
System.out.println(cet2.toString());
}
}
执行结果:
true
false
false
[1, 2, 3, 4]
集合中元素的遍历
【演示1】
package com.gather.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo04 {
public static void main(String[] args) {
Collection cet1 = new ArrayList();// 创建集合cet1
cet1.add(1);// 向cet1中添加元素
cet1.add(2);
cet1.add(8);
cet1.add(9);
System.out.println("cet1的元素个数:"+cet1.size());
/*
使用增强for循环遍历
*/
for (Object obj: cet1) {
Integer i = (Integer)obj;
System.out.println(i.toString());
}
/*
使用迭代器遍历
迭代过程中不能使用Collection的删除方法
haNext(); 有没有下一个元素
next(); 获取下一个元素
remove(); 删除当前元素
*/
Iterator it = cet1.iterator();
while (it.hasNext()) {
Integer i = (Integer)it.next();
System.out.println(i.toString());
it.remove();
//cet1.remove(1);迭代过程中不能使用Collection的删除方法:并发修改异常
}
System.out.println("删除后cet1的元素个数:"+cet1.size());
}
}
执行结果:
cet1的元素个数:4
1
2
8
9
1
2
8
9
删除后cet1的元素个数:0
【演示2】
package com.gather.collection;
public class Student {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student["+this.name+","+this.age+"]";
}
}
package com.gather.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo03 {
public static void main(String[] args) {
Student s1 = new Student("张三",18);
Student s2 = new Student("李四",20);
Student s3 = new Student("王五",15);
Collection c1 = new ArrayList();
c1.add(s1);// 添加学生对象
c1.add(s2);
c1.add(s3);
c1.add(s3);// ArrayList 实现类元素可重复
System.out.println("元素个数"+c1.size());
System.out.println(c1.toString());
/*
使用增强for循环遍历
*/
for (Object obj: c1) {
Student s = (Student)obj;
System.out.println(s.toString());
}
/*
使用迭代器遍历
迭代过程中不能使用Collection的删除方法
haNext(); 有没有下一个元素
next(); 获取下一个元素
remove(); 删除当前元素
*/
Iterator it = c1.iterator();
while (it.hasNext()) {
Student s = (Student)it.next();
System.out.println(s.toString());
it.remove();// Iterator类中的remove方法删除当前元素
}
System.out.println(c1.size());
}
}
执行结果:
元素个数4
[Student[张三,18], Student[李四,20], Student[王五,15], Student[王五,15]]
Student[张三,18]
Student[李四,20]
Student[王五,15]
Student[王五,15]
Student[张三,18]
Student[李四,20]
Student[王五,15]
Student[王五,15]
0
List接口
list接口是Collection接口的子类,其继承了Collection接口的所有方法,但也有其独有的方法。
List接口的特点:
- 它是一个元素存取有序的集合。
- 它是一个带有索引的集合,通过索引就可以精确的操作集合中的元素。
- 集合中可以有重复的元素,通过元素的equals方法,来比较是否为重复的元素
常用方法
方法 | 描述 |
---|---|
void add(int index,E element) | 将指定的元素插入此列表中的指定位置(可选操作) |
E get(int index) | 返回此列表中指定位置的元素 |
E remove(int index) | 从列表中删除指定元素的第一个出现(如果存在)(可选操作) |
E set(int index,E element) | 用指定的元素(可选操作)替换此列表中指定位置的元素 |
List subList(int fromIndex,int toIndex) | 返回此列表中指定的 fromIndex (含)和 toIndex之间的集合元素 |
ListIterator接口方法(列表迭代器)
ListIterator接口是Iterator接口的子类,继承了Iterator的所有方法。
ListIterator独有的方法
方法 | 描述 |
---|---|
void add(E e) | 将指定的元素插入列表(可选操作) |
boolean hasPrevious() | 返回 true如果遍历反向列表,列表迭代器有多个元素 |
int nextIndex() | 返回随后调用 next()返回的元素的索引 |
E previous() | 返回列表中的上一个元素,并向后移动光标位置 |
int previousIndex() | 返回由后续调用 previous()返回的元素的索引 |
void set(E e) | 用 指定的元素替换由 next()或 previous()返回的最后一个元素(可选操作 |
add()方法、get()方法、remove()方法、set()方法
【演示】
package com.gather.list;
import java.util.ArrayList;
import java.util.List;
public class Demo01 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("张三");
list.add("李四");
list.add("王五");
System.out.println("最初的元素列表" + list.toString());
list.add(0, "赵六");// 将"赵六"插入此列表第0位
System.out.println("指定位置添加后的元素列表" + list.toString());
System.out.println("第2位元素为:" + list.get(2));// 获取此列表第2位的元素
list.remove(3);// 删除此列表的第3位元素
System.out.println("删除后的元素列表" + list.toString());
list.set(0, "张三");// 用"张三"替换此列表第0位的元素(可以有重复的元素)
System.out.println("替换后的元素列表" + list.toString());
}
}
执行结果:
最初的元素列表[张三, 李四, 王五]
指定位置添加后的元素列表[赵六, 张三, 李四, 王五]
第2位元素为:李四
删除后的元素列表[赵六, 张三, 李四]
替换后的元素列表[张三, 张三, 李四]
集合中元素遍历
利用for循环遍历
package com.gather.list;
import java.util.ArrayList;
import java.util.List;
public class Demo02 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("小米");
list.add("华为");
list.add("苹果");
for (int i = 0; i < list.size(); i++) {
String str = (String) list.get(i);
System.out.println(str);
}
System.out.println("---------分隔--------");
for (Object obj : list) {
String str = (String) obj;
System.out.println(str);
}
}
}
执行结果:
小米
华为
苹果
---------分隔--------
小米
华为
苹果
利用迭代器遍历
package com.gather.list;
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "[" + this.name + "," + this.age + "]";
}
}
package com.gather.list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Demo03 {
public static void main(String[] args) {
Student s1 = new Student("小明", 12);
Student s2 = new Student("小红", 15);
Student s3 = new Student("小王", 10);
Student s4 = new Student("小亮", 8);
List list = new ArrayList();
list.add(s1);
list.add(s2);
list.add(0, s3);
list.add(0, s4);
/*
利用Iterator接口
*/
Iterator it = list.iterator();
System.out.println("---------Iterator遍历--------");
while (it.hasNext()) {
Student s = (Student) it.next();
System.out.println(s.toString());
}
/*
利用listIterator接口
*/
ListIterator lit = list.listIterator();
System.out.println("---------listIterator正序遍历--------");
while (lit.hasNext()) {// 正序遍历
int x = lit.nextIndex();// 返回随后调用 next()返回的元素的索引
Student s = (Student) lit.next();
System.out.println(x + "-->" + s.toString());
}
System.out.println("---------listIterator逆序遍历--------");
while (lit.hasPrevious()) {// 逆序遍历(上面正序遍历完之后,指针正好指向最后一个元素)
int y = lit.previousIndex();// 返回由后续调用 previous()返回的元素的索引
Student s = (Student) lit.previous();// 返回列表中的上一个元素,并向后移动光标位置
System.out.println(y + "-->" + s.toString());
}
}
}
执行结果:
---------Iterator遍历--------
[小亮,8]
[小王,10]
[小明,12]
[小红,15]
---------listIterator正序遍历--------
0-->[小亮,8]
1-->[小王,10]
2-->[小明,12]
3-->[小红,15]
---------listIterator逆序遍历--------
3-->[小红,15]
2-->[小明,12]
1-->[小王,10]
0-->[小亮,8]
集合添加数据(自动装箱)&subList()方法
package com.gather.list;
import java.util.ArrayList;
import java.util.List;
public class Demo04 {
public static void main(String[] args) {
List list = new ArrayList();
/*
添加数据类型:自动装箱
int----->----Integer
*/
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
System.out.println(list.toString());
list.remove(1);// 从列表中删除下标为1的元素(调用的是List接口中的方法:remove(int index))
System.out.println(list.toString());
list.remove((Object) 1);// 从列表中删除为1的元素(调用的是Collection接口中的方法:remove(Object o))
//list.remove(new Integer(1)); //从列表中删除为1的元素
System.out.println(list.toString());
List list2 = list.subList(1, 3);// 返回list列表中[1,3)的集合元素(含头不含尾)
System.out.println("list2:" + list2.toString());
}
}
执行结果:
[1, 2, 3, 4, 5, 6]
[1, 3, 4, 5, 6]
[3, 4, 5, 6]
list2:[4, 5]
List实现类
List接口一共有三个实现类:ArrayList、Vector和LinkedList
其中ArrayList和Vector都是利用数组这一个数据结构实现的,所以具有较强的随机访问能力,但是相应的,插入和删除的能力就比较弱:ArrayList和Vector要求实现所用的数组的元素之间是不能有间隔的,换言之就是如果你在中间删除了一个元素,后面的都必须向前移动来补位。数组在初始化的时候要约定一个大小,所以当插入的元素个数大于当前空间的最大大小时,就需要申请新的内存空间、创建新的数组并将现有数据拷贝过去(ArrayList在内存不够时默认是扩展1.5倍,Vector是默认扩展1倍)
LinkedList是利用链表实现的,那么相应的,它的增删代价比较小,但是随机访问的能力就弱了。
- ArrayList 【重点】
- 数组结构实现,必须要连续空间,查询快、增删慢
- jdk1.2版本,运行效率快、线程不安全
- Vector
- 数组结构实现,查询快、增删慢
- jdk1.0版本,运行效率慢、线程安全
- LinkedList
- 双向链表结构实现,无需连续空间,增删快,查询慢
ArrayList类
ArrayList是可以动态增长和缩减的索引序列,它是基于数组实现的List类
创建对象:ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();
常用方法
方法 | 描述 |
---|---|
boolean add(Object obj) | 将指定元素obj追加到集合的末尾 |
Object get(int index) | 返回集合中指定位置上的元素 |
int size() | 返回集合中的元素个数 |
boolean add(int index, Object obj) | 将指定元素obj插入到集合中指定的位置 |
Object remove(int index) | 从集合中删除指定index处的元素,返回该元素 |
void clear() | 清空集合中所有元素 |
Object set(int index, Object obj) | 用指定元素obj替代集合中指定位置上的元素 |
【演示】
package com.gather.arraylist;
import java.util.ArrayList;
public class Demo01 {
public static void main(String[] args) {
ArrayList arraylist = new ArrayList();
arraylist.add(10);
arraylist.add(20);
arraylist.add(30);
arraylist.add(0, 40);// 在第0位添加元素40
System.out.println("元素个数:" + arraylist.size());// 返回集合元素个数
System.out.println(arraylist);
System.out.println("第0位元素:" + arraylist.get(0));// 获取第0位元素
System.out.println("删除的元素为:" + arraylist.remove(2));// 删除第2位元素,并返回该元素
arraylist.set(1, 50);// 用50代替第1位元素
System.out.println(arraylist);
}
}
执行结果:
元素个数:4
[40, 10, 20, 30]
第0位元素:40
删除的元素为:20
[40, 50, 30]
重写equals()和hashCode()方法
package com.gather.arraylist;
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override// 重写equals方法
public boolean equals(Object o) {
if (this == o) {// 1,比较两个引用的对象是否为同一个
return true;
}
if (o == null) {// 2.判断该对象是否为null
return false;
}
if (this.getClass() != o.getClass()) {// 3.判断两个引用指向的实际对象类型是否一致,即new的类是否一致
return false;
}
if (o instanceof Student) {// 4.判断对象o是否是Student类的实例或者是Student类的子类实例
Student s = (Student) o;// 若不是Student类的实例,则强制转换
if (this.name == s.getName() && this.age == s.getAge()) {// 依次比较各个属性值是否相等
return true;
}
}
return false;
}
@Override// 重写hashCode方法
public int hashCode() {
int result = 17;
result = 31 * result + (this.name == null ? 0 : this.name.hashCode());
result = 31 * result + age;
return result;
}
@Override// 重写toString方法
public String toString() {
return "[" + this.name + "," + this.age + "]";
}
}
package com.gather.arraylist;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class Demo02 {
public static void main(String[] args) {
Student s1 = new Student("刘德华", 20);
Student s2 = new Student("郭富城", 23);
Student s3 = new Student("张学友", 18);
Student s4 = new Student("刘德华", 20);
ArrayList alt = new ArrayList();
alt.add(s1);
alt.add(s2);
alt.add(0, s3);
/*
s1和s4是不同的对象,但是它们的属性内容是一样的
重写了equals和hashCode方法后,其哈希值相等
*/
System.out.println(s1.equals(s4));
System.out.println(s1.hashCode());
System.out.println(s4.hashCode());
/*
使用Iterator迭代
*/
System.out.println("------Iterator------");
Iterator it = alt.iterator();
while (it.hasNext()) {
Student s = (Student) it.next();
System.out.println(s.toString());
}
alt.remove(new Student("张学友", 18));
/*
使用ListIterator迭代
*/
System.out.println("------ListIterator------");
ListIterator lit = alt.listIterator();
while (lit.hasNext()) {
Student s = (Student) lit.next();
System.out.println(s.toString());
}
}
}
执行结果:
true
650312502
650312502
------Iterator------
[张学友,18]
[刘德华,20]
[郭富城,23]
------ListIterator------
[刘德华,20]
[郭富城,23]
ArrayList内存分配
- 如果没有向集合中添加任何元素时,容量0
- 添加一个元素后,容量为10
- 当插入的元素个数大于当前空间的最大大小时,就需要申请新的内存空间、创建新的数组并将现有数据拷贝过去,容量为15
- 接着每次扩容是原来的1.5倍
Vector类
Vector类实现了可扩展的对象数组。 像数组一样,它包含可以使用整数索引访问的组件。 但是, Vector的大小可以根据需要增长或缩小,以适应在创建Vector之后添加和删除项目。
常用方法
方法 | 描述 |
---|---|
void addElement(Object obj) | 将obj插入向量的尾部 |
void setElementAt(Object obj,int index) | 将index处的对象设置成obj,原来的对象将被覆盖 |
void removeElement(Object obj) | 从向量中删除obj |
void removeElementAt(int index) | 删除index所指的地方的对象 |
void removeAllElement() | 删除向量所有的对象 |
public E firstElement() | 获取向量对象中的首个obj |
public E lastElement() | 获取向量对象的最后一个obj |
Enumeration接口
方法 | 描述 |
---|---|
boolean hasMoreElements() | 测试此枚举是否包含更多元素 |
E nextElement() | 如果此枚举对象至少有一个要提供的元素,则返回此枚举的下一个元素 |
addElement()方法、setElementAt()方法、removeElement()方法、removeElementAt()方法
【演示】
package com.gather.vecotr;
import java.util.Vector;
public class Demo01 {
public static void main(String[] args) {
Vector vector = new Vector();
Integer integer = new Integer(56);
vector.add(integer);// 在尾部添加56
vector.add(new Integer(10));// 在尾部添加10
vector.addElement(new Integer(20));// 在尾部添加20
vector.addElement(new Integer(30));// 在尾部添加30
vector.setElementAt(new Integer(88), 0);// 将第0位元素替换为88
vector.removeElement(integer);// 删除56
vector.removeElementAt(2);// 删除第2位元素
}
}
firstElement()方法、lastElement()方法
【演示】
package com.gather.vecotr;
import java.util.Vector;
public class Demo02 {
public static void main(String[] args) {
Vector vector = new Vector();
vector.add("张三");
vector.add("李四");
vector.add("王五");
System.out.println(vector.firstElement());// 返回第一个元素
System.out.println(vector.lastElement());// 返回最后一个元素
/*
回顾:contains()方法、clear()方法、isEmpty()方法
*/
System.out.println(vector.contains("张三"));
vector.clear();
System.out.println(vector.isEmpty());
}
}
执行结果:
张三
王五
true
true
集合元素遍历(Eunmeration)
Vector中元素也可用for循环,增强for,Iterator、ListIterator遍历
【补充方法】
public Enumeration elements(); 从索引 0 开始列举向量中所有元素。该方法返回一个列举( Enumeration )对象。
【演示】
package com.gather.vecotr;
import java.util.Enumeration;
import java.util.Vector;
public class Demo03 {
public static void main(String[] args) {
Vector vector = new Vector();
vector.addElement(new Character('A'));
vector.addElement('B');// 集合中添加数据会自动装箱
vector.addElement('C');
vector.addElement('D');
Enumeration enumeration = vector.elements();
while (enumeration.hasMoreElements()) {
Character c = (Character) enumeration.nextElement();
System.out.println(c);
}
}
}
执行结果:
A
B
C
D
LinkedList类
LinkedList也是List接口的实现类,与ArrayList不同之处是采用的存储结构不同,ArrayList的数据结构为线性表,而LinkedList数据结构是链表。链表数据结构的特点是每个元素分配的空间不必连续、插入和删除元素时速度非常快、但访问元素的速度较慢。
常用方法
方法 | 描述 |
---|---|
void addFirst(E e) | 在该列表开头插入指定的元素 |
void addLast(E e) | 将指定的元素追加到此列表的末尾 |
E getFirst() | 返回此列表中的第一个元素 |
E getLast() | 返回此列表中的最后一个元素 |
E removeFirst() | 从此列表中删除并返回第一个元素 |
E removeLast() | 从此列表中删除并返回最后一个元素 |
【演示】
package com.gather.linkedlist;
import java.util.LinkedList;
public class Demo01 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add("猪八戒");
linkedList.add(0, "孙悟空");
linkedList.addFirst("唐僧");// 在列表开头添加"唐僧"
linkedList.addLast("沙僧");// 在列表末尾添加"沙僧",与add()方法功能相同
System.out.println("第一个元素:"+linkedList.getFirst());
System.out.println("最后一个元素:"+linkedList.getLast());
System.out.println("删除第一个元素:"+linkedList.removeFirst());
System.out.println("删除最后一个元素:"+linkedList.removeLast());
}
}
执行结果:
第一个元素:唐僧
最后一个元素:沙僧
删除第一个元素:唐僧
删除最后一个元素:沙僧
集合元素遍历
package com.gather.linkedlist;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
public class Demo02 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add('B');
linkedList.add('C');
linkedList.addFirst('A');
linkedList.addLast('D');
/*
1.利用for循环遍历
*/
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
/*
2.利用增强for遍历
*/
for (Object o : linkedList) {
Character c = (Character) o;
System.out.println(c);
}
/*
3.利用Iterator迭代器遍历
*/
Iterator it = linkedList.iterator();
while (it.hasNext()) {
Character c = (Character) it.next();
System.out.println(c);
}
/*
4.利用ListIterator列表迭代器遍历
*/
ListIterator lit = linkedList.listIterator();
while (lit.hasNext()) {// 正序遍历
Character c = (Character) lit.next();
System.out.println(c);
}
while (lit.hasPrevious()) {// 逆序遍历(正序遍历结束后指针刚好指向最后一个元素)
Character c = (Character) lit.previous();
System.out.println(c);
}
}
}
ArryaList与LinkedList的区别
-
ArrayList:必须开辟连续空间,查询快,增删慢
Arraylist:底层是基于动态数组,根据下表随机访问数组元素的效率高,向数组尾部添加元素的效率高;但是,删除数组中的数据以及向数组中间添加数据效率低,因为需要移动数组。例如最坏的情况是删除第一个数组元素,则需要将第2至第n个数组元素各向前移动一位。而之所以称为动态数组,是因为Arraylist在数组元素若超过其容量,Arraylist可以进行扩容(针对JDK1.8 数组扩容后的容量是扩容前的1.5倍)
-
LinkedList:无需开辟连续空间,查询慢,增删快
Linkedlist基于链表的动态数组,数据添加删除效率高,只需要改变指针指向即可,但是访问数据的平均效率低,需要对链表进行遍历