ArrayList与LinkedList的简单实现及区别分析

ArrayList与LinkedList的简单实现及区别分析

ArrayList和LinkedList都实现了List接口，用于存储一系列的对象引用。它们都可以对元素的增删改查进行操作。但是它们之间也存在一些区别，这些区别使得它们在不同数据操作上的性能也并不一样

一、ArrayList的实现

package Home20202;

import java.util.ArrayList;
import java.util.Arrays;

class A{
    public static void func(){
        System.out.println("A");
    }
}

class B extends A{
    public static void func(){
        System.out.println("B");
    }
}

class MyArrayList{
    private String[] elements; //存储元素的容器
    private static int defaultCapacity = 5;
    private int size; //实际元素个数

    public MyArrayList(){
        this(defaultCapacity);
    }

    public MyArrayList(int capacity){
        elements = new String[capacity];
    }

    //添加某一个元素
    public void add(String value){
        //判断elements是否够用
        if(size() == elements.length){
            elements = Arrays.copyOf(elements, elements.length * 2);
        }

        elements[size++] = value;
    }

    //删除某一个下标之下的元素
    public boolean remove(int index){
        if(!checkIndex(index)){
            return false;
        }
        System.arraycopy(elements, index+1, elements, index, size-1-index);
        elements[--size] = null;
        return true;
    }

    //删除某一个元素
    public boolean remove(String value){
        int index = -1;//value->下标
        for(int i=0; i<size; i++){
            if(elements[i].equals(value)){
                index = i;
            }
        }
        if(index == -1){
            return false;
        }
        remove(index);
        return true;
    }

    //判断是否包含某一个元素
    public boolean contains(String value){
        for(int i=0; i<size; i++){
            if(elements[i].equals(value)){
                return true;
            }
        }
        return false;
    }

    //得到某一个下标下的某一个元素
    public String get(int index){
        if(!checkIndex(index)){
            return elements[index];
        }
        return null;
    }

    //得到当前容器中的元素个数
    public int size(){
        return size;
    }

    public boolean checkIndex(int index){
        return index > 0 && index < elements.length;
    }

    public String toString(){
        return Arrays.toString(elements);
    }
}

public class Arraylist {
    public static void main(String[] args) {
        MyArrayList list = new MyArrayList();
        list.add("abc");
        list.add("adadbc");
        list.add("awebc");
        list.add("adsabc");
        list.add("dfeabc");
        list.add("tgabc");

        System.out.println(list.toString());
        System.out.println(list.remove(5));
        System.out.println(list.remove("abc"));
        System.out.println(list.toString());

        System.out.println(list.contains("adsabc"));
        System.out.println(list.size());
    }
}

`ArrayList在集合的末尾删除或添加元素所用的时间是一致的，但是在列表中间的部分添加或删除时所用时间就会大大增加，但是它在根据索引查找元素的时候速度很快。

二、LinkedList的实现

package Array;
 
import java.util.NoSuchElementException;
 
public class MyLinkedList<T> {
private class Node<T>{
	T t;
	Node<T> next;//后继
	Node<T> prev;//前驱
	Node(T t){
		this.t=t;
	}
}
Node<T> frist;
Node<T> last;
int size;//链表长度
public MyLinkedList() {
	frist=last=null;
}
//加一个元素
public void add(T t) {
	Node<T> n=new Node<T>(t);
	if(last==null) {
		frist=n;
		last=n;
	}else {
	last.next=n;//最后一个元素下一个为此次添加的元素
	n.prev=last;//添加元素的前驱指前一个元素
	last=n;//此时最后一个元素为刚添加进入的
	}
	size++;
}
//添加元素到第一个
public void addFrist(T t) {
	Node<T> f=new Node<T>(t);	
	if(last==null) {
		frist=f;
		last=f;
	}else {
	f.next=frist;
	frist.prev=f;
	frist=f;
	}
	size++;
}
//将元素添加到最后一个位置
public void linkedFrist(T t) {
	add(t);
}
//删除第一个元素
public void deleteFrist() {
	if(size<1) {
		throw new NoSuchElementException("linked为空，无法进行此操作");
	}
 frist.next.prev=null;
 frist=frist.next;
 size--;
}
//删除最后一个元素
public void deleteLast() {
	if(size<1) {
		throw new NoSuchElementException("linked为空，无法进行此操作");
	}
last=last.prev;
last.next=null;
size--;
}
//删除指定元素
public void delete(T t) {
	Node<T> n=findNode(t);
	n.prev.next=n.next;
	n.next.prev=n.prev;
	size--;
}
//删除指定位置的元素
public void delete(int index) {
	Node<T> n=findex(index);
	n.prev.next=n.next;
	n.next.prev=n.prev;
	size--;
}
//将更改第一个元素,返回其原来的元素
public T setFrist(T t) {
	T t1=frist.t;
	frist.t=t;
	return t1;
}
//更改最后一个元素
public T setLast(T t) {
	T t1=last.t;
	last.t=t;
	return t1;
}
//更改指定位置的元素,返回该位置的元素
public T set(int index,T t) {
	Node<T> n=findex(index);//获取这个位置的结点
	T t1=n.t;
	n.t=t;
	return t1;
}
//获取第一个元素
public T getFrist() {
	if(size()==0) {
		throw new NoSuchElementException("linkedlist为空，无法进行此操作");
	}
	return frist.t;
}
//获取最后一个元素
public T getLast() {
	if(size()==0) {
		throw new NoSuchElementException("linkedlist为空，无法进行此操作");
	}
	return last.t;
}
//获取指定位置的元素
public T get(int index) {
	Node<T> n=findex(index);
	return n.t;
}
//输入指定元素，获取其结点
private Node<T> findNode(T t){
	Node<T> n=frist;
	for(int i=0;i<size;i++) {
		if(n.t.equals(t)) {
			return n;
		}
		n=n.next;
	}
	throw new NoSuchElementException("linkedlist无此元素，无法进行此操作");
}
//输入指定位置，获取其结点
private Node<T> findex(int index) {
	if(index<1||index>size()) {
		
		throw new NoSuchElementException("linkedlist输入错误，无法进行此操作:"+index);
	}
	Node<T> n=frist;
	for(int i=0;i<size;i++) {
		if(i==index-1) {
			return n;
		}
		n=n.next;
	}
	return null;
}
//判断是否为空
public boolean isEmpty() {
	return size()==0;
}
//判断长度
public int size() {
	return size;
}
}

``ArrayList和LinkedList的大致区别如下:
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。