我只是很简单的仿照了jdk的ArrayList类的源码实现了一下,总体来说还是很简单,后面也有对数组的总结和分析,来都来了,建议看着理解一下。
实现:
import java.util.Arrays;
public class IArray<E> {
// 定义一个数组
private Object[] intArray;
// 定义数组的实际有效长度
private int elems;
// 定义数组的最大长度
private int length;
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 默认构造一个长度为10的数组
public IArray() {
this(10);
}
// 构造函数,初始化一个长度为length 的数组
public IArray(int initialCapacity) {
if (length < 0)
throw new IllegalArgumentException("Illegal Capacity: " + length);
elems = 0;
this.length = initialCapacity;
intArray = new Object[length];
}
/**
* 获取数组的有效长度
*
* @return
*/
public int Size() {
return elems;
}
/**
* 遍历显示元素
*/
public void print() {
for (int i = 0; i < elems; i++) {
System.out.print(intArray[i] + " ");
}
System.out.println();
}
/**
* 添加元素
*
* @param value,假设操作人是不会添加重复元素的,如果有重复元素对于后面的操作都会有影响。
* @return添加成功返回true,添加的元素超过范围了返回false
*/
public boolean add(Object value) {
isGrow(elems + 1);
intArray[elems] = value;
elems++;
return true;
}
/**
* 给数组扩容
*/
private void isGrow(int minCapacity) {
if (minCapacity < length)
return;
int oldCapacity = length;
int newCapacity = oldCapacity + (oldCapacity >> 1);// 扩大原来的一半
newCapacity = (newCapacity > MAX_ARRAY_SIZE) ? MAX_ARRAY_SIZE : newCapacity;
this.length = newCapacity;
intArray = Arrays.copyOf(intArray, length);
}
/**
* 根据下标获取元素
*
* @param i
* @return查找下标值在数组下标有效范围内,返回下标所表示的元素 查找下标超出数组下标有效值,提示访问下标越界
*/
public Object get(int i) {
if (i < 0 || i > elems) {
System.out.println("访问下标越界:" + i);
throw new ArrayIndexOutOfBoundsException();
}
else
return intArray[i];
}
/**
* 查找元素
*
* @param searchValue
* @return查找的元素如果存在则返回下标值,如果不存在,返回 -1
*/
public int find(Object searchValue) {
int i;
for (i = 0; i < elems; i++) {
if (intArray[i] == searchValue) {
break;
}
}
if (i == elems) {
return -1;
}
return i;
}
/**
* 删除元素
*
* @param value
* @return如果要删除的值不存在,直接返回 false;否则返回true,删除成功
*/
public boolean delete(Object value) {
int k = find(value);
if (k == -1) {
return false;
} else {
if (k == elems - 1) {
elems--;
} else {
for (int i = k; i < elems - 1; i++) {
intArray[i] = intArray[i + 1];
}
elems--;
}
return true;
}
}
/**
* 修改数据
*
* @param oldValue原值
* @param newValue新值
* @return修改成功返回true,修改失败返回false
*/
public boolean modify(Object oldValue, Object newValue) {
int i = find(oldValue);
if (i == -1) {
System.out.println("需要修改的数据不存在");
return false;
} else {
intArray[i] = newValue;
return true;
}
}
}
测试:
IArray<Integer> iArray = new IArray<Integer>(2);
System.out.println(iArray.Size());
iArray.add(1);
iArray.add(2);
iArray.add(3);
iArray.add(4);
iArray.add(5);
System.out.println(iArray.Size());
System.out.println(iArray.get(3));
System.out.println(iArray.find(6));
iArray.print();
if (iArray.delete(2)) {
System.out.println("删除成功!");
} else {
System.out.println("删除成功!");
}
数组的优缺点分析:
-
插入块,上面我们实现的是一个无序数组,无序数组的插入速度为1,但是如果是有序数组的话,就很慢了,首先要找到插入的位置,然后再将后面的元素整体向后移位,复杂度为n。
-
查找慢,如果我们查找是根据数组的下标来,查找速度就很快,为1,但这实际中这么查没意义,如果使用哈希表就不一样了。有序数组的查找速度为log n,无序的为n。
-
删除慢,根据元素值删除,我们要先找到该元素所处的位置,然后将元素后面的值整体向前面移动一个位置,复杂度为n。

被折叠的 条评论
为什么被折叠?



