我们的计算机中能够存储数据的东西有内存，外存等等

内存的读写速度优于外存很多很多，但是由于其成本高的特点，一般只适用于做短时存储读取，也就是说，当我们的电脑关闭的时候，内存中的数据就全部消失了。与之相比，外存也就是磁盘，是致力于实现数据持久化技术的

了解过一些硬件的人应该知道，我们的磁盘是由很多个个圆形磁道组成的，每个磁道上又分成很多个小块，用来存储数据，如下图所示：

因为小块的数量很多很多，再加上为了便于理解，我们可以将这些数据存储单元抽象为下图这样的平面矩形分块：

到现在为止，我们将基本的数据存储模型建立完毕了，下面我们来比较一下内存和外存中存储结构的差异

外存

假设我们有一段数据，大小需要占满3个格子，那么我们在外存中应该如何选择格子来存储呢？

假如我们直接选择相邻的3个格子来存储数据，如下图棕色区域所示：

这样，我们当读取这段数据的时候，直接通过第一个棕色格子的地址，就可以找到这段数据把它读出来，这不是挺好的吗？

但是，当我们存储了很多数据之后，我们就发现了问题所在了

假设我们又存储了一段大小为4个格子的数据，存储了一段大小为两个格子的数据，存储了大小为7个格子的数据，存储了大小为1个格子的数据，存储了大小为8个格子的数据

用一种颜色代表一段数据，可以看到，我们的磁盘存储容量已经被占满了：

这时，我们想要删除绿色的和蓝色的数据，如图：

删除之后，按理说我们的磁盘已经空出了三个格子的空间，可以存储大小为三个格子的数据了，但是由于我们是顺序存储，所以上面的两个格子和下面的一个格子连不到一起，意味着我们只能再存进去两个格子的数据和一个格子的数据，并不能存进去三个格子的。

也就是说，如果按照顺序存储，用到最后，我们的磁盘只能存入比较小的数据了，明明容量充足，却没法存进去大的数据，岂不是很难受？

有人可能要说了，我们可以通过删除之后把后面的数据移到前面来填补上前面的格子来达到，就像玩电脑游戏里的整理背包一样。但是如果这样的话，我们每次删除一个数据都要把这个数据后面的数据向前移动（更改数据的存储地址），这样对性能的影响非常严重，所以，显然，我们的磁盘不是用这种方式来存储数据的，而是用下面这种：

这就是磁盘的存储方式——链式存储，这种方式能最大限度的利用磁盘的空间。

内存

上述的链式存储方式虽然最大限度地利用了磁盘的存储空间但是毕竟在增删改查的数据操作上的速度不如顺序存储，对于内存来说，因为它的读写速度非常非常快，因此我们上述的每次删除之后的重新整理的速度也非常快，因此我们的内存使用的是顺序存储方式，这样不会速度很慢，而且也方便了增删改查的操作。

问题一（最多可以存储多少条数据）

答案先放在上面 Integer.MAX_VALUE 2147483647
简单解释arraylist底层是一个数组对象Object[] arr = new Object[10]; 数组的大小只能设置int类型。想进一步了解可以看后面的源码部分

//这样会直接编译报错
Long len = 10L;
Object[] arr = new Object[len];

问题二 ，存储到最大之后再进行add会出现什么情况

准确的说会抛出来内存不足异常。throw new OutOfMemoryError();
感谢 如果時間不記得 大佬指正，给大佬敬茶。

Integer minCapacity = Integer.MAX_VALUE;
minCapacity++;
System.out.println(minCapacity);
 minCapacity = -2147483648;

// arraylist 代码块
private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }


 if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();

为什么（why？）

首先list在被创建出来时会存放在jvm堆内存中，假设一个对象为1kb的大小，存放10个对象的数组大小就是10kb。而数组最大限制是2147483647，这就要求硬件内存超过2147483647kb（实际使用中可能需要2147483647kb*2 因为list在add的时候是需要扩容的，除非你在创建的时候指定大小为最大值，否则你在add的时候超过内存阀值会直接抛出内存溢出）。

