List 底层简单实现

List 容器实际上就是用数组模拟的容器，使用泛型可以规范数组管理。

首先开辟一个Object类型的数组，默认长度为10，或者自己定义长度。

add()方法：向数组的数据末端添加新数据，如果数组长度不够会使用扩容方法（原长度+原长度/2）。

get()方法：根据索引值获取数组内容。

set()方法：根据索引值和要设置的数据覆盖原来的数据。

remove()方法：实际上就是数组的拷贝，把后一个数据覆盖到当前的位置，把最后一个赋为空。

trimToSize()方法：声明一个与当前数组实际长度相等的新数组，把原来数组里的值拷贝到新数组里，在改变一下引用。

isEmpty()方法：判断数组的实际大小是否为0，

clean()方法：把数据变为空，大小变为0。

package Conllection;

/**
 * List 底层简单实现
 * 
 * @author zhaoy
 *
 */
public class List<T> {
	private Object[] elementData;
	private int size = 0;
	private static final int DEFAULT_CAPACITY = 10;

	public List() {
		elementData = new Object[DEFAULT_CAPACITY];
	}

	public List(int capacity) {
		elementData = new Object[capacity];
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		for (int i = 0; i < size; i++) {
			sb.append(elementData[i] + ",");
		}
		sb.setCharAt(sb.length() - 1, ']');
		return sb.toString();
	}

	/**
	 * 添加方法+ 数组扩容
	 * 
	 * @param obj
	 */
	public void add(T obj) {
		if (size == elementData.length) {
			Object[] newArray = new Object[size + (size >> 1)];
			for (int i = 0; i < elementData.length; i++) {
				newArray[i] = elementData[i];
			}
			elementData = newArray;
		}
		elementData[size++] = obj;
	}

	/**
	 * 获取内容方法
	 * 
	 * @param index
	 * @return
	 */
	public Object get(int index) {
		checkRange(index);
		return elementData[index];
	}

	/**
	 * 设置方法
	 * 
	 * @param index
	 * @param obj
	 */
	public void set(int index, T obj) {
		checkRange(index);
		elementData[index] = obj;
	}

	/**
	 * 根据索引位置移除数据
	 * 
	 * @param index
	 */
	public void remove(int index) {
		checkRange(index);
		for (int i = index + 1; i < size; i++) {
			elementData[i - 1] = elementData[i];
		}
		elementData[size] = null;
		size--;
	}

	/**
	 * 把数组容量变成实际大小的容量
	 */
	public void trimToSize() {
		int length = elementData.length;
		Object[] newArray = new Object[length];
		for (int i = 0; i < size; i++) {
			newArray[i] = elementData[i];
		}
		size = length;
		elementData = newArray;
	}

	/**
	 * 判断是否为空
	 * 
	 * @return
	 */
	public boolean isEmpty() {
		if (size == 0) {
			return true;
		}
		return false;
	}

	/**
	 * 判断数组索引是否正确
	 * 
	 * @param index
	 */
	public void checkRange(int index) {
		if (index < 0 || index >= size) {
			throw new RuntimeException("索引不合法：" + index);
		}
	}

	/**
	 * 清空数组
	 */
	public void clean() {
		for (int i = 0; i < size; i++) {
			elementData[i] = null;
		}
		size = 0;
	}
	/**
	 *  找出内容一样的第一个索引值
	 * @param obj
	 * @return
	 */
	public int indexOf(T obj) {
		if(obj!=null) {
			for(int i=0;i<size;i++) {
				if(elementData[i].equals(obj)) {
					return i;
				}
			}
		}
		return -1;
	}
	/**
	 *  找出内容一样的最后一个索引值
	 * @param obj
	 * @return
	 */
	public int lastIndexOf(T obj) {
		if(obj!=null) {
			for(int i=size-1;i>=0;i--) {
				if(elementData[i].equals(obj)) {
					return i;
				}
			}
		}
		return -1;
	}
	/**
	 * 主方法
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		List<String> list = new List<>();
		list.add("1");
		list.add("2");
		list.add("2");
		list.add("4");
		System.out.println(list);
		Object resule = list.get(2);
		System.out.println(resule);
		int index = list.indexOf("2");
		System.out.println("index:"+index);
		int lastIndex = list.lastIndexOf("2");
		System.out.println("lastIndex:"+lastIndex);
	}
}