数据结构、集合概述、集合框架中的接口
数据结构
线性表
(数组)存储区间是连续的,占用内存严重,故空间复杂度很大。但数组的二分查找(前提是必须有序)时间复杂度小,为O(1);
数组的特点是:
- 寻址容易(arr[n]=arr[0]+n*每个元素的长度,时间复杂度为O(1))
- 插入和删除困难(可能会引发一半以上的数据元素移动,时间复杂度为O(n));
- Java中的数组是定长的,如果需要变长则需要自行编程实现
链表
存储区间离散(数据不是连续存放的),占用内存比较宽松,故空间复杂度很小,但操作元素的时间复杂度很大,达O(N)。
链表的特点是:
- 寻址困难(可能需要通过遍历的方式查找元素,时间复杂度为O(n))
- 插入和删除容易(不需要引发元素的移动,仅仅只是进行地址的拷贝,时间复杂度为O(1))。
概述集合
- 集合只能存放对象。比如你存一个 int 型数据 1放入集合中,其实它是自动转换成 Integer 类后存入的(装箱操作),Java中每一种基本类型都有对应的引用类型
- 集合存放的是多个对象的引用,对象本身还是放在堆内存中
- 集合可以存放不同类型,不限数量的数据类型。定义集合变量时如果不指定数据类型,则默认数据类型为Object
数组和集合的比较
针对Java中的数组定长,Java提出了集合框架,实现了一种变长存储数据的容器—集合【容积和当前元素个数】
数组不是面向对象的,存在明显的缺陷,集合弥补了数组的缺点,比数组更灵活更实用,而且不同的集合框架类可适用不同场合。如下:
- 数组能存放基本数据类型和对象,而集合类存放的都是对象的引用,而非对象本身
- 数组容量固定无法动态改变,集合类容量动态改变
- 数组无法判断其中实际存有多少元素,length只告诉了数组的容量,而集合的size()可以确切知道元素的个数
- 集合有多种实现方式和不同适用场合,不像数组仅采用顺序表方式
- 集合以类的形式存在,具有封装、继承、多态等类的特性,通过简单的方法和属性即可实现各种复杂操作,大大提高了软件的开发效率
集合框架中的接口
Collection接口
- 顶级接口,继承Iterable接口
- 无序、允许重复
常见方法
- size():int获取元素个数
- contains(Object):boolean 判断集合中是否有指定对象
- 使用的是equals方法进行判断,不是==
- toArray():Object[] 将集合中的所有元素以数组方式进行返回
- add(Object):boolean 向集合中添加元素
- remove(Object):boolean 从集合中删除指定的元素
- 使用的是equals方法进行判断,不是==
- clear():void 删除集合中的所有元素,清空集合
- isEmpty():boolean 判断元素个数是否为0,不判断null
- list.size()<1
Iterator迭代器
用于遍历集合中的所有元素
- Collection接口继承于Iterable接口,所以所有的Collection接口的实现类都可以进行遍历访问
- Iterator it=list.iterator();
- while(it.hasNext()){ //判断是否还有没有遍历访问的元素
- Object tmp=it.next(); //指针后移,同时获取一个元素
- }
如何获取迭代器
list.iterator():Iterator 具体的迭代器一般是由实现类提供具体的实现
List接口
List接口是Collection接口的子接口
有序、允许重复
注意:凡是使用下标参数的,要求下标必须在[0,list.size())
-
E get(int index);按照下标获取指定位置上的元素,index就是下标值,要求index的值不能超过[0,list.size()),否则IndexOutOfBoundsException
-
E set(int index, E element) 修改指定位置index上的元素为新元素element,并返回原始位置上的元素 修改操作
-
void add(int index, E element) 在指定位置index上添加新元素element
-
E remove(int index)删除指定下标index位置上的元素,并返回删除的元素
-
int indexOf(Object o) 从前向后查找o在集合中的第一个下标位置,如果查找不到则返回-1
-
int lastIndexOf(Object o);
-
default void sort(Comparator<? super E> c) 使用自定义的比较器对象对数据元素进行排序,按照升序进行排序
Set接口
Set接口是Collection接口的子接口
无序、不允许重复[重复元素的添加会产生覆盖]
没有新方法
boolean add(E e);向集合中追加元素e对象,如果出现重复则后盖前
问题:如何判断两个元素相等
- 首先比较两个对象的hashcode值是否相等,如果hashcode值不相等则不会调用equals,认为两个对象不相等
- 如果hashcode值相等才调用equals进行比较,否则不相等
潜规则【不是语法】:SUN要求当两个对象的equals为true时,hashcode值应该相等
常见的List接口的实现类
- ArrayList:数组实现,查询快,增删慢,轻量级;(线程不安全)
- LinkedList:双向链表实现,增删快,查询慢 (线程不安全)
- Vector:数组实现,重量级 (线程安全、使用少)
ArrayList实现类
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
内部实现
transient Object[] elementData; 用于存储数据,体现ArrayList采用的是数组的方式提供实现
构造器
//new ArrayList(1000);
public ArrayList(int initialCapacity) { //参数是初始化容积
if (initialCapacity > 0) { 如果容积初始值大于0则创建对应的对象
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) { 如果容积值位0则创建一个空数组
this.elementData = EMPTY_ELEMENTDATA;
} else { 如果小于0则抛出一个运行时异常
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
}
}
//new ArrayList();
public ArrayList() { 没有初始化参数值,则自动创建一个0个长的空数组
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
add方法的实现
//向存储数据的elementData添加新元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); //确保内部容量,处理数组elementData的长度,确保可以存放数据,如果当前数组长度不足,则需要增加数组长度。参数的含义是满足条件的最小容积
elementData[size++] = e;
return true; //如果添加过程中不出异常,则返回一定是true
}
ensureCapacityInternal方法
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++; //修改次数加1
if (minCapacity - elementData.length > 0) 如果所需要的最小容积大于实际存储数据的数组长度,则需要进行扩容处理
grow(minCapacity);
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length; 获取实际数组的长度
//符号>>表示二进制向右移位计算,>>1表示除以2,>>2表示除以4(2的平方).如果<<表示乘以2的多少次方
int newCapacity = oldCapacity + (oldCapacity >> 1); //新的容积值=旧有容器*1.5
if (newCapacity - minCapacity < 0) 新容器如果小于所需要的最小容积,则新容积为最小容积值
newCapacity = minCapacity;
//int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
if (newCapacity - MAX_ARRAY_SIZE > 0) 如果新容积值大于所允许的最大容积值
newCapacity = hugeCapacity(minCapacity); 获取满足最小容积需求的合法的容积值
//从elementData拷贝所有的数组元素,Arrays是工具类,提供了常见的针对数组的操作方法
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) 如果最小容积值小于0则抛出错误,表示OOM内存溢出
throw new OutOfMemoryError();
//例如获取的最小容积值为Integer.MAX_VALUE-7
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
+
add方法用于向集合中添加元素,如果ArrayList中真正存放数据的数组长度不足,则新建一个数组,新数组的长度为原始长度1.5倍,并拷贝原始数组中的数据到新数组中,最后再追加新元素
remove方法的实现
和Vector实现一致
结论:使用数组元素移动的方式实现元素的删除
注意:这里没有变小容积
修改元素个数时会有modCount的修改–快速失败
get方法的实现
public E get(int index) {
rangeCheck(index); //针对索引值进行合法性验证,如果有问题则报异常
return elementData(index);
}
E elementData(int index) {
return (E) elementData[index];
}
结论:首先要求index应该在[0,size-1]的范围内,否则异常
如果index正确则按照下标从数组中获取元素
Vector
类定义
属于老版本提供的,从1.0,而ArrayList比较新,从1.2。属于线程安全的类,大部分方法上都有synchronized,一般用于要求线程安全的属性定义
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable,
java.io.Serializable
数据存储
protected Object[] elementData; 采用也是数组的方式存储数据
构造器方法
public Vector() {
this(10); //表示调用当前类的其它构造器,初始化容积为10,增长的步长值为0
}
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
public Vector(int initialCapacity, int capacityIncrement) { //参数1是初始化容积,参数2是容
积增长的步长值
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
this.elementData = new Object[initialCapacity];//按照初始化容积值构建对应的数组
this.capacityIncrement = capacityIncrement;
}
add新增元素的方法实现
public synchronized boolean add(E e) {//线程安全的方法
modCount++; //修改次数+1
ensureCapacityHelper(elementCount + 1); //处理容积
elementData[elementCount++] = e; //在数组中存储元素
return true;
}
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0) //需要储存的数据超出数组可以存放的数据格
式,则需要进行增长
grow(minCapacity);
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length; //当前数组的长度,也就是可以存放的元素个数
int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement :
oldCapacity); //新长度为原始长度的2倍或者原始长度+步长值
if (newCapacity - minCapacity < 0) //如果新长度不满足最小长度要求,则新长度为最小要
求的长度
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) //如果新长度大于最大数组长度进行长度处理
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity); //将原始数组中的数据拷贝到新
数组中,并替换原始数组
}
private static int hugeCapacity(int minCapacity) { //和ArrayList处理一致
if (minCapacity < 0) //OOM 内存溢出
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
- 方法同步
- 增长为2倍
- 无参数创建时是10个长的数组
删除元素的方法remove(Object)
public boolean remove(Object o) {
return removeElement(o);
}
public synchronized boolean removeElement(Object obj) {
modCount++;
int i = indexOf(obj); //查找元素的索引值
if (i >= 0) {
removeElementAt(i); //按照索引删除指定元素
return true;
}
return false;
}
public synchronized void removeElementAt(int index) {
modCount++;
//针对index索引值进行合法性验证
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
} else if (index < 0) {
throw new ArrayIndexOutOfBoundsException(index);
}
int j = elementCount - index - 1; //获取需要移动的元素个数
if (j > 0) { //通过拷贝的方式将数据的后续移动元素向前移动一位
System.arraycopy(elementData, index + 1, elementData, index, j);
}
elementCount--; //元素个数-1
elementData[elementCount] = null; //将数组末尾的元素值赋null
}
LinkedList
类定义
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>,
Cloneable, java.io.Serializable
//Deque是队列接口,提供一个双端队列的访问方法实现
底层实现为双向链表
private static class Node<E> { //节点定义
E item; //具体存储的数据
Node<E> next; //向后的指针
Node<E> prev; //向前的指针
}
LinkedList类中的数据存储
transient Node<E> first; //头指针,指向链表的第一个元素
transient Node<E> last; //尾指针,指向链表的最后一个元素
对应的构造器
public LinkedList() { //没有初始化容积
}
add方法中
- 创建Node对象,其中包含需要添加的元素值
- Node对象的next为null
- prev指向last
- last对象的next为新建对象Node
- last指向新建的Node对象
List总结
ArrayList | LinkedList | Vector | |
---|---|---|---|
实现方式 | 数组,按照索引下标访问速度快O(1),但是当删除、添加元素时会导致元素的移动,速度慢O(n) | 双向链表,按照索引下标访问速度慢O(n),但是删除添加元素速度快O(1) | 数组,按照索引下标访问速度快O(1),但是当删除添加元素时会导致元素的移动,速度慢O(n) |
是否同步 | 不同步,线程不安全,但是并发高,访问效率高 | 不同步,线程不安全,但是并发高,访问效率高 | 同步,所以线程安全,但是并发低,访问效率低 |
如何选择 | 经常需要快速访问,较少在中间增加删除元素时使用;如果多线程访问,则需要自行编程解决线程安全问题 | 经常需要在内部增删元,但是很少需要通过索引快速访问时使用;如果多线程访问,则需要自行编程解决线程安全问题 | 一般不使用,如果在多线程访问时可以考虑使用 |
修改同时并发迭代访问的问题
需求:一个线程使用Iterator迭代访问集合中的元素,另外一个线程修改集合中的元素。临界资源为集合
public class T4 {
public static void main(String[] args)throws Exception {
List list = new ArrayList();
for(int i=0;i<5;i++)
list.add(i);
new Thread(()->{
System.out.println(Thread.currentThread().getName()+",begin....");
Iterator it=list.iterator();
while(it.hasNext()) {
Object tmp=it.next();
System.out.println(tmp);
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+",end....");
}).start();
Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+",begin modify....");
list.remove(0);
System.out.println(Thread.currentThread().getName()+",end modify....");
}
}
ConcurrentModicationException
一个线程使用迭代器访问数据,另外一个线程修改数据
- 如果仅仅只是修改集合中的元素值,可以正常执行
- 如果修改了集合的结构则会报错ConcurrentModicationException add/remove
ArrayList中提供了Iterator接口的私有实现
private class Itr implements Iterator<E> {
int expectedModCount = modCount; 当构建迭代器对象时获取当前集合的修改次数
报错的调用方法
@SuppressWarnings("unchecked")
public E next() {
checkForComodification(); //检查修改的状态
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
final void checkForComodification() {
if (modCount != expectedModCount) 如果修改次数不等于希望的修改次数则报异常
throw new ConcurrentModificationException();
}
快死异常主要用于检查遍历数据时的并发修改操作。主要作用是杜绝在遍历元素时其它线程修改了集合框架结构
对象赋值和克隆
对象赋值 Date now2=now;
两个变量now2和now中存放是同一个对象的地址,不管操作那个变量两个都受影响,因为now2和now是同一个对象
如果希望两个变量相互不影响,则只能通过克隆实现。Java中的克隆可以分为深克隆和浅克隆
public class Student{
private long id;
private Date birth;
}
如果需要支持克隆操作要求必须实现Cloneable接口
Object类中提供了clone()方法,这个方法是一个本地方法,是由虚拟机提供实现的
protected native Object clone() throws
CloneNotSupportedException;
Cloneable接口属于标志性接口,没有具体的实现,具体实现实际上是Object类中提供的
- 自定义类上要求实现Cloneable接口
- 自定义类中要求实现clone方法,这个方法只需要调用父类的clone方法即可,一般不需要额外的处理
public class Test2 {
public static void main(String[] args) throws Exception {
Student s1 = new Student();
s1.setId(100L);s1.setBirth(new Date());
//浅克隆,只是克隆s1对象,但是针对s1中的引用类型属性只是克隆地址
Student s2 = (Student) s1.clone();
s2.getBirth().setYear(9000);
System.out.println(s2);
System.out.println(s1);
}
}
class Student implements Cloneable {
private Long id;
private Date birth;
public Object clone() throws CloneNotSupportedException{ //定义该方法的原因是Object中的
clone方法是protected的
return super.clone();
}
@Override
public String toString() {
return "Student [id=" + id + ", birth=" + birth + "]";
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
}
深克隆
一般采用对象流实现。自定义类要求实现Serializable接口
public class Test2 {
public static void main(String[] args) throws Exception {
Student s1 = new Student();
s1.setId(100L);s1.setBirth(new Date());
//浅克隆,只是克隆s1对象,但是针对s1中的引用类型属性只是克隆地址
Student s2 = (Student) s1.deepClone();
s2.getBirth().setYear(9000);
System.out.println(s2);
System.out.println(s1);
}
}
class Student implements Serializable {
private Long id;
private Date birth; //其中的属性也必须实现了序列化接口
private transient String password;//transient表示该属性不能被序列化处理
public Student deepClone() {
Student res=null;
try {
ByteArrayOutputStream baos=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(baos);
oos.writeObject(this);
ObjectInputStream ois=new ObjectInputStream(new
ByteArrayInputStream(baos.toByteArray()));
res=(Student)ois.readObject();
oos.close();
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
return res;
}
@Override
public String toString() {
return "Student [id=" + id + ", birth=" + birth + "]";
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
}