代码块摘自jdk1.8 java.util.ArrayList。 里面都标注好了注释，希望可以帮助你愉快的阅读完。

ArrayList中add运行的代码块

//当前集合对象
transient Object[] elementData;

//当前集合大小
private int size;


//arraylist  add对象的方法  本文问题的源头
public boolean add(E e) {
        ensureCapacityInternal(size + 1); 
        elementData[size++] = e;
        return true;
    }

//这个方法是判断的当前数组容量是否需要扩容，需要的话扩容
//如果需要扩容 扩容之前我们需要设定新数组的大小
//那么就是先确定新数组大小，然后初始化一个新容器将旧的数据copy到新容器里面
//elementData 表示的是当前数组对象
//minCapacity 这个是上个add方法调用的  集合当前大小+1
private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private static final int DEFAULT_CAPACITY = 10;

//DEFAULTCAPACITY_EMPTY_ELEMENTDATA是一个空数组
//DEFAULT_CAPACITY为10
//如果是空对象，也就是刚初始化里面还没有存入值返回默认大小
private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

//minCapacity 上一个方法返回的数值
//modCount++  与本文问题无关，这个值是关于迭代器迭代的时候用来保证线程安全方面的东西
//如果  集合当前size+1 - 当前集合数量 大于0  则grow 成长（扩容）  
//看到这里已经改就明白了吧 问题的解码就都在grow函数里
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

//minCapacity  集合当前size+1 
//oldCapacity 当前数组大小  
//newCapacity 当前数组大小  + 当前数组大小的一半，也就是默认扩容机制是0.5倍扩容
//重点来了 newCapacity - MAX_ARRAY_SIZE 
//MAX_ARRAY_SIZE 为int最大值-8
//如果新数组大小- （int最大值-8）>0 则看hugeCapacity
// Arrays.copyOf(elementData, newCapacity);  创建一个大小为newCapacity的集合，将就数据copy进去。
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }


//minCapacity  集合当前size+1 
//如果 集合当前size+1  > 数组最大值 则返回int最大值
//大体意思 数组在扩容到 （int最大值-8)之后，还没存满默认还是使用（int最大值-8)
//存满之后使用Integer.MAX_VALUE 所以最多可以存Integer.MAX_VALUE
private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

回过头来分析

源码分析完了以后我们在回过头来看add方法存满之后发生什么呢？

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

当size达到int最大值以后，size++ 这个运算并不会报错（具体可以看java中的int类型计算），那存满之后再存值为什么会数组越界呢

为什么数组越界

public static void main(String[] args) {
        Integer aa = Integer.MAX_VALUE;
        aa++;
        System.out.println(aa);
        Object[] arr = new Object[aa];
        arr[aa] = 11;
    }

//代码执行结果
-2147483648
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -2147483648

业务中真的碰到了怎么解决

知道问题的发生原理与实际运行情况之后我们在回过头来分析，如果真的有业务场景需要存储大量的数据但是不知道数组大小的情况下，我们该怎么办呢。

链表形式存储(LinkedList)

为避免大量的扩容导致内存溢出，可以选择使用LinkedList,它里面是链表的结构，并不会有大小限制，不过使用它的话取值只能通过循环比较去取值，在保证内存够用的情况下，理论上可以想存多少存多少。但是取值效率会因为值太多效率极低。可以简单看下(LinkedList)里面的实现

private static class Node<E> {
        E item; // 当前对象
        Node<E> next;//当前对象的下一个引用地址
        Node<E> prev;//当前对象的上一个引用地址

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

map分级存储

如果即想存多一些的数据又想查询快一些可以通过所存的对象中的业务逻辑划分为map对象存储，比如学生表中有type，优/良/差 ，type为key，list为value，但是key分级少了，数据还是会很多，可以考虑多层分级，比如type基础上按年纪，班级再分层，到最后不就越来越少，插值或者查询都可以提高效率。

数据库（mysql，oracle等）

真的有这样大的数据肯定还是存到数据库中是最好的方式。如果这么大的数据集合直接放在内存中，那要数据库干什么。