一、提出问题
为什么数组要从0开始编号，而不是从1开始呢？从1开始不是更符合人类的思维习惯吗？
如何实现随机访问？
二、数组概述
数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据
关键词理解
线性表
- 线性表就是数据排成像一条线一样的结构，每个线性表上的数据最多只有前和后两个方向，其实除了数组，链表、队列、栈等也是线性表结构
- 相对立的概念是非线性表，比如二叉树、堆、图等，在非线性表中，数据之间并不是简单的前后关系
连续的内存空间和相同类型的数据
要想在数组中删除、插入一个数据，为了保证连续性，就需要做大量的数据搬移工作
数组是如何实现根据下标随机访问数组元素的？
拿一个长度为10的int类型的数组int[] a = new int[10]来举例，在这个图中，计算机给数组a[10]，分配了一块连续内存空间1000～1039，其中，内存块的首地址为base_address = 1000
计算机会给每个内存单元分配一个地址，计算机通过地址来访问内存中的数据，当计算机需要随机访问数组中的某个元素时，它会首先通过下面的寻址公式，计算出该元素存储的内存地址：a[i]_address = base_address + i * data_type_sizedata_type_size表示数组中每个元素的大小，数组中存储的是int类型数据，所以data_type_size就为4个字节
数组和链表的区别？
常常不准确的回答：链表适合插入、删除，时间复杂度O(1)；数组适合查找，查找时间复杂度为O(1）
数组是适合查找操作，但是查找的时间复杂度并不为O(1)。即便是排好序的数组，你用二分查找，时间复杂度也是O(logn)。所以，正确的表述应该是，数组支持随机访问，根据下标随机访问的时间复杂度为O(1)
三、数组操作
提出问题：数组为了保持内存数据的连续性，会导致插入、删除这两个操作比较低效，究竟为什么会导致低效？又有哪些改进方法呢？
- 插入操作
假设数组的长度为n，要将一个数据插入到数组中的第k个位置
末尾：不需要移动数据，时间复杂度为O(1)
开头：所有的数据都需要依次往后移动一位，最坏时间复杂度是O(n)，平均情况时间复杂度为(1+2+…n)/n=O(n）
如果数组中存储的数据并没有任何规律，数组只是被当作一个存储数据的集合。在这种情况下，如果要将某个数组插入到第k个位置，为了避免大规模的数据搬移，直接将第k位的数据搬移到数组元素的最后，把新的元素直接放入第k个位置，在第k个位置插入一个元素的时间复杂度就会降为O(1)
- 删除操作
要删除第k个位置的数据，为了内存的连续性，也需要搬移数据
末尾：最好情况时间复杂度为O(1)
开头：最坏情况时间复杂度为O(n)，平均情况时间复杂度也为O(n)
在某些特殊场景下，我们并不一定非得追求数组中数据的连续性。如果我们将多次删除操作集中在一起执行，删除的效率是不是会提高很多呢？
数组a[10]中存储了8个元素：a，b，c，d，e，f，g，h。现在，我们要依次删除a，b，c三个元素
先记录下已经删除的数据，每次的删除操作并不是真正地搬移数据，只是记录数据已经被删除，当数组没有更多空间存储数据时，我们再触发执行一次真正的删除操作，这样就大大减少了删除操作导致的数据搬移
这就是JVM标记清除垃圾回收算法的核心思想
四、注意问题
- 警惕数组的访问越界问题
实例分析：
int main(int argc, char* argv[]){
int i = 0;
int arr[3] = {0};
for(; i<=3; i++){
arr[i] = 0;
printf("hello world\n");
}
return 0;
}
结果会无限打印“hello world”，数组大小为3，a[0]，a[1]，a[2]，代码因为书写错误，导致for循环的结束条件错写为了i<=3而非i<3，所以当i=3时，数组a[3]访问越界
在C语言中，只要不是访问受限的内存，所有的内存空间都是可以自由访问的，根据我们前面的数组寻址公式，a[3]也会被定位到某块不属于数组的内存地址上，而这个地址正好是存储变量i的内存地址，那么a[3]=0就相当于i=0，所以就会导致代码无限循环
对于数组访问越界造成无限循环，编译器的问题，对于不同的编译器，在内存分配时，会按照内存地址递增或递减的方式进行分配。如果是内存地址递减的方式，就会造成无限循环
数组越界在C语言中是一种未决行为，并没有规定数组访问越界时编译器应该如何处理。因为访问数组的本质就是访问一段连续内存，只要数组通过偏移计算得到的内存地址是可用的，那么程序就可能不会报任何错误
很多计算机病毒也是利用到了代码中的数组越界可以访问非法地址的漏洞，来攻击系统，所以写代码的时候一定要警惕数组越界
Java本身就会做越界检查，比如int[] a = new int[3]; a[3] = 10;就会抛出java.lang.ArrayIndexOutOfBoundsException
- 容器能否完全替代数组？
什么时候适合用数组，什么时候适合用容器呢？
ArrayList最大的优势就是可以将很多数组操作的细节封装起来，比如前面提到的数组插入、删除数据时需要搬移其他数据等，另外，它还有一个优势，就是支持动态扩容
ArrayList在存储空间不够的时候，会将空间自动扩容为1.5倍大小，但是扩容操作涉及内存申请和数据搬移，是比较耗时的，如果事先能确定需要存储的数据大小，最好在创建ArrayList的时候事先指定数据大小
总结
- Java ArrayList无法存储基本类型，比如int、long，需要封装为Integer、Long类，而Autoboxing、Unboxing则有一定的性能消耗，所以如果特别关注性能，或者希望使用基本类型，就可以选用数组
- 如果数据大小事先已知，并且对数据的操作非常简单，用不到ArrayList提供的大部分方法，也可以直接使用数组
- 当要表示多维数组时，用数组往往会更加直观，比如Object[][] array；而用容器的话则需要这样定义：ArrayList array
对于业务开发，直接使用容器就足够了，省时省力，毕竟损耗一丢丢性能，完全不会影响到系统整体的性能，但如果你是做一些非常底层的开发，比如开发网络框架，性能的优化需要做到极致，这个时候数组就会优于容器，成为首选
- 解答开篇：为什么大多数编程语言中，数组要从0开始编号，而不是从1开始呢？
从数组存储的内存模型上来看，“下标”最确切的定义是“偏移（offset）”，如果用a来表示数组的首地址，a[0]就是偏移为0的位置（首地址），a[k]就表示偏移k个type_size的位置，计算a[k]的内存地址只需要用这个公式：a[k]_address = base_address + k * type_size
如果数组从1开始计数，计算数组元素a[k]的内存地址就会变为：a[k]_address = base_address + (k-1)*type_size
从1开始编号，每次随机访问数组元素都多了一次减法运算，对于CPU来说，多了一次减法指令，还有便是历史原因，C语言设计者用0开始计数数组下标，之后的高级语言继续沿用了从0开始计数的习惯 - 思考问题
- 标记清除垃圾回收算法
大多数主流虚拟机采用可达性分析算法来判断对象是否存活，在标记阶段，会遍历所有 GC ROOTS，将所有 GC ROOTS 可达的对象标记为存活。只有当标记工作完成后，清理工作才会开始。
不足：1.效率问题：标记和清理效率都不高，但是当知道只有少量垃圾产生时会很高效
2.空间问题：会产生不连续的内存空间碎片 - 二维数组的内存寻址公式
对于 m * n 的数组a [ i ][ j ] (i < m,j < n)的地址为：address = base_address + ( i * n + j) * type_size
五、代码实现
package com.mys.array;
public class GenericArray<T> {
private T[] data;
private int size;
//根据传入容量，构造Array
public GenericArray(int capacity) {
data = (T[]) new Object[capacity];
size = 0;
}
//无参构造函数，默认数组容量10
public GenericArray() {
this(10);
}
//获取数组容量
public int getCapacity() {
return data.length;
}
//获取当前元素个数
public int count() {
return size;
}
//判断数组是否为空
public boolean isEmpty() {
return size == 0;
}
//获取对应index位置的元素
public T get(int index) {
checkIndex(index);
return data[index];
}
//查看数组中是否包含元素e
public boolean contains(T e) {
for (int i = 0; i < size; i ++) {
if (data[i].equals(e)) {
return true;
}
}
return false;
}
//获取对应元素的下标
public int find(T e) {
for (int i = 0; i < size; i ++) {
if (data[i].equals(e)) {
return i;
}
}
return -1;
}
//在index位置插入元素e，时间复杂度O(m+n)
public void add(int index, T e) {
checkIndex(index);
//如果当前元素个数等于数组容量，则将数组扩容为原来的两倍
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 ++;
}
//向数组头插入元素
public void addFirst(T e) {
add(0, e);
}
//向数组尾插入元素
public void addLast(T e) {
add(size, e);
}
//删除index位置元素，并返回
public T remove(int index) {
checkIndexForRemove(index);
T ret = data[index];
for (int i = index + 1; i < size; i ++) {
data[i - 1] = data[i];
}
size --;
data[size] = null;
//缩容
if (size == data.length / 4 && data.length / 2 != 0) {
resize(data.length / 2);
}
return ret;
}
//删除第一个元素
public T removeFirst() {
return remove(0);
}
//删除最后一个元素
public T removeLast() {
return remove(size - 1);
}
//删除指定元素
public void removeElement(T e) {
int index = find(e);
if (index != -1) {
remove(index);
}
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append(String.format("Array size = %d, capacity = %d \n", size, data.length));
builder.append('[');
for (int i = 0; i < size; i ++) {
builder.append(data[i]);
if (i != size - 1) {
builder.append(", ");
}
}
builder.append(']');
return builder.toString();
}
//扩容方法,时间复杂度O(n)
private void resize(int capacity) {
T[] newData = (T[]) new Object[capacity];
for (int i = 0; i < size; i ++) {
newData[i] = data[i];
}
data = newData;
}
private void checkIndex(int index) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("Add failed|Required index >= 0 and index <= size.,");
}
}
private void checkIndexForRemove(int index) {
if(index < 0 || index >= size) {
throw new IllegalArgumentException("remove failed! Require index >=0 and index < size.");
}
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
