其实这两个数据结构蛮好玩的，都是List列表存储
    1.ArrayList底层是数组存储，LinkedList底层是基于双向链表存储的
    2.由于底层存储方式不同，一些特性也就由此展现。
    3.数组存储：添加删除操作都是比较浪费存储时间的，以为每一次操作，都要进行数据的迁移。但是对于数据经常查询.get()方法的时候，Array的优势就体现了。基于链表存储，他的添加删除操作是比较快的，但查询来说就相对较慢，因为他需要遍历每一个节点，从而得倒想要的数据。

    1. package com.zhangyi;
    3. import java.util.ArrayList;
    4. import java.util.LinkedList;
    5. import java.util.List;
    7. public class compare {
    8.     static final int N=100000;
    9.     static long timeList(List list){
    10.         long start=System.currentTimeMillis();
    11.         Object o = new Object();
    12.         for(int i=0;i<N;i++) {
    13.             list.add(0, o);
    14.         }
    15.         return System.currentTimeMillis()-start;
    16.     }
    17.     static long readList(List list){
    18.         long start=System.currentTimeMillis();
    19.         for(int i=0,j=list.size();i<j;i++){
    21.         }
    22.         return System.currentTimeMillis()-start;
    23.     }
    25.     static List addList(List list){
    26.         Object o = new Object();
    27.         for(int i=0;i<N;i++) {
    28.             list.add(0, o);
    29.         }
    30.         return list;
    31.     }
    32.     public static void main(String[] args) {
    33.         System.out.println("ArrayList添加"+N+"条耗时："+timeList(new ArrayList()));
    34.         System.out.println("LinkedList添加"+N+"条耗时："+timeList(new LinkedList()));
    36.         List list1=addList(new ArrayList<>());
    37.         List list2=addList(new LinkedList<>());
    38.         System.out.println("ArrayList查找"+N+"条耗时："+readList(list1));
    39.         System.out.println("LinkedList查找"+N+"条耗时："+timeList(list2));
    40.     }
    41. }
    1. /Library/Java/JavaVirtualMachines/jdk-11.0.1.jdk/Contents/Home/bin/java "-javaagent:/Applications/IntelliJ IDEA.app/Contents/lib/idea_rt.jar=52811:/Applications/IntelliJ IDEA.app/Contents/bin" -Dfile.encoding=UTF-8 -classpath /opt/dev/java/Course/out/production/Course:/Users/zhangyi/.m2/repository/org/junit/jupiter/junit-jupiter-api/5.3.1/junit-jupiter-api-5.3.1.jar:/Users/zhangyi/.m2/repository/org/apiguardian/apiguardian-api/1.0.0/apiguardian-api-1.0.0.jar:/Users/zhangyi/.m2/repository/org/opentest4j/opentest4j/1.1.1/opentest4j-1.1.1.jar:/Users/zhangyi/.m2/repository/org/junit/platform/junit-platform-commons/1.3.1/junit-platform-commons-1.3.1.jar:/Users/zhangyi/.m2/repository/junit/junit/4.12/junit-4.12.jar:/Users/zhangyi/.m2/repository/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar com.zhangyi.compare
    2. ArrayList添加100000条耗时：523
    3. LinkedList添加100000条耗时：6
    4. ArrayList查找100000条耗时：1
    5. LinkedList查找100000条耗时：2
    7. Process finished with exit code 0

    通过这个小程序，可以清楚的发现查找如果对于数据存储而言，如果Arraylist进行添加数据，除了在尾部添加效率相对较高，但是还要考虑扩容问题，那么LinkedList就比较划算了，而数据查找起来，ArrayList相对Linkedlist优势比较明显。所以我觉得若果在数据库读取数据的时候存储应该优先考虑将数据保存为ArrayList格式。