浅谈List接口 自己实现ArrayList LinkedList主要方法

List 存放对象有序可重复

Set 存放对象无序不可重复

Map 存放键值对

 

Collection<E>接口主要方法

int size();

boolean isEmpty();

boolean contains(Object obj);

Iterator<E> iterator();

Object[] toArray();

boolean add(E e);

boolean remove(Object obj);

boolean containsAll(Collection<?> e);

boolean addAll(Collection<? extends E> e);

boolean removeAll(Collection<?> e);

boolean retainAll(Collection<?> e);//取交集

void clear();

boolean equals(Object obj);

Int hashCode();

 

Lsit接口实现类

ArrayList 数组实现 查询快 删除慢 插入慢 线程不安全，效率高

LinkedList 链表实现 查询慢 删除快 插入快 线程不安全，效率高

Vector 线程安全，效率低

 

自己实现ArrayList主要方法

 

public class MyArrayList {
	private Object[] elementData;
	private int size=0;
	
	public MyArrayList(){
		this(5);
	}
	public MyArrayList(int length){
		if(length<=0){
			try {
				throw new Exception();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		elementData=new Object[length];
	}
	public void add(Object obj){
		if(size==elementData.length){
			Object[] newArray=new Object[elementData.length*2];
			System.arraycopy(elementData, 0, newArray, 0, size);
			elementData=newArray;
		}
		elementData[size++]=obj;
	}
	public Object remove(int index){
		rangeCheck(index);
		System.arraycopy(elementData, index+1, elementData, index, size-index-1);
		elementData[size-1]=null;
		size--;
		return elementData[index];
	}
	public boolean remove(Object obj){
		for(int i=0;i<size;i++){
			if(obj.equals(elementData[i])){
				remove(i);
				return true;
			}
		}
		return false;
	}
	private void rangeCheck(int index){
		if(index<0||index>=size){
			try {
				throw new Exception();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	public Object get(int index){
		rangeCheck(index);
		return elementData[index];
	}
	public Object set(int index,Object obj){
		rangeCheck(index);
		Object o=elementData[index];
		elementData[index]=obj;
		return o;
	}
	public int size(){
		return this.size;
	}
	public String toString(){
		String str="[";
		for(int i=0;i<size;i++){
			str+=elementData[i].toString()+",";
		}
		str=str.substring(0, str.length()-1)+"]";
		return str;
	}
}

自己实现LinkedList主要方法

public class Node {
	private Node previous;
	private Object obj;
	private Node next;
	public Node getPrevious() {
		return previous;
	}
	public void setPrevious(Node previous) {
		this.previous = previous;
	}
	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 class MyLinkedList {
	private Node first;
	private Node last;
	private int size;
	
	public void add(Object obj){
		Node node=new Node();
		node.setObj(obj);
		if(first==null){
			first=node;
			last=node;
		}else{
			last.setNext(node);
			node.setPrevious(last);
			last=node;
		}
		size++;
	}
	private void rangeCheck(int index){
		if(index<0||index>=size){
			try {
				throw new Exception();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	public Object get(int index){
		rangeCheck(index);
		Node temp=first;
		for(int i=0;i<index;i++){
			temp=temp.getNext();
		}
		
		return temp.getObj();
	}
	public Object remove(int index){
		rangeCheck(index);
		Node temp=first;
		for(int i=0;i<index;i++){
			temp=temp.getNext();
		}
		temp.getPrevious().setNext(temp.getNext());
		size--;
		return temp.getObj();
	}
	public boolean remove(Object obj){
		Node temp=first;
		
		for(int i=0;i<size;i++){
			if(temp.getObj().equals(obj)){
				remove(i);
				return true;
			}else{
				temp=temp.getNext();
			}
		}
		
		return false;
	}
	public int size(){
		return size;
	}
	public String toString(){
		Node temp=first;
		String str="[";
		while(temp!=null){
			str+=(temp.getObj().toString()+",");
			temp=temp.getNext();
		}
		str=str.substring(0, str.length()-1);
		str+="]";
		return str;
		
	}
}