章节七、3-ArrayList和LinkedList对比

一、创建集合并添加元素（从末尾位置添加）

package ZangJie7;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LinkedListDemo {
    /***
     * ArrayList 底层是数据实现的，是连续的空间{0,1,2,3,4,5,6},如果从最后的位置增除的话，用ArrayList比较快，
       *   用ArrayList增删元素时，会造成原素位空缺，其它已经存在的元素会向前或者向后移动，影响程序效率。
          
     * LinkedList 如果从最开始的位置删除的话，用LinkedList 比较快
     *  LinkedList是使用索引存储元素，采用的是手拉手的形式，增删时不会带来元素的移动，所以效率比ArrayList要快。
     */

    public static void main(String[] args) {
        List <Integer> alist = new ArrayList<Integer>();
        List<Integer> llist = new LinkedList<Integer>();
        runDuration(alist,"ArrayList");
        runDuration(llist,"LinkedList");
    }
        public static void runDuration(List<Integer> list,String listType){
            System.out.println("\n duration方法的开始，用的集合是："+listType);
            //记录开始时当前时间
            long startTime = System.currentTimeMillis();
            for(int i = 0;i<100000;i++) {
                list.add(i);
            }
            //记录结束时当前时间
            long endTime = System.currentTimeMillis();
            //持续时间
            long duration = endTime-startTime;
            System.out.println("集合"+listType+"用时为"+duration+"毫秒");
        }
    
        }
    

 

二、计算集合大小

package ZangJie7;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LinkedListDemo {
    /***
     * ArrayList 底层是数据实现的，是连续的空间{0,1,2,3,4,5,6},如果从最后的位置增除的话，用ArrayList比较快，
       *   用ArrayList增删元素时，会造成原素位空缺，其它已经存在的元素会向前或者向后移动，影响程序效率。
          
     * LinkedList 如果从最开始的位置删除的话，用LinkedList 比较快
     *  LinkedList是使用索引存储元素，采用的是手拉手的形式，增删时不会带来元素的移动，所以效率比ArrayList要快。
     */

    public static void main(String[] args) {
        List <Integer> alist = new ArrayList<Integer>();
        List<Integer> llist = new LinkedList<Integer>();
        runDuration(alist,"ArrayList");
        runDuration(llist,"LinkedList");
    }
        public static void runDuration(List<Integer> list,String listType){
            System.out.println("\n duration方法的开始，用的集合是："+listType);
            for(int i = 0;i<100000;i++) {
                list.add(i);
            }
            //获取集合大小
            int size = list.size();
            //添加元素
            int elementToAdd = size + 10000;
            
            System.out.println("第一次添加的元素个数为："+elementToAdd);

            //记录开始时当前时间
            long startTime = System.currentTimeMillis();
            for(int i = size;i<elementToAdd;i++) {
                list.add(i);
            }
            System.out.println("第一次添加的元素个数为："+list.size());
            //记录结束时当前时间
            long endTime = System.currentTimeMillis();
            //持续时间
            long duration = endTime-startTime;
            System.out.println("集合"+listType+"用时为"+duration+"毫秒");
        }
        }

从运行结果看，LinkedLst比ArrayList运行耗时更少，效率更高。

 

三、在指定索引位上加元素

package ZangJie7;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LinkedListDemo {
    /***
     * ArrayList 底层是数据实现的，是连续的空间{0,1,2,3,4,5,6},如果从最后的位置增除的话，用ArrayList比较快，
       *   用ArrayList增删元素时，会造成原素位空缺，其它已经存在的元素会向前或者向后移动，影响程序效率。
          
     * LinkedList 如果从最开始的位置删除的话，用LinkedList 比较快
     *  LinkedList是使用索引存储元素，采用的是手拉手的形式，增删时不会带来元素的移动，所以效率比ArrayList要快。
     */

    public static void main(String[] args) {
        List <Integer> alist = new ArrayList<Integer>();
        List<Integer> llist = new LinkedList<Integer>();
        runDuration(alist,"ArrayList");
        runDuration(llist,"LinkedList");
    }
        public static void runDuration(List<Integer> list,String listType){
            System.out.println("\n duration方法的开始，用的集合是："+listType);
            for(int i = 0;i<100000;i++) {
                list.add(i);
            }
            //获取集合大小
            int size = list.size();
            //添加元素
            int elementToAdd = size + 10000;
            
            System.out.println("第一次添加的元素个数为："+elementToAdd);

            //记录开始时当前时间
            long startTime = System.currentTimeMillis();
            for(int i = size;i<elementToAdd;i++) {
            //    list.add(i);
                list.add(0, i);
            }
            System.out.println("第一次添加的元素个数为："+list.size());
            //记录结束时当前时间
            long endTime = System.currentTimeMillis();
            //持续时间
            long duration = endTime-startTime;
            System.out.println("集合"+listType+"用时为"+duration+"毫秒");
        }
        }

