ArrayList的使用小技巧

1.首先我们看一块代码：

       List<String> list =new ArrayList<>();
        //获取一批数据的函数
        List<String> allData=getData();
        for (String str:allData) {
            list.add(str);
        }

这个代码，乍一看上去是没有问题的。并且在大部分情况都没问题，就是循环的往 ArrayList 中写入数据。但是数据量非常大时，list.add(str) 就会有问题了。

 

ArrayList 是由数组实现，而数据的长度有限；需要在合适的时机对数组扩容。默认的大小为10，扩容时新的长度=原有长度 * 1.5

但是并不是在初始化的时候就创建了 DEFAULT_CAPACITY=10 的数组，而是在往里边 add 第一个数据的时候会扩容到 10.扩容的时候会进行数组复制，(比如会10-->15，要重新开辟一块新的内存空间存放这 15 个元素的数组)。一旦我们频繁且数量巨大的进行写入时就会导致许多的数组复制，这个效率是极低的。

如果我们提前预知了可能会写入多少条数据时就可以提前避免这个问题。

以1000W 条数据为例子，在初始化的时候就给定数组长度与用默认 10 的长度之间性能是差距巨大的。做个实验：

新建一个maven项目，在pom.xml中导入JMH依赖，这里贴一下pom文件内容：便于大家复制

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.qax</groupId>
    <artifactId>yexuman</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-core</artifactId>
            <version>1.19</version>
        </dependency>
        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-generator-annprocess</artifactId>
            <version>1.19</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>


</project>

新建一个Test类

//参数iterations就是预热轮数
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)  //预热
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)  //测试
public class Test {

   public static final int TEN_MILLION=10000000;

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public void testArrayList(){
        //指定初始化大小
        List<String> list=new ArrayList<String>();
        for (int i=0;i<TEN_MILLION;i++){
            list.add("111");
        }
    }

   @Benchmark
   @BenchmarkMode(Mode.AverageTime)
   @OutputTimeUnit(TimeUnit.MICROSECONDS)
   public void testArrayListSize(){
         //指定初始化大小
         List<String> list=new ArrayList<String>(TEN_MILLION);
         for (int i=0;i<TEN_MILLION;i++){
             list.add("111");
         }
    }

    public static void main(String[] args) throws RunnerException {
        Options opt=new OptionsBuilder()
                .include(Test.class.getSimpleName())
                .forks(1).build();
        new Runner(opt).run();
    }
}

可以看到预设长度的效率会比用默认的效率高上很多（Score 指执行完函数所消耗的时间）。

JMH 基准测试  有不了解的同学可以参考这篇文章  https://www.jianshu.com/p/159f5ac0a1f4

2.现在我们来看看LinkedList

我们随便在网上一搜，就可以知道ArrayList和LinkedList的区别

LinkedList 基于双向链表。适合增删多的场景。理论上来说它的写入非常高效，将不会有 ArrayList 中效率极低的数组复制，每次只需要移动指针即可。

这里也来做一个测试，对比ArrayList(初始化赋值的)和LinkedList的写入效率。

//参数iterations就是预热轮数
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)  //预热
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)  //测试
public class Test {

   public static final int TEN_MILLION=10000000;

//    @Benchmark
//    @BenchmarkMode(Mode.AverageTime)
//    @OutputTimeUnit(TimeUnit.MICROSECONDS)
//    public void testArrayList(){
//        //指定初始化大小
//        List<String> list=new ArrayList<String>();
//        for (int i=0;i<TEN_MILLION;i++){
//            list.add("111");
//        }
//    }

   @Benchmark
   @BenchmarkMode(Mode.AverageTime)
   @OutputTimeUnit(TimeUnit.MICROSECONDS)
   public void testArrayListSize(){
         //指定初始化大小
         List<String> list=new ArrayList<String>(TEN_MILLION);
         for (int i=0;i<TEN_MILLION;i++){
             list.add("111");
         }
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public void testLinkedList(){
        List<String> list=new LinkedList<String>();
        for (int i=0;i<TEN_MILLION;i++){
            list.add("111");
        }
    }


    public static void main(String[] args) throws RunnerException {
        Options opt=new OptionsBuilder()
                .include(Test.class.getSimpleName())
                .forks(1).build();
        new Runner(opt).run();
    }
}

根据结果可以看到，

写入 1000W 次数据，初始化数组长度的 ArrayList 效率明显是要高于 LinkedList 。因为预设 ArrayList 的数组长度，避免了数组扩容，所以 ArrayList 的写入效率非常高，而 LinkedList 的虽然不需要复制内存，但却需要创建对象，变换指针等操作。

总结：

1.使用ArrayList 时如果可以提前预测到数据量大小，比较大时一定要指定其长度。（提高效率）

2.以此类推，另外一个常用的容器HashMap也会扩容（*2），也是在数据量较大时推荐初始化长度而避免频繁扩容。