Java 自定义动态数组方式

Java自定义动态数组

1、静态数组向动态数组转变

（1）静态数组，数组空间固定长度

这个数组空间总长为4，如果此时新插入一个数据就会报数组空间不足

（2）静态数组如何转变成动态数组

第一步：创建一个空间是data数组两倍的newData数组（扩容）；

第二步：把data数组中的元素全部赋值到newData数组；

2、数组扩容程序

// 数组扩容
private void resize(int newCapacity){
 E[] newData = (E[]) new Object[newCapacity];
 for (int i = 0; i < size; i++) {
   newData[i] = data[i];
 }
 data = newData;
}

数组添加元素：数组空间不够就会扩容（原来空间2倍）

 // 数组指定位置添加元素
 public void add(int index, E e) {
//    if (size == data.length)
//      throw new IllegalArgumentException("Add failed.Array is full.");
   if (index < 0 || index > size)
     throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");
   if (size == data.length)
     resize(2 * data.length);
   for (int i = size - 1; i >= index; i--)
     data[i + 1] = data[i];
   data[index] = e;
   size++;
 }

数组删除元素：数组空间空闲太大就会缩容（原来空间的1/2）

// 从数组中删除index位置的元素，返回删除的元素
public E remove(int index) {
 if (index < 0 || index >= size) {
   throw new IllegalArgumentException("Remove failed.Index is illegal");
 }
 E ret = data[index];
 for (int i = index + 1; i < size; i++) {
   data[i - 1] = data[i];
 }
 size--;
 // loitering objects != memory leak 手动释放内存空间
 data[size] = null;
 if(size == data.length / 2) {
   resize(data.length / 2);
 }
 return ret;
}

3、数组整体代码

public class Array<E> {
 // 定义数组变量，data.length表示数组容量capacity
 private E[] data;
 // 定义数组中存放数据大小
 private int size;
 // 有参构造方法，传入数组的容量capacity构造动态数组
 public Array(int capacity) {
   data = (E[])new Object[capacity];
   size = 0;
 }
 // 无参构造方法，默认初始容量为capacity=10
 public Array() {
   this(10);
 }
 // 获取数组中元素个数
 public int getSize() {
   return size;
 }
 // 获取数组的容量
 public int getCapacity() {
   return data.length;
 }
 // 判断数组是否为空
 public boolean isEmpty() {
   return size == 0;
 }
/*  // 在数组末尾添加元素
 public void addLast(E e) {
   if (size == data.length)
     throw new IllegalArgumentException("AddLast failed.Array is full.");
   data[size] = e;
   size++;
 }*/
 // 在数组末尾添加元素（复用add方法）
 public void addLast(E e) {
   add(size, e);
 }
 // 在数组头部添加元素（复用add方法）
 public void addFirst(E e) {
   add(0, e);
 }
 // 数组指定位置添加元素
 public void add(int index, E e) {
//    if (size == data.length)
//      throw new IllegalArgumentException("Add failed.Array is full.");
   if (index < 0 || index > size)
     throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");
   if (size == data.length)
     resize(2 * data.length);
   for (int i = size - 1; i >= index; i--)
     data[i + 1] = data[i];
   data[index] = e;
   size++;
 }
 // 获取index索引位置的元素
 public E get(int index) {
   if (index < 0) {
     throw new IllegalArgumentException("Get failed.Index is illegal.");
   }
   return data[index];
 }
 // 修改index索引位置的元素
 public void set(int index, E e) {
   if (index < 0 || index >= size) {
     throw new IllegalArgumentException("Set failed.Index is illegal.");
   }
   data[index] = e;
 }
 // 查找数组中是否存在元素e
 public boolean contains(E e) {
   for (int i = 0; i < size; i++) {
     if (data[i] == e) {
       return true;
     }
   }
   return false;
 }
 // 查找数组中元素e所在的索引，如果不存在元素e，则返回-1
 public int find(E e) {
   for (int i = 0; i < size; i++) {
     if (data[i] == e) {
       return i;
     }
   }
   return -1;
 }
 // 从数组中删除index位置的元素，返回删除的元素
 public E remove(int index) {
   if (index < 0 || index >= size) {
     throw new IllegalArgumentException("Remove failed.Index is illegal");
   }
   E ret = data[index];
   for (int i = index + 1; i < size; i++) {
     data[i - 1] = data[i];
   }
   size--;
   // loitering objects != memory leak 手动释放内存空间
   data[size] = null;
   if(size == data.length / 2) {
     resize(data.length / 2);
   }
   return ret;
 }
 // 删除数组第一个元素，返回删除的元素
 public E removeFirst() {
   return remove(0);
 }
 // 删除数组最后一个元素
 public E removeLast() {
   return remove(size - 1);
 }
 // 删除数组中指定元素e
 public void removeElement(E e) {
   int index = find(e);
   if (index != -1) {
     remove(index);
   }
 }
 // 数组扩容
 private void resize(int newCapacity){
   E[] newData = (E[]) new Object[newCapacity];
   for (int i = 0; i < size; i++) {
     newData[i] = data[i];
   }
   data = newData;
 }
 // 重写父类toString()方法
 @Override
 public String toString() {
   StringBuilder sb = new StringBuilder();
   sb.append(String.format("Array: size = ％d , capacity = ％d\n", size, data.length));
   sb.append('[');
   for (int i = 0; i < size; i++) {
     sb.append(data[i]);
     if (i != size - 1) {
       sb.append(',');
     }
   }
   sb.append(']');
   return sb.toString();
 }
}

4、数组测试代码

public class ArrayTest {
 public static void main(String[] args) {
   // 测试toString()方法
   Array<Integer> arr = new Array(10);
   for (int i = 0; i < 10; i++) {
     // 测试addLast(int e)方法
     arr.addLast(i);
   }
   System.out.println("添加数组元素：");
   System.out.println(arr);
   // 测试add(int index, int e)方法
   arr.add(1, 200);
   System.out.println("在数组指定索引位置插入元素e：");
   System.out.println(arr);
   // 测试addFirst(int e)方法
   arr.addFirst(-10);
   System.out.println("在数组头部位置插入元素e：");
   System.out.println(arr);
 }
}

测试结果如下所示：初始化数组空间大小为10，第一次插入10个元素到数组之后，然后再添加一个元素，此时数组会扩容为原来空间的两倍。

添加数组元素：

Array: size = 10 , capacity = 10
[0,1,2,3,4,5,6,7,8,9]

在数组指定索引位置插入元素e：

Array: size = 11 , capacity = 20
[0,200,1,2,3,4,5,6,7,8,9]

在数组头部位置插入元素e：

Array: size = 12 , capacity = 20

补充：Java静态数组和动态数组的定义方式

数组的定义方式

静态：

//简化语法常用 定义和初始化同步完成
int [] a = {5,2,6,4,10};

动态：

//数组的定义和初始化同时完成，使用动态初始化语法
int[] prices = new int[5];

补充：

//初始化数组时元素的类型是定义数组时元素类型的子类
Object[] books = new String[4];

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。如有错误或未考虑完全的地方，望不吝赐教。

来源：https://blog.csdn.net/longgeqiaojie304/article/details/87311625