从运行结果看，在指定位置插入值时，LinkedLst比ArrayList运行耗时要少，效率更高。

 

 

四、从尾部删减元素

package ZangJie7;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LinkedListDemo {
    /***
     * ArrayList 底层是数据实现的，是连续的空间{0,1,2,3,4,5,6},如果从最后的位置增除的话，用ArrayList比较快，
       *   用ArrayList增删元素时，会造成原素位空缺，其它已经存在的元素会向前或者向后移动，影响程序效率。
          
     * LinkedList 如果从最开始的位置删除的话，用LinkedList 比较快
     *  LinkedList是使用索引存储元素，采用的是手拉手的形式，增删时不会带来元素的移动，所以效率比ArrayList要快。
     */

    public static void main(String[] args) {
        List <Integer> alist = new ArrayList<Integer>();
        List<Integer> llist = new LinkedList<Integer>();
        runDuration(alist,"ArrayList");
        runDuration(llist,"LinkedList");
    }
        public static void runDuration(List<Integer> list,String listType){
            System.out.println("\n duration方法的开始，用的集合是："+listType);
            for(int i = 0;i<100000;i++) {
                list.add(i);
            }
            //获取集合大小
            int size = list.size();
            //添加元素
            int elementToAdd = size + 10000;
            
            System.out.println("第一次添加的元素个数为："+elementToAdd);

            //记录开始时当前时间
            long startTime = System.currentTimeMillis();
            /*for(int i = size;i<elementToAdd;i++) {
            //    list.add(i);
                list.add(0, i);
            }*/
            
            for(int i = 90000;i<92000;i++) {
                    list.remove(i);
                }
            System.out.println("第一次添加的元素个数为："+list.size());
            //记录结束时当前时间
            long endTime = System.currentTimeMillis();
            //持续时间
            long duration = endTime-startTime;
            System.out.println("集合"+listType+"用时为"+duration+"毫秒");
        }
        }

从运行结果看，从尾部开始删减元素，ArrayList比LinkedLst运行耗时要少，效率更高。

五、从首部开始删减元素

package ZangJie7;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LinkedListDemo {
    /***
     * ArrayList 底层是数据实现的，是连续的空间{0,1,2,3,4,5,6},如果从最后的位置增除的话，用ArrayList比较快，
       *   用ArrayList增删元素时，会造成原素位空缺，其它已经存在的元素会向前或者向后移动，影响程序效率。
          
     * LinkedList 如果从最开始的位置删除的话，用LinkedList 比较快
     *  LinkedList是使用索引存储元素，采用的是手拉手的形式，增删时不会带来元素的移动，所以效率比ArrayList要快。
     */

    public static void main(String[] args) {
        List <Integer> alist = new ArrayList<Integer>();
        List<Integer> llist = new LinkedList<Integer>();
        runDuration(alist,"ArrayList");
        runDuration(llist,"LinkedList");
    }
        public static void runDuration(List<Integer> list,String listType){
            System.out.println("\n duration方法的开始，用的集合是："+listType);
            for(int i = 0;i<100000;i++) {
                list.add(i);
            }
            //获取集合大小
            int size = list.size();
            //添加元素
            int elementToAdd = size + 10000;
            
            System.out.println("第一次添加的元素个数为："+elementToAdd);

            //记录开始时当前时间
            long startTime = System.currentTimeMillis();
            //添加元素
            /*for(int i = size;i<elementToAdd;i++) {
            //    list.add(i);
                list.add(0, i);
            }*/
            
            /*//从尾部开始删减元素添加元素
            for(int i = 90000;i<92000;i++) {
                    list.remove(i);
                }*/
            
            //从首部开始删减元素添加元素
            for(int i = 0;i<100;i++) {
                    list.remove(i);
                }
            System.out.println("第一次添加的元素个数为："+list.size());
            //记录结束时当前时间
            long endTime = System.currentTimeMillis();
            //持续时间
            long duration = endTime-startTime;
            System.out.println("集合"+listType+"用时为"+duration+"毫秒");
        }
        }

从运行结果看，从首部开始删减原始，LinkedLst比ArrayList运行耗时要少，效率更高。