文章结构：
数组看起来简单基础，但是很多人没有理解这个数据结构的精髓。带着为什么数组要从0开始编号，而不是从1开始的问题，进入主题。
1.    数组如何实现随机访问
1）    数组是一种线性数据结构，用连续的存储空间存储相同类型数据
I）    线性表：数组、链表、队列、栈 非线性表：树 图
II）    连续的内存空间、相同的数据，所以数组可以随机访问，但对数组进行删除插入，为了保证数组的连续性，就要做大量的数据搬移工作
a)    数组如何实现下标随机访问。
引入数组再内存种的分配图，得出寻址公式
b)    纠正数组和链表的错误认识。数组的查找操作时间复杂度并不是O(1)。即便是排好的数组，用二分查找，时间复杂度也是O（logn）。
正确表述：数组支持随机访问，根据下标随机访问的时间复杂度为O（1）
2.    低效的插入和删除
1）    插入：从最好O(1) 最坏O(n) 平均O(n)
2）    插入：数组若无序，插入新的元素时，可以将第K个位置元素移动到数组末尾，把心的元素，插入到第k个位置，此处复杂度为O(1)。作者举例说明
3）    删除：从最好O(1) 最坏O(n) 平均O(n)
4）    多次删除集中在一起，提高删除效率
记录下已经被删除的数据，每次的删除操作并不是搬移数据，只是记录数据已经被删除，当数组没有更多的存储空间时，再触发一次真正的删除操作。即JVM标记清除垃圾回收算法。
3.    警惕数组的访问越界问题
用C语言循环越界访问的例子说明访问越界的bug。此例在《C陷阱与缺陷》出现过，很惭愧，看过但是现在也只有一丢丢印象。翻了下书，替作者加上一句话：如果用来编译这段程序的编译器按照内存地址递减的方式给变量分配内存，那么内存中的i将会被置为0，则为死循环永远出不去。
4.    容器能否完全替代数组
相比于数字，java中的ArrayList封装了数组的很多操作，并支持动态扩容。一旦超过村塾容量，扩容时比较耗内存，因为涉及到内存申请和数据搬移。
数组适合的场景：
1）    Java ArrayList 的使用涉及装箱拆箱，有一定的性能损耗，如果特别管柱性能，可以考虑数组
2）    若数据大小事先已知，并且涉及的数据操作非常简单，可以使用数组
3）    表示多维数组时，数组往往更加直观。
4）    业务开发容器即可，底层开发，如网络框架，性能优化。选择数组。
5.    解答开篇问题
1）    从偏移角度理解a[0] 0为偏移量，如果从1计数，会多出K-1。增加cpu负担。为什么循环要写成for(int i = 0;i<3;i++) 而不是for(int i = 0 ;i<=2;i++)。第一个直接就可以算出3-0 = 3 有三个数据，而后者 2-0+1个数据，多出1个加法运算，很恼火。
2）    也有一定的历史原因

1. 我认为文中更准确的说法可能是标记-整理垃圾回收算法。标记-清除算法在垃圾收集时会先标记出需要回收的对象，标记完成后统一回收所有被标记的对象。清除之后会产生大量不连续的内存碎片。标记-整理垃圾回收算法在标记完成之后让所有存活的对象都向一端移动，然后直接清理掉边界以外的内存。
2. 假设二维数组大小为m*n，那么寻址公式为
a[i][j]_address = base_address + (i * n+j)*data_type_size

3. C语言变量的内存申请可以看做是地址按照从大到小连续申请的，因为i在arr前面申请，所以arr[3]的地址和i的地址相同。

例如对于如下代码：
int i = 0;int j = 1;int k = 2; int arr[3] = {0}; cout<<"i-"<<&i<<endl;
cout<<"j-"<<&j<<endl;
cout<<"k-"<<&k<<endl;
cout<<"arr-"<<&arr<<endl;
cout<<"arr3-"<<&arr[3]<<endl;

运行结果：
i-0x28ff0c

j-0x28ff08

k-0x28ff04

arr-0x28fef8

