ArrayList和LinkedList的底层实现

ArrayList实现

底层是用数组进行实现

package cn;

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

public class ArrayActive {
	//List list = new ArrayList();
	private transient Object[] list;
	//这里的size用来判定传进来add方法有调用了多少次，也就是实现添加有多少个，而且这里的话默认是0
	private int size;
	
	//这是一个无参构造函数
	public ArrayActive(){
		this(10);
	}
	
	//这里是一个有参数的构造函数,这里的参数表示的是数组的大小
	public ArrayActive(int initialCapacity){
		if(initialCapacity==0)
		{
			initialCapacity=10;
			list = new Object[initialCapacity];
		}
		else if(initialCapacity<0)
		{
			throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
		}
		else
		{
			list = new Object[initialCapacity];
		}
	}
	public boolean isEmpty()
	{
		
		if(size==0)
		{
			return false;
		}
		else
		{
			return true;
		}
	}
	public int size()
	{
		return size;
	}
	//实现增加的方法
	public void add(Object obj)
	{
		//这里的话主要是要要做一个判断，如果要是size超出了范围了，必须给数组扩容
		//数组一旦确定下来的话是无法进行修改的，所以的话就是底层的代码就是创建一个新的数组来代替原来的数组
		//将原来的数组的内容复制给了新的数组
		if(size>=list.length)
		{
			//这里的话是创建了一个新的数组
			Object [] list1 = new Object[size*2+1];
			//第二部就是给新的数组复制，注意，这里的复制方式有两种
			/*这里是第一种方式
			for(int i = 0;i<list.length;i++)
			{
				list1[i]=list[i];
			}*/
			System.arraycopy(list, 0, list1, 0, list.length);
			//对新创建的数组进行赋值之后要将新的数组赋值给原先的数组
			list= list1;
			
		}
		list[size] = obj;
		size++;
	}
	public static void main(String[] args) {
		ArrayActive list = new ArrayActive();
		
		System.out.println(list.isEmpty());
	}

}

 

 

LinkedList实现

底层使用链表实现，链表有单项链表和双向链表，这是使用的是双向链表实现

package cn;

public class Node {
	private Node before;
	private Object obj;
	private Node next;
	public Node() {
		super();
	}
	public Node getBefore() {
		return before;
	}
	public void setBefore(Node before) {
		this.before = before;
	}
	public Object getObj() {
		return obj;
	}
	public void setObj(Object obj) {
		this.obj = obj;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
	public Node(Node before, Object obj, Node next) {
		super();
		this.before = before;
		this.obj = obj;
		this.next = next;
	}

}

 

package cn;

public class LinkedListTest {
	
	private Node first;
	private Node last;
	private int size;
	
	public void add(Object obj){
		Node node = new Node();
		if(first==null){
			
			node.setBefore(null);
			node.setNext(null);
			node.setObj(obj);
			first = node;
			last = first;
		}else{
			node.setBefore(last);
			node.setObj(obj);
			node.setNext(null);
			last.setNext(node);
			last = node;
		}
		size++;
		
	}
	
	public int size()
	{
		return size;
	}
	//这里的方法是获得指定索引下标的节点
	public Node node(int index)
	{ 
		Node temp =first;
		if(index<0||index>size)
		{
			System.out.println("请正确输入");
			 temp = null;
		}
		else{
			if(first!=null)
			{
				
			
				if(index==0)
				{
					temp = first;
				}
				else
				{
					for(int i = 0;i<index;i++)
					{
						temp = temp.getNext();
					}
					
				}
				
			}
			
		}
		return temp;
		
	}
	
	//获得指定位置的值
	public Object get(int index)
	{
		Node node =node(index);
		return node.getObj();
	}
	
	//删除指定位置的节点，注意这里的删除就是讲前一个节点的next的值转移和下一个节点的before改变
	public boolean remove(int index)
	{
		boolean isflag = false;
		Node node = node(index);
		Node before = node.getBefore();
		Node next = node.getNext();
		before.setNext(next);
		next.setBefore(before);
		isflag = true;
		size--;
		return isflag;
	}
	//在指定位置加
	public void add(int index,Object obj)
	{
		Node node = node(index);
		Node node1 = node(index-1);
		Node newnode = new Node();
		newnode.setObj(obj);
		node1.setNext(newnode);
		node.setBefore(newnode);
		
		size++;
		
	}
	
	
	
	public static void main(String[] args) {
		LinkedListTest list = new LinkedListTest();
		
		list.add("12345");
		list.add("dwead");
		list.add("dwqa1");
		list.add("12345");
		list.add("dwead");
		list.add("dwqa2");
		list.add(2, "-----");
		System.out.println(list.get(2));
	}
}