模拟实现ArrayList的常用方法
ArrayList
ArrayList：顺序表
我们可以将顺序表的底层理解成为一个数组（可以扩容的数组），但是相比于数组多出一个记录有效数据的计数器size，如：
顺序表和数组的区别：
上面说，顺序表的底层可以理解为一个数组，但是相比于数组，更加的高级。
顺序表可以自己扩容；
顺序表严格区分数组容量和元素的个数。
所以数组其实就是一种不完备的顺序表。
顺序表中的注意点：
我们需要区分顺序表中的两个概念：容量（capacity）和元素个数（size）。
容量可以理解为数组的大小（长度），元素个数是size中记录的有效元素个数。
顺序表中，数据的存储是需要连续的，不可以元素和元素之间存在“空隙”，当进行插入、删除等操作时，操作完成后，也要保证顺序表的连续。
ArrayList的常用方法
在Java中，内置了ArrayList的许多方法，我们常用的一些方法（增删改查），如下：
//尾插
boolean add(Integer e);
//指定位置插入
void add(int index, Integer e);
//删除指定位置
Integer remove(int index);
//删除指定元素
boolean remove(Integer e);
//获取元素
Integer get(int index);
//set
Integer set(int index, Integer e);
//判断是否包含
boolean contains(Integer e);
//从前到后首次遇到
int indexOf(Integer e);
//从后到前首次遇到
int lastIndexOf(Integer e);
//请空顺序表
void clear();
//获取元素个数
int size();
//判断size==0？
boolean isEmpty();
模拟实现ArrayList的常用方法
当我们需要模拟实现ArrayList的时候，我们需要先创建一个数组，和计数器size。
我们需要考虑到数组连续性的问题，以及操作中判断数组是否满了，需要2倍扩容的题，以及下标合法性校验…
1、定义接口，列出需要实现的方法：
package ArrayList;
public interface MyList {
//尾插
boolean add(Integer e);
//指定位置插入
void add(int index, Integer e);
//删除指定位置
Integer remove(int index);
//删除指定元素
boolean remove(Integer e);
//获取元素
Integer get(int index);
//set
Integer set(int index, Integer e);
//判断是否包含
boolean contains(Integer e);
//从前到后首次遇到
int indexOf(Integer e);
//从后到前首次遇到
int lastIndexOf(Integer e);
//请空顺序表
void clear();
//获取元素个数
int size();
//判断size==0？
boolean isEmpty();
}
2、具体实现：
package ArrayList;
import java.util.ArrayList;
import java.util.Arrays;
/**
* 模拟实现自己的ArrayList
*/
public class MyArrayList implements MyList {
private Integer[] array;
private int size;
public MyArrayList() {
array = new Integer[10];
size = 0;
}
//判断是否满了
private void isFull() {
if (size < array.length) {
return;
}
Integer[] arr = new Integer[array.length * 2];
//注意： 没有Integer类型的copyOf方法。
//arr = Arrays.copyOf(array, array.length);
for (int i=0;i<array.length;i++){
arr[i]=array[i];
}
this.array = arr;
}
@Override
public boolean add(Integer e) {
isFull();
array[size] = e;
size++;
return true;
}
@Override
public void add(int index, Integer e) {
isFull();
if (index < 0 || index > size()) {
// 下标不合法
throw new ArrayIndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
for (int from = size() - 1; from >= index; from--) {
array[from + 1] = array[from];
}
array[index] = e;
size++;
}
@Override
public Integer remove(int index) {
if (index < 0 || index >= size()) {
// 下标不合法
throw new ArrayIndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
Integer e = array[index];
for (int from = index + 1; from < size; from++) {
array[from - 1] = array[from];
}
array[size - 1] = null;
size--;
return e;
}
@Override
public boolean remove(Integer e) {
int i = indexOf(e);
if (i < 0) {
return false;
}
remove(i);
return true;
}
@Override
public Integer get(int index) {
if (index < 0 || index >= size()) {
// 下标不合法
throw new ArrayIndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
return array[index];
}
@Override
public Integer set(int index, Integer e) {
if (index < 0 || index >= size()) {
// 下标不合法
throw new ArrayIndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
Integer old = array[index];
array[index] = e;
return old;
}
@Override
public boolean contains(Integer e) {
return indexOf(e) >= 0;
}
@Override
public int indexOf(Integer e) {
for (int i = 0; i < size(); i++) {
if (array[i].equals(e)) {
return i;
}
}
return -1;
}
@Override
public int lastIndexOf(Integer e) {
for (int i = size() - 1; i >= 0; i--) {
if (array[i].equals(e)) {
return i;
}
}
return -1;
}
@Override
public void clear() {
Arrays.fill(array, null);
size = 0;
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public String toString() {
Integer[] toShow = Arrays.copyOf(array, size);
return Arrays.toString(toShow);
}
}
3、测试
package ArrayList;
public class MyArrayListDemo {
public static void main(String[] args) {
MyList list = new MyArrayList();
System.out.println(list); // []
list.add(1);
list.add(2);
list.add(3);
System.out.println(list); // [1, 2, 3]
list.add(0, 100);
list.add(0, 200);
list.add(0, 300);
System.out.println(list); // [300, 200, 100, 1, 2, 3]
Integer remove = list.remove(2);
System.out.println(list); // [300, 200, 1, 2, 3]
System.out.println(remove); // 100
boolean r = list.remove((Integer)1); // 通过类型转换，确认调用的是 remove(Integer) 而不是 remove(int)
System.out.println(r); // true
System.out.println(list); // [300, 200, 2, 3]
System.out.println(list.size());
System.out.println(list.isEmpty());
list.clear();
System.out.println(list.size());
System.out.println(list.isEmpty());
}
}
4、结果：
总结：我发现数据结构的逻辑性很强，需要慢慢的思考，结合图形，加深理解！！！