课程学习--JavaSE--第2讲--List

子类

ArrayList（数组链表）

特点

• 查询快（储存地址连着）
• 插入、修改、删除慢（要修改所有之后的数据）
• 线程不安全，效率高。
• 总结：适合查找和遍历，不适合增删改。

数组里放对象

构造方法

// 对象数组
private Object[] elementData;
// 容量	
private int size;
// 无参
public SxtArrayList() {
		// 初始化容量
		this(10);
	}
// 有参	
public SxtArrayList(int initialCapacity) {
	
	if(initialCapacity<0) {
		try {
			throw new Exception();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	elementData = new Object[initialCapacity];
}

工具

private void rangeCheck(int index) {
		if(index<0 || index>=this.size) {
			try {
				throw new Exception();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	private void ensureCapacity() {
		// 数组扩容和数据迁移
		if(size == elementData.length) {
			Object[] newArray = new Object[size*2+1];
			System.arraycopy(elementData, 0, newArray, 0, elementData.length);
//							for(int i=0;i<elementData.length;i++) {
//								newArray[i] = elementData[i];
//							}	 	 	 	
			
			elementData = newArray;
		}
	}

size、empty、getset

public int size() {
		return this.size;
	}
	
	public boolean isEmpty() {
		return this.size == 0;
	}
	
	// *
	public Object get(int index) {
		// 代码总是越写越少
		rangeCheck(index);
		return elementData[index];
	}
	
	public Object set(int index, Object obj) {
		rangeCheck(index);

        Object oldValue = elementData[index];
        elementData[index] = obj;
        return oldValue;
	}

add

public void add(Object obj) {
		// 数组扩容和数据迁移
		if(size == elementData.length) {
			Object[] newArray = new Object[size*2+1];
			System.arraycopy(elementData, 0, newArray, 0, elementData.length);
//			for(int i=0;i<elementData.length;i++) {
//				newArray[i] = elementData[i];
//			}
			
			elementData = newArray;
		}
		
		elementData[size++] = obj;
	}
	
	public void add(int index, Object obj) {
		rangeCheck(index);
		// 检查容量大小
		ensureCapacity();
				
		System.arraycopy(elementData, index, elementData, index + 1,
                size - index);
		elementData[index] = obj;
		size++;
	}

remove

public void remove(int index) {
		rangeCheck(index);
		// delete 
		int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

	}
	
	public void remove(Object obj) {
		
		for(int i=0;i<size;i++) {
			// 注意底层是equals
			if(get(i).equals(obj)) {
				remove(i);
			}
		}
	}
	

LinkedList（链表）

特点：

• 查询慢（存储区不连续），查询、修改、删除快（只改一个），线程不安全，效率高。
• 总结：适合数据的动态插入和删除，随机访问和遍历速度比较慢。

Node Bean(节点)

package cn.bjsxt.collection;

public class Node {
	Node previous;
	Object obj;
	Node next;
	public Node(Node previous, Object obj, Node next) {
		super();
		this.previous = previous;
		this.next = next;
		this.obj = obj;
	}
	public Node() {
		
	}
	public Node getPrevious() {
		return previous;
	}
	public void setPrevious(Node previous) {
		this.previous = previous;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
	public Object getObj() {
		return obj;
	}
	public void setObj(Object obj) {
		this.obj = obj;
	}
}

package cn.bjsxt.collection;

public class SxtLinkedList {
	
	private Node first;
	private Node last;
	
	private int size;
	
	private void rangeCheck(int index) {
		if(index<0 || index>=this.size) {
			try {
				throw new Exception();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	public void add(Object obj) {
		Node n = new Node();
		if(first == null) {
			n.setPrevious(null);
			n.setObj(obj);
			n.setNext(null);
			
			first = n;
			last = n;
		}else {
			n.setPrevious(last);
			n.setObj(obj);
			n.setNext(null);
			
			last.setNext(n);
			last = n;
		}
		size++;
	}
	
	public Object get(int index) {
		rangeCheck(index);
		Node temp = node(index);
		if(temp!=null) {
			return temp.obj;
		}
		return null;
		
	}
	
	public int size() {
		return size;
	}
	
	public Node node(int index) {
		Node temp = null;
		if(first != null) {
			temp = first;
			for(int i = 0; i < index; i++) {
				temp = temp.next;
			}
		}
		return temp;
	}
	
	public void remove(int index) {
		Node temp = node(index);
		
		if(temp != null) {
			Node up = temp.previous;
			Node down = temp.next;
			
			up.next = down;
			down.previous = up;
			size--;
		}
		
	} 
	
	public void add(int index, Object obj) {
		Node temp = node(index);
		
		Node newNode = new Node();
		
		newNode.obj =obj;
		
		if(temp !=null) {
			Node up = temp.previous;
			up.next = newNode;
			newNode.previous = up;
			newNode.next = temp;
			temp.previous = newNode;
			
			size++;
		}
	} 
	
	public static void main(String[] args) {
		SxtLinkedList list = new SxtLinkedList();
		list.add("aaa");
		list.add("bbb");
		list.add(1,"eee");
		list.add("ccc");
//		list.remove(1);
		System.out.println(list.get(1));
	}
}

Vector

特点：线程安全，但是效率低。（使用多线程）