在静态类型语言如Java和C中，动态数组的实现与动态语言有所不同，因为它们需要在编译时指定数据类型和数组长度。然而，通过一些技巧，我们仍然可以在这些语言中模拟动态数组的行为。以下是Java和C语言分别实现动态数组的方法。
在Java中，虽然有内置的ArrayList类可以方便地实现动态数组的功能，但有时为了性能考虑，程序员会选择自定义实现。例如，Tomcat源码中就有一个自定义的动态数组实现。这个实现的核心是通过创建新的数组并复制旧数组的内容来调整大小。以下是Java版动态数组的基本思路：
1. 初始化一个固定大小的数组。
2. 当需要添加元素时，创建一个新的数组，其大小比原数组大1。
3. 使用`System.arraycopy()`方法将原数组内容复制到新数组。
4. 在新数组的末尾添加新元素。
5. 将新数组的引用赋值给原来的数组变量，完成动态扩展。
以下是一个简单的Java动态数组添加和删除元素的示例：
```java
public class DiyArrayListDemo {
public static void main(String[] args) {
int[] arr = {5, 8, 10};
System.out.println(Arrays.toString(arr));
arr = DiyArrayList.add(arr, 15);
arr = DiyArrayList.add(arr, 20);
arr = DiyArrayList.add(arr, 25);
System.out.println(Arrays.toString(arr));
arr = DiyArrayList.remove(arr, 1);
System.out.println(Arrays.toString(arr));
}
}
class DiyArrayList {
public static int[] add(int[] src, Integer newData) {
int[] dest = new int[src.length + 1];
System.arraycopy(src, 0, dest, 0, src.length);
dest[src.length] = newData;
return dest;
}
public static int[] remove(int[] src, Integer index) {
int[] desc = new int[src.length - 1];
for (int i = 0; i < src.length; i++) {
if (i > index) {
desc[i - 1] = src[i];
} else {
desc[i] = src[i];
}
}
return desc;
}
}
```
在C语言中，由于没有内置的动态数组类，实现起来更为复杂，需要直接操作内存。C语言中的动态数组通常使用`malloc()`和`realloc()`函数来分配和调整内存。以下是C语言实现动态数组的基本步骤：
1. 定义一个结构体，包含数组指针和当前元素数量。
2. 使用`malloc()`函数分配初始内存。
3. 添加元素时，当数组满时，使用`realloc()`分配更大的内存，并将现有元素复制到新内存区域。
4. 删除元素时，需要重新分配内存并手动调整元素位置。
在C语言中，动态数组的实现通常需要谨慎处理内存管理，避免内存泄漏和悬挂指针。以下是一个简单的C语言动态数组添加元素的示例：
```c
#include <stdio.h>
#include <stdlib.h>
typedef struct ArrayList {
int* data;
int size;
} ArrayList;
ArrayList* createArrayList(int initialSize) {
ArrayList* list = malloc(sizeof(ArrayList));
list->data = malloc(initialSize * sizeof(int));
list->size = initialSize;
return list;
}
void addElement(ArrayList* list, int value) {
if (list->size == 0) {
list->data = realloc(list->data, 1 * sizeof(int));
list->data[0] = value;
list->size = 1;
} else {
list->data = realloc(list->data, (list->size + 1) * sizeof(int));
list->data[list->size] = value;
list->size++;
}
}
void destroyArrayList(ArrayList* list) {
free(list->data);
free(list);
}
int main() {
ArrayList* list = createArrayList(0);
addElement(list, 5);
addElement(list, 8);
addElement(list, 10);
// 打印数组元素
for (int i = 0; i < list->size; i++) {
printf("%d ", list->data[i]);
}
// 清理
destroyArrayList(list);
return 0;
}
```
需要注意的是，C语言中的`realloc()`在扩展内存时可能会返回一个新地址，因此在使用前必须检查是否成功，并更新结构体中的数据指针。删除元素时，同样需要重新分配内存，然后手动移动元素，这可能涉及更多的代码和错误处理。
虽然Java和C语言作为静态类型语言，不支持像动态语言那样直接的动态数组操作，但通过自定义实现，我们可以模拟动态数组的行为，满足不同场景的需求。这两种实现方式各有优缺点，Java的方式更易于使用且不易出现内存问题，而C语言的实现则需要更多手动内存管理和错误检查。