arr3-0x28ff04

————总结一下————

什么是数组

数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。



1.线性表
线性表就是数据排成像一条线一样的结构。
常见的线性表结构：数组，链表、队列、栈等。

2. 连续的内存空间和相同类型的数据

优点：两限制使得具有随机访问的特性
缺点：删除，插入数据效率低

数组怎么根据下标随机访问的？

通过寻址公式，计算出该元素存储的内存地址：
a[i]_address = base_address + i * data_type_size

为何数组插入和删除低效

插入：
若有一元素想往int[n]的第k个位置插入数据，需要在k-n的位置往后移。
最好情况时间复杂度 O(1)
最坏情况复杂度为O(n)
平均负责度为O(n)

如果数组中的数据不是有序的，也就是无规律的情况下，可以直接把第k个位置上的数据移到最后，然后将插入的数据直接放在第k个位置上。

这样时间复杂度就将为 O（1）了。

删除：
与插入类似，为了保持内存的连续性。
最好情况时间复杂度 O(1)
最坏情况复杂度为O(n)
平均负责度为O(n)

提高效率：将多次删除操作中集中在一起执行，可以先记录已经删除的数据，但是不进行数据迁移，而仅仅是记录，当发现没有更多空间存储时，再执行真正的删除操作。这也是 JVM 标记清除垃圾回收算法的核心思想。

数组访问越界问题
C语言中的数据越界是一种未决行为，一般比较难发现的逻辑错误。相比之下，Java会有越界检查。

用数组还是容器？
数组先指定了空间大小
容器如ArrayList可以动态扩容。
1.希望存储基本类型数据，可以用数组
2.事先知道数据大小，并且操作简单，可以用数组
3.直观表示多维，可以用数组
4.业务开发，使用容器足够，开发框架，追求性能，首先数组。

为什么数组要从 0 开始编号？
由于数组是通过寻址公式，计算出该元素存储的内存地址：
a[i]_address = base_address + i * data_type_size
如果数组是从 1 开始计数，那么就会变成：
a[i]_address = base_address + （i-1）* data_type_size

对于CPU来说，多了一次减法的指令。
当然，还有一定的历史原因。

————课后思考————

1.我理解的JVM标记清除垃圾回收算法：在标记阶段会标记所有的可访问的对象，在清除阶段会遍历堆，回收那些没有被标记的对象。现在想想，和「如果数组中的数据不是有序的，也就是无规律的情况下，可以直接把第k个位置上的数据移到最后，然后将插入的数据直接放在第k个位置上。」思想类似。

2. 对于一维数组：a[i]_address = base_address + （i）* data_type_size
二维数组如果是m*n，那么a[i][j]== base_address + （i*n+j）* data_type_size。
2.

汇总一下各位大神关于那段代码无限循环的总结：
这段代码无限循环原因有2，以及一个附加条件:
1.栈空间从高往低依次分配，i占4字节，接着arr占12字节，内存从高往低是这样：存i的4字节|arr[2]|arr[1]|arr[0]，数组访问是通过“baseAddr+index乘typeSize”得到，算下来当index=3时，刚好是i的地址
2.这里刚好满足字节对齐，系统为64位系统，字长64，那么字节对齐必须是8字节的倍数，刚好i变量和arr变量占了16字节，对齐了
如果这里将arr[3]改为arr[4]，为了对齐，内存从高往低是这样：存i的4字节|空4字节|arr[3]|arr[2]|arr[1]|arr[0]，那么arr[4]刚好是空的4字节，无法影响到i的值，则并不会无限循环

附加条件：编译时gcc默认会自动添加越界保护，此处要达到无限循环效果，编译时需加上-fno-stack-protector去除该保护

对于无线循环那个问题解释

个人认为应该按照这样的顺序声明：
int arr［3］＝｛0｝;
int i;
因为在计算机中程序一般顺序分配存储空间，这样声明，首先分配0 1 2三个存储单元给数组arr，然后再分配 4 存储单元给变量i，然后根据数组访问公式即会出现无线循环。
不知道对不对，还请老师指点。