动态数组，见名知意，不像静态数组那样，一旦开辟了空间，就不能再进行增加或者删除操作，动态数组可以在数组存储满的时候自动扩容，数组中存储元素过少的时候自动缩容。
在这里，为了使用方便起见，使用了泛型
/**
* 动态数组中的元素存储于data中
*/
private E[] data;
/**
* size记录数组中的元素个数
*/
private int size;首先实现add，传入要插入的索引位置，以及元素，在add的基础上可以实现addLast 以及addFirst ，以便后续在动态数组上实现栈，以及队列的操作
public void add(int index, E e) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("Add failed ,required index>=0 and index<=size ");
}
if (size == data.length) {
resize(size * 2);
}
//将需要插入的位置(包括本身)向后挪动一位
for (int i = size - 1; i >= index; i--) {
data[i + 1] = data[i];
}
//最后将想要添加的元素放入想要放入的位置
data[index] = e;
size++;
}
public void addLast(E e) {
add(size, e);
}
public void addFirst(E e) {
add(0, e);
}以及remove某个索引的元素，在这个基础上实现removeElement，removeFirst，removeLast
/**
* 从数组中删除指定索引位置元素并返回
* ret 保存需要返回的元素 然后将 index+1至 size-1 统一向前挪动一个位置
* 如果数组现存的元素个数不到数组长度的 1/4 就将数组缩容 为 原长的1/2
*
* @param index
* @return
*/
public E remove(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Remove failed , index illegal");
}
E ret = data[index];
for (int i = index + 1; i < size; i++) {
data[i - 1] = data[i];
}
//data[size - 1] = null;
size--;
//如果数组中存储的元素不及数组容量的1/4，缩小数组容量为现在的一半
if (size == data.length / 4 && data.length / 2 != 0) {
resize(data.length / 2);
}
return ret;
}
/**
* 首先找到元素e的索引，再删除
*
* @param e
*/
public void removeElement(E e) {
int index = find(e);
if (index != -1) {
remove(index);
}
}
public E removeLast() {
return remove(size - 1);
}
public E removeFirst() {
return remove(0);
}还有一个最重要的resize，为数组重新开辟空间
/**
* 将原数组的元素复制进新的数组中
*
* @param newCapacity
*/
private void resize(int newCapacity) {
E[] newData = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
data = newData;
}
整个动态数组包装的方法：
以及整个动态数组的代码：
public class Array<E> {
/**
* 动态数组中的元素存储于data中
*/
private E[] data;
/**
* size记录数组中的元素个数
*/
private int size;
/**
* 传入数组的容量capacity来构造Array
*
* @param capacity
*/
public Array(int capacity) {
data = (E[]) new Object[capacity];
size = 0;
}
/**
* 无参构造,默认数组容量capacity = 10
*/
public Array() {
this(10);
}
/**
* 将传入的数组转化为动态数组存储
*
* @param arr
*/
public Array(E[] arr) {
data = (E[]) new Object[arr.length];
for (int i = 0; i < arr.length; i++) {
data[i] = arr[i];
}
size = arr.length;
}
public int getSize() {
return size;
}
public int getCapacity() {
return data.length;
}
public boolean isEmpty() {
return size == 0;
}
public void addLast(E e) {
add(size, e);
}
public void addFirst(E e) {
add(0, e);
}
public void add(int index, E e) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("Add failed ,required index>=0 and index<=size ");
}
if (size == data.length) {
resize(size * 2);
}
//将需要插入的位置(包括本身)向后挪动一位
for (int i = size - 1; i >= index; i--) {
data[i + 1] = data[i];
}
//最后将想要添加的元素放入想要放入的位置
data[index] = e;
size++;
}
/**
* 返回index位置的元素
*
* @param index
* @return
*/
public E get(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Get failed , index illegal");
}
return data[index];
}
public E getLast() {
return get(size - 1);
}
public E getFirst() {
return get(0);
}
/**
* 修改index位置的元素e
*
* @param index
* @param e
*/
public void set(int index, E e) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Set failed , index illegal");
}
data[index] = e;
}
/**
* 查找数组中是否有元素e
*
* @param e
* @return
*/
public boolean contains(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e)) {
return true;
}
}
return false;
}
/**
* 返回元素e的索引，如果没找到，返回-1
*
* @param e
* @return
*/
public int find(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e)) {
return i;
}
}
return -1;
}
public E removeLast() {
return remove(size - 1);
}
public E removeFirst() {
return remove(0);
}
/**
* 首先找到元素e的索引，再删除
*
* @param e
*/
public void removeElement(E e) {
int index = find(e);
if (index != -1) {
remove(index);
}
}
/**
* 从数组中删除指定索引位置元素并返回
* ret 保存需要返回的元素 然后将 index+1至 size-1 统一向前挪动一个位置
* 如果数组现存的元素个数不到数组长度的 1/4 就将数组缩容 为 原长的1/2
*
* @param index
* @return
*/
public E remove(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Remove failed , index illegal");
}
E ret = data[index];
for (int i = index + 1; i < size; i++) {
data[i - 1] = data[i];
}
//data[size - 1] = null;
size--;
//缩小数组长度
if (size == data.length / 4 && data.length / 2 != 0) {
resize(data.length / 2);
}
return ret;
}
@Override
public String toString() {
StringBuilder result = new StringBuilder();
result.append(String.format("DynamicArray : size = %d , capacity = %d\n", size, data.length));
result.append('[');
for (int i = 0; i < size; i++) {
result.append(data[i]);
if (i != size - 1) {
result.append(", ");
}
}
result.append(']');
return result.toString();
}
/**
* 交换索引为 i 和 j 的元素位置
*
* @param i
* @param j
*/
public void swap(int i, int j) {
if (i < 0 || i >= size || j < 0 || j >= size) {
throw new IllegalArgumentException("Index is illegal . ");
}
E t = data[i];
data[i] = data[j];
data[j] = t;
}
/**
* 将原数组的元素复制进新的数组中
*
* @param newCapacity
*/
private void resize(int newCapacity) {
E[] newData = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
data = newData;
}
}
最后测试下：
public class Main { public static void main(String[] args) { Array<Integer> array = new Array(); for (int i = 0; i < 10; i++) { array.addLast(i); } System.out.println(array); array.add(1, 100); System.out.println(array); array.addFirst(-1); System.out.println(array); //[-1, 0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9] array.remove(2); System.out.println(array); array.removeElement(4); System.out.println(array); array.removeFirst(); System.out.println(array); } }
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
