ArrayList简介
ArrayList是Java集合框架中的一个重要的类,它继承于AbstractList,实现了List接口,是一个长度可变的集合,提供了增删改查的功能。集合中允许null的存在。ArrayList类还是实现了RandomAccess接口,可以对元素进行快速访问。ArrayList有如下特点:
- 底层结构是动态数组
- 线程不同步
- 更擅长做随机访问(遍历)
- 添加和删除元素速度比LinkedList慢
定义接口List
List是线性结构的接口,里面定义了该线性结构的一些通用操作并支持泛型。List接口继承自Iterable(可迭代接口),主要用于遍历数据结构,其次让我们的类可以使用for-each循环。
其中包含的方法和List接口完整代码如下:
public interface List<E> extends Iterable<E> {
/**
*在线性结构的末尾添加指定元素element
*/
public void add(E element);
/**
* 在线性结构中指定下标index处添加元素element
*/
public void add(int index,E element);
/**
* 在线性结构中删除指定元素element
*/
public void remove(E element);
/**
* 在线性结构中删除指定下标index处的元素并返回
*/
public E remove(int index);
/**
* 在线性结构中获取指定下标index处的元素
*/
public E get(int index);
/**
* 修改指定下标处index元素为新元素element
*/
public E set(int index,E element);
/**
* 获取有效元素个数
*/
public int size();
/**
* 获取指定元素element在线性结构中的下标
*/
public int indexOf(E element);
/**
* 查看线性表中是否包含指定元素element
*/
public boolean contains(E element);
/**
* 查看线性结构是否为空
*/
public boolean isEmpty();
/**
* 清空线性结构
*/
public void clear();
/**
* 对线性结构按照比较器Comparator的定义进行排序(E类型不能直接用大于、于号直接比较)
*/
public void sort(Comparator<E> comparator);
/**
* 获取线性结构中从指定fromIndex下标开始到toIndex下标结尾的所有元素
* (size > toIndex > fromIndex >= 0)
*/
public List<E> sublist(int fromIndex,int toIndex);
}
ArrayList类的创建
创建ArrayList类,实现我们刚刚编写好的List接口,类里面有3个属性:
- data[]:存储元素的容器
- size:有效元素的个数
- DEFAULT_CAPACITY:默认容量大小,设置为10
构造方法有三个,第一个为无参数,即直接创建一个默认长度的ArrayList;第二个为带一个参数,用于创建一个指定长度的ArrayList;第三个为将一个数组封装为线性表,参数是数组。
- 传入指定长度时需要判断参数的合法性,不合法则抛出异常
- 传入指定数组时需要判断数组是否为空,为空则抛出异常
- 第三个构造方法使用的add()方法即是本ArrayList要实现的添加元素的方法,在后面会实现
代码如下:
public class ArrayList<E> implements List<E> {
//存储元素的容器
private E[] data;
//元素的有效个数
private int size;
//默认容量大小
private static int DEFAULT_CAPACITY = 10;
/**
* 创建一个默认容量为10的线性表
*/
public ArrayList(){
this(DEFAULT_CAPACITY);
}
/**
* 创建一个指定容量为capacity的线性表
*/
public ArrayList(int capacity){
if(capacity <= 0){
throw new IllegalArgumentException("容量必须大于等于0");
}
data = (E[]) new Object[capacity];
size = 0;
}
/**
* 将一个现有数组封装成线性表
*/
public ArrayList(E[] arr){
if(arr == null){
throw new IllegalArgumentException("数组不能为空");
}
data = (E[]) new Object[arr.length];
size = 0;
for(E e : arr){ //e是arr[i]
add(e); //把每个元素添加到线性表的末尾
}
}
}
数组的扩容
在实现其他方法前,先编写扩容函数。每当向数组中添加元素时,都要去检查添加后元素的个数是否会超出当前数组的长度,如果超出,数组将会进行扩容,以满足添加数据的需求;
如果数组元素大大小于数组长度时,同样可以使用此函数对数组进行缩容操作。
- 函数内定义一个新数组newData,长度为参数newLength。
- 将原数组data内的所有元素转移到newData中。
代码如下:
private void resize(int newLength) {
E[] newData = (E[]) new Object[newLength];
for(int i = 0;i < size;i++){
newData[i] = data[i];
}
data = newData;
}
添加元素
add()方法用于向ArrayList中添加元素,有带一个参数和带两个参数的形式。
- 判断表是否已满,如果满则调用扩容函数进行扩容。
- 添加元素时,将待添加位置之后的元素整体后移一个位置,将数据进行插入。
- size自增1。
代码如下:
@Override
public void add(E element){
add(size,element);
}
@Override
public void add(int index,E element){
if(index < 0 || index > size){ //判断传入index的正确性
throw new IllegalArgumentException("index范围错误");
}
//判断是否满
if(size == data.length){
//如果表满则扩容
resize(data.length * 2);
}
for(int i = size;i >index;i--){
data[i] = data[i - 1];
}
data[index] = element;
size++;
}
删除元素
remove()方法用于向ArrayList中添加元素,有参数为元素和参数为下标的形式。
- 判断传入下标是否合法。
- 使用变量接取待删除的值。
- 删除元素时,将待添加位置之后的元素整体前移一个位置,将数据进行覆盖删除。
- 判断当前表内数据是否小于表容量的四分之一,如果小于则使用扩容函数进行缩容操作。
- 返回被删除的值。
代码如下:
@Override
public void remove(E element){
int index = 0;
while((index = indexOf(element)) != -1) { //只要包含
remove(index);
}
}
@Override
public E remove(int index){
if(index < 0 || index >= size) {
throw new IllegalArgumentException("index范围错误");
}
E ret = data[index];
for(int i = index;i <= size - 2;i++){
data[i] = data[i + 1];
}
size--;
if(size == data.length / 4 && data.length > DEFAULT_CAPACITY) { //如果有效数据长度等于data数组的四分之一,且数组长度大于默认容量,则可缩容
resize(data.length / 2);
}
return ret;
}
获取指定元素的下标
indexOf()方法用于获取指定元素element在线性结构中的下标。
- 使用循环对比表内元素和传入参数是否相等,相等则返回下标,否则返回-1。
- 因为数据类型为泛型,所以使用equals进行数据的对比。
代码如下:
@Override
public int indexOf(E element){
for(int i = 0;i < size;i++){
if(data[i].equals(element)){
return i;
}
}
return -1;
}
查看表中是否包含元素
contains()方法用于查看线性表中是否包含指定元素element。
- 直接调用返回indexOf方法的值即可。
代码如下:
@Override
public boolean contains(E element){
return indexOf(element) != -1;
}
获取指定下标的元素
get()方法用于获取线性结构中指定下标的元素。
- 判断传入下标是否合法。
- 返回指定下标处的值。
代码如下:
@Override
public E get(int index){
if(index < 0 || index >= size){
throw new IllegalArgumentException("index范围错误");
}
return data[index];
}
修改指定下标的元素的值
set()方法用于修改指定下标处index元素为新元素element。
- 判断传入下标是否合法。
- 使用变量接取修改前的值。
- 修改index处的数据。
- 返回修改前的值。
代码如下:
@Override
public E set(int index,E element){
if(index < 0 || index >= size){
throw new IllegalArgumentException("index范围错误");
}
E ret = data[index];
data[index] = element;
return ret;
}
判断表是否为空
isEmpty()用于判断表是否为空。
- 直接返回size是否等于0。
代码如下:
@Override
public boolean isEmpty(){
return size == 0;
}
获取表内元素个数
size()用于获取有效元素个数。
- 直接返回size的值。
代码如下:
@Override
public int size(){
return size;
}
清空全表
clear()用于清空整个表。
- 将data声明为一个新数组,长度为默认值。
- 将数据数size置为0。
代码如下:
@Override
public void clear(){
data = (E[]) new Object[DEFAULT_CAPACITY];
size = 0;
}
数据排序
sort()用于对表内数据的排序。因为我们使用的是泛型,所以<、>等运算符均无法用来比较数据大小,这时候就要使用比较器Comparator。其中compare()方法用来比较两个参数,返回负数表示第一个比第二个小,返回正数表示第一个参数比第二个大。排序过程使用插入排序。
- 判断传入的比较器对象是否为空,为空则抛出异常。
- 使用compare()方法进行插入排序。
代码如下:
@Override
public void sort(Comparator<E> comparator){
if(comparator == null){
throw new IllegalArgumentException("比较器不能为空");
}
//插入排序 O(n^2)
for(int i = 1;i < size;i++){
E e = data[i];
int j;
for(j = i;j > 0 && comparator.compare(data[j - 1],e) > 0;j--){ //比较两个参数,返回负数表示第一个比第二个小,返回正数表示第一个参数比第二个大
data[j] = data[j - 1];
}
data[j] = e;
}
}
获取一个区间内的表元素
sublist()方法用于获取线性结构中从指定fromIndex下标开始到toIndex下标结尾的所有元素。我们使用本ArrayList来存放获取到的元素,所以此方法的返回类型是一个List。
- 判断索引是否合法。区间为 size > toIndex > fromIndex >= 0。
- 创建新的ArrayList对象list。
- 循环,将fromIndex到toIndex区间内的值添加进list。
- 返回list。
代码如下:
@Override
public List<E> sublist(int fromIndex,int toIndex){
if(fromIndex < 0 || toIndex >= size || fromIndex > toIndex){
throw new IllegalArgumentException("索引超出范围");
}
ArrayList<E> list = new ArrayList<>();
for(int i = fromIndex;i < toIndex;i++){
list.add(data[i]);
}
return list;
}
重写equals方法
- 判断传入参数是否为空。
- 判断传入参数是否是自己。
- 判断传入对象是否为ArrayList。
- 将传入对象obj转换成ArrayList。
- 先比较两个对象长度是否相等。
- 最后对比数据,一致则返回true;上述一个条件不满足则直接返回false。
代码如下:
@Override
public boolean equals(Object obj){
if(obj == null){
return false; //先判空
}
if(obj == this){
return true; //判断是否是自己
}
if(obj instanceof ArrayList){ //判断传入对象是否为ArrayList
ArrayList<E> other = (ArrayList<E>) obj; //将obj强转为ArrayList
if(this.size == other.size){ //先比较有效长度size是否相等
for(int i = 0;i < this.size;i++){
if(!this.data[i].equals(other.data[i])){ //对比数据,不一致则返回false
return false;
}
}
return true;
}
else{
return false;
}
}
else{
return false;
}
}
重写toString方法
重写toString方法,使用toString方法时可以输出ArrayList,使输出数据较为美观。
其中使用StringBuilder存放数据。代码如下:
@Override
public String toString(){
StringBuilder sb = new StringBuilder();
sb.append('['); //使用字符的原因是减少临时字符串常量的产生 (字符串底层是字符数组)
if(isEmpty()){
sb.append(']');
}
else{
for(int i = 0;i < size;i++){
sb.append(data[i]);
if(i != size - 1){
sb.append(',');
}
else{
sb.append(']');
}
}
}
return sb.toString();
}
定义迭代器内部类
定义内部类ArrayListIterator实现Iterator接口并实现hasNext()和next方法,代码如下:
/**
* 迭代器内部类
*/
private class ArrayListIterator implements Iterator<E>{
private int cur = 0;
/**
* 检查是否有下一个
*/
@Override
public boolean hasNext() {
return cur < size;
}
/**
* 取出cur然后向后移
*/
@Override
public E next() {
return data[cur++];
}
}
返回迭代器对象
iterator()方法用于返回一个迭代器对象。返回类型是Iterator。
- 直接返回上面创建的迭代器内部类的对象。
代码如下:
@Override
public Iterator<E> iterator() {
return new ArrayListIterator();
}
ArrayList类完整代码
public class ArrayList<E> implements List<E> {
//存储元素的容器
private E[] data;
//元素的有效个数
private int size;
//默认容量大小
private static int DEFAULT_CAPACITY = 10;
/**
* 创建一个默认容量为10的线性表
*/
public ArrayList(){
this(DEFAULT_CAPACITY);
}
/**
* 创建一个指定容量为capacity的线性表
*/
public ArrayList(int capacity){
if(capacity <= 0){
throw new IllegalArgumentException("容量必须大于等于0");
}
data = (E[]) new Object[capacity];
size = 0;
}
/**
* 将一个现有数组封装成线性表
*/
public ArrayList(E[] arr){
if(arr == null){
throw new IllegalArgumentException("数组不能为空");
}
data = (E[]) new Object[arr.length];
size = 0;
for(E e : arr){ //e是arr[i]
add(e); //把每个元素添加到线性表的末尾
}
}
@Override
public void add(E element){
add(size,element);
}
@Override
public void add(int index,E element){
if(index < 0 || index > size){ //判断传入index的正确性
throw new IllegalArgumentException("index范围错误");
}
//判断是否满
if(size == data.length){
//如果表满则扩容
resize(data.length * 2);
}
for(int i = size;i >index;i--){
data[i] = data[i - 1];
}
data[index] = element;
size++;
}
@Override
public void remove(E element){
int index = 0;
while((index = indexOf(element)) != -1) { //只要包含
remove(index);
}
}
@Override
public E remove(int index){
if(index < 0 || index >= size) {
throw new IllegalArgumentException("index范围错误");
}
E ret = data[index];
for(int i = index;i <= size - 2;i++){
data[i] = data[i + 1];
}
size--;
if(size == data.length / 4 && data.length > DEFAULT_CAPACITY) { //如果有效数据长度等于data数组的四分之一,且数组长度大于默认容量,则可缩容
resize(data.length / 2);
}
return ret;
}
@Override
public int indexOf(E element){
for(int i = 0;i < size;i++){
if(data[i].equals(element)){
return i;
}
}
return -1;
}
@Override
public boolean contains(E element){
return indexOf(element) != -1;
}
@Override
public E get(int index){
if(index < 0 || index >= size){
throw new IllegalArgumentException("index范围错误");
}
return data[index];
}
@Override
public E set(int index,E element){
if(index < 0 || index >= size){
throw new IllegalArgumentException("index范围错误");
}
E ret = data[index];
data[index] = element;
return ret;
}
@Override
public boolean isEmpty(){
return size == 0;
}
@Override
public int size(){
return size;
}
@Override
public void clear(){
data = (E[]) new Object[DEFAULT_CAPACITY];
size = 0;
}
@Override
public void sort(Comparator<E> comparator){
if(comparator == null){
throw new IllegalArgumentException("比较器不能为空");
}
//插入排序 O(n^2)
for(int i = 1;i < size;i++){
E e = data[i];
int j;
for(j = i;j > 0 && comparator.compare(data[j - 1],e) > 0;j--){ //比较两个参数,返回负数表示第一个比第二个小,返回正数表示第一个参数比第二个大
data[j] = data[j - 1];
}
data[j] = e;
}
}
@Override
public List<E> sublist(int fromIndex,int toIndex){
if(fromIndex < 0 || toIndex >= size || fromIndex > toIndex){
throw new IllegalArgumentException("索引超出范围");
}
ArrayList<E> list = new ArrayList<>();
for(int i = fromIndex;i < toIndex;i++){
list.add(data[i]);
}
return list;
}
/**
* 扩容
* 每当向数组中添加元素时,都要去检查添加后元素的个数是否会超出当前数组的长度,如果超出,数组将会进行扩容,以满足添加数据的需求。
*/
private void resize(int newLength) {
E[] newData = (E[]) new Object[newLength];
for(int i = 0;i < size;i++){
newData[i] = data[i];
}
data = newData;
}
@Override
public String toString(){
StringBuilder sb = new StringBuilder();
sb.append('['); //使用字符的原因是减少临时字符串常量的产生 (字符串底层是字符数组)
if(isEmpty()){
sb.append(']');
}
else{
for(int i = 0;i < size;i++){
sb.append(data[i]);
if(i != size - 1){
sb.append(',');
}
else{
sb.append(']');
}
}
}
return sb.toString();
}
@Override
public boolean equals(Object obj){
if(obj == null){
return false; //先判空
}
if(obj == this){
return true; //判断是否是自己
}
if(obj instanceof ArrayList){ //判断传入对象是否为ArrayList
ArrayList<E> other = (ArrayList<E>) obj; //将obj强转为ArrayList
if(this.size == other.size){ //先比较有效长度size是否相等
for(int i = 0;i < this.size;i++){
if(!this.data[i].equals(other.data[i])){ //对比数据,不一致则返回false
return false;
}
}
return true;
}
else{
return false;
}
}
else{
return false;
}
}
/**
* 返回迭代器对象
*/
@Override
public Iterator<E> iterator() {
return new ArrayListIterator();
}
/**
* 迭代器内部类
*/
private class ArrayListIterator implements Iterator<E>{
private int cur = 0;
/**
* 检查是否有下一个
*/
@Override
public boolean hasNext() {
return cur < size;
}
/**
* 取出cur然后向后移
*/
@Override
public E next() {
return data[cur++];
}
}
}