ArrayList与LinkedList详解-优快云博客

ArrayList 和LinkedList原理，代码实现，性能区别.

1，ArrayList 为什么查询快

数组和集合区别：动态大小，数组的长度是固定的，

ArrayList : 数组集合，内部使用数组实现的。

自定义ArrayList：如下：

public static void main(String[] args) throws Exception {
        MyArrayList myArrayList = new MyArrayList();
        //添加
        myArrayList.add(1);
        myArrayList.add(2);
        myArrayList.add(3);
        myArrayList.add(4);
        myArrayList.add(5);
        myArrayList.add(6);
        myArrayList.add(7);
        myArrayList.add(8);
        myArrayList.add(9);
        //修改
        myArrayList.set(1,70);

        //删除
        myArrayList.removeAt(1);
        System.out.println(myArrayList.size);
//        myArrayList.clear();
        for (int i=0;i<myArrayList.size;i++){
            System.out.print(myArrayList.get(i) + ",");
        }

    }

    //定义一个数组
    private Object[] objects = new Object[4];

    private int size = 0; //集合大小

    public int size(){
        return size;
    }

    //添加
    public void add(Object value){
        //判断是否可以放的下
        if(size >= objects.length){
            //动态扩容
            Object[] temp = new Object[objects.length * 2];
//            Arrays.copyOf(objects, objects.length * 2);
            for (int i = 0;i< objects.length;i++){
                temp[i] = objects[i];
            }
            objects = temp;
        }
        objects[size] = value;
        size++;
    }

    //修改
    public void set(int index,Object value) throws Exception{
        //验证
        if(index >= size || index < 0){
          throw new Exception("超出范围");
        }
        objects[index] = value;
    }

    //获取
    public Object get(int index) throws Exception{
        //验证
        if(index >= size || index < 0){
            throw new Exception("超出范围");
        }
        return objects[index];
    }

    //清空
    public void clear(){
        size = 0;
        objects = new Object[4];
    }

    public void removeAt(int index) throws Exception{
        //验证
        if(index >= size || index < 0){
            throw new Exception("超出范围");
        }

        for (int i = index+1; i<size; i++){
            objects[i-1] = objects[i];
        }
        size--;
    }

LinkList : 底层使用链表实现为什么查询慢..

自定义LinkedList 如下：

链表实现:包含node节点类

public static void main(String[] args) throws Exception {
        MyLinkedList myLinkedList = new MyLinkedList();
        //添加
        myLinkedList.add(1);
        myLinkedList.add(2);
        myLinkedList.add(3);
        myLinkedList.add(4);
        myLinkedList.add(5);
        myLinkedList.add(6);
        myLinkedList.add(7);
        myLinkedList.add(8);
        myLinkedList.add(9);
        //修改
        myLinkedList.set(1,70);
        //获取
        System.out.println(myLinkedList.get(8));
        //删除
        myLinkedList.removeAt(1);
        System.out.println(myLinkedList.size);
//        myLinkedList.clear();
        for (int i=0;i<myLinkedList.size;i++){
            System.out.print(myLinkedList.get(i) + ",");
        }

    }
    private int size = 0;
    private Node head = null; //头 ， 链表有头什么都有， 没头什么都没有.
    public int size(){
        return size;
    }
    //添加
    public void add(Object value){
        Node newNode  = new Node(value);
        if(head == null){ //第一次添加
            head = newNode;
        }else {
            //指针
            Node temp = head; //当前节点
            while (temp.getNext() != null){
                temp = temp.getNext(); //当前节点向后移动
            }
            //循环结束, temp表示最后一个节点
            temp.setNext(newNode);
        }
        size++;
    }

    //修改
    public void set(int index,Object value){
        Node temp = head;
        for (int i = 0;i<index;i++){
            temp = temp.getNext();
        }
        //temp 定位到指定位置
        temp.setValue(value);
    }

    //获取
    public Object get(int index){
        Node temp = head;
        for (int i = 0;i<index;i++){
            temp = temp.getNext();
        }
        //temp 定位到指定位置
       return temp.getValue();
    }

    //清除
    public void clear(){
        head = null;
        size = 0;
    }

    public void removeAt(int index){
        //删除头
        if(index == 0){
            head = head.getNext();
        }else {
            //找到删除元素的前一个元素
            Node temp = head;
            for (int i=0;i<index-1;i++){
                temp = temp.getNext();
            }
            //循环结束, temp表示删除元素的前一个元素
            temp.setNext(temp.getNext().getNext());
        }
        size--;
    }

public class Node {
    private Object value; //数据
    // 下一个节点地址(对象引用)
    private Node next;

    //构造方法
    public Node(Object value) {
        this.value = value;
    }

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}