JavaSE 集合 List

JavaSE 集合 List

标签（空格分隔）： JavaSE List

---

Collection

• 常用API

   add() 添加
   	boolean add(E e)  
   	boolean addAll(Collection<? extends E> c)  
   void clear() 清空元素
   int size() 返回大小
   boolean contains(Object obj) 是否包含	//判断对象默认调用equals方法
   boolean isempty() 是否为空
   remove() 删除 
   	boolean remove(Object o)  删除第一个元素
   	boolean removeAll(Collection<?> c) 
   	boolean retainAll(Collection<?> c)  只保留c中有的元素
   Object[] toArray() 转换为数组
  

Collection 接口的的方法是不带有索引的

List

• List特点
  顺序表 有序 有索引 接口

• 常用API 与 collection相比多索引

    void add(int index, E element) //指定插入位置，顺移
    boolean addAll(int index, Collection<? extends E> c)  
    E remove(int index) 
    E get(int index)  
    E set(int index, E element)  
    boolean contains(Object o)  
    boolean containsAll(Collection<?> c) 
    List<E> subList(int fromIndex, int toIndex)  
    	子列表和父列表公用一个空间
    	如果不想修改父列表重新new 一个列表参数传入
    	new ArrayList(List list);		
  

ArrayList

• 底层
  基于数组存储数据
  计算容器的大小，重新new一个新的数组大小，并将当前的数组所有元素复制到这个新的数组中，然后将最新的值放入数组的最后一个。
• 实现接口
  RandomAccess
• 查询效率高 插入删除效率低
• 自定义MyArrayList实现List接口

package se01.day04;

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
 * ArrayList底层是数组
 * @author Bonnie
 *
 */
public class MyArrayList implements List {
	private Object[] elements;// 集合中存放元素的数组
	
	public MyArrayList() {
		// 数组初始长度为0
		elements = new Object[0];
	}
	/** List中的元素个数 */
	public int size() {
		return elements.length;
	}
	/** 集合是否为空 */
	public boolean isEmpty() {
		return elements.length == 0;
	}
	/** 是否包含指定元素 */
	public boolean contains(Object o) {
		// 循环数组中的每一个元素并和o比较
		/*for (int i = 0; i < size(); i++) {
			if (elements[i].equals(o)) {
				return true;
			}
		}
		return false;*/
		return indexOf(o) != -1;
	}
	/** 向集合末尾追加元素e */
	public boolean add(Object e) {
		/*// 1.扩容
		elements = Arrays.copyOf(elements, elements.length + 1);
		// 2.将e放入新数组最后一位
		elements[elements.length - 1] = e;*/
		add(size(), e);
		return true;
	}
	/** 从集合中删除第一个o元素 */
	public boolean remove(Object o) {
		// 1.判断有没有o
		int index = indexOf(o);
		if (index == -1) {
			return false;
		}
		// 2.将o后面的元素向前移一位 i位元素
		for (int i = index; i < size() - 1; i++) {
			elements[i] = elements[i + 1];
		}
		// 3.将数组缩容
		elements = Arrays.copyOf(elements, size() - 1);
		return true;
	}
	/** 清空集合 */
	public void clear() {
		elements = new Object[0];
	}
	/** 获取index位置上的元素*/
	public Object get(int index) {
		return elements[index];
	}
	/** 将index位置上的元素替换为element，并返回被替换掉的元素 */
	public Object set(int index, Object element) {
		Object o = elements[index];
		elements[index] = element;
		return o;
	}
	/** 在index位置插入element */
	public void add(int index, Object element) {
		// 0.判断index合法性  0 <= index <= size
		if(index < 0 || index > size()) {
			return;
		}
		// 1.扩容
		elements = Arrays.copyOf(elements, size() + 1);
		// 2.将index后面的内容后移一位
		for (int i = size() - 2; i >= index; i--) {
			elements[i + 1] = elements[i];
		}
		// 3.将element放入index位置
		elements[index] = element;
	}
	/** 将index位置上的元素移除，并返回被删除的元素 */
	public Object remove(int index) {
		Object o = elements[index];
		remove(get(index));
		return o;
	}
	/** 获得第一个o元素出现的位置，如果没有o返回-1 */
	public int indexOf(Object o) {
		for (int i = 0; i < size(); i++) {
			if (elements[i].equals(o)) {
				return i;
			}
		}
		return -1;
	}
	public String toString() {
		return Arrays.toString(elements);
	}
	public Iterator iterator() {
		return null;
	}
	public Object[] toArray() {
		return null;
	}
	public Object[] toArray(Object[] a) {
		return null;
	}
	
	public boolean containsAll(Collection c) {
		return false;
	}
	public boolean addAll(Collection c) {
		return false;
	}
	public boolean addAll(int index, Collection c) {
		return false;
	}
	public boolean removeAll(Collection c) {
		return false;
	}
	public boolean retainAll(Collection c) {
		return false;
	}
	
	public int lastIndexOf(Object o) {
		return 0;
	}
	public ListIterator listIterator() {
		return null;
	}
	public ListIterator listIterator(int index) {
		return null;
	}
	public List subList(int fromIndex, int toIndex) {
		return null;
	}

}

LinkedList

• 双向链表 实现接口 Deque ， Queue
  元素称之为节点
• 查询效率低 插入删除效率高
• 与比List多的API 应为是双端列表所以有着First 和Last的方法
  void addFirst(E e)
  void addLast(E e)
  E getFirst()
  E getLast()

Vector

使用（不用）线程安全 效率低
使用方法和ArrayList相似

List图解比较