手动重现Java中ArrayList类中常用方法

import java.util.Arrays;

public class ArrayListDemo {
	/**基于Object[]*/
	private Object[] value;
	
	/**元素个数*/
	private int size;
	
	/**
	 * 创建一个默认长度是10，且有指定元素的ArrayList对象
	 * @param obj
	 */
	public ArrayListDemo(Object obj){
		this(10);
		add(obj);
	}
	
	/**
	 * 创建一个默认长度是10的ArrayList对象
	 */
	public ArrayListDemo() {
		this(10);
	}

	/**
	 * 创建指定长度的ArrayList对象
	 * @param length
	 */
	public ArrayListDemo(int length) {
		super();
		//判断创建数组的长度
		if (length <= 0) {
			throw new IllegalArgumentException("请，不能创建小于等于0的对象哦！！！");
		}
		value = new Object[length];
	}

	/**
	 * 可以任意添加任意类型的数据 void add(Object obj)
	 * @param obj
	 */
	public void add(Object obj){
		//判断数组是否能够装下当前要添加的元素，如果不能，则扩容
		if (size >= value.length) {
			//根据添加元素自动扩容 length*2,将扩容后的新数组地址重新赋值给value保存
			value = Arrays.copyOf(value,value.length*2);
		}
		value[size] = obj;
		size++;
	}
	
	/**
	 * 可以记录当前数据的个数 int size()
	 * @return
	 */
	public int size(){
		return size;
	}
	
	/**
	 * 可以打印当前数据结构的对象，格式如下：[值1，值2.。。。。]
	 * value数组进行字符串拼接
	 */
	@Override
	public String toString() {
		//数组缩容，将所有有元素的取出来放到新数组中，避免打印没有元素的默认值null的情况
		Object[] newArr = Arrays.copyOf(value,size);
		return Arrays.toString(newArr);
	}
	
	/**
	 * 查询指定下标的元素  Object searchByIndex(int index)
	 * @param index
	 * @return
	 */
	public Object searchByIndex(int index){
		//校验下标合法性
		checkIndex(index);
		//直接返回该下标处的元素
		return value[index];
	}
	
	/**
	 * 该方法校验下标合法性
	 * @param index
	 */
	private void checkIndex(int index) {
		if(index < 0 || index >= size){
			throw new IllegalArgumentException("亲，下标范围是：[0,"+(size-1)+"]");
		}
	}
	
	/**
	 * 查询指定的元素第一次出现的位置  int searchByElement(Object ele);
	 * @param ele
	 * @return
	 */
	public int searchByElement(Object ele){
		/*
		 * 遍历数组，将元素取出来跟ele进行对比，如果相等（equals、==）则返回下标，否则返回-1
		 * 注意：
		 * 		1. 先判断ele是不是为null，因为如果为null用equals比较会抛出空指针异常
		 * 		2. 循环次数是size次，而不是value.length次
		 */
		if (ele == null) {//先判断，后循环，效率高
			for (int i = 0; i < size; i++) {
				if (ele == value[i]) {
					return i;
				}
			}
		} else {
			for (int i = 0; i < size; i++) {
				if (ele.equals(value[i])) {
					return i;
				}
			}
		}
		//如果循环完毕没有找到，返回-1
		return -1;
	}
	
	/**
	 * 修改指定下标处的元素  void updateByIndex(int index,Object obj)
	 * @param index
	 * @param obj
	 */
	public void updateByIndex(int index,Object obj){
		//检验下标合法性，因为在多处都会使用到校验下标合法性问题，所以将该功能抽象成一个方法
		checkIndex(index);
		//直接根据下标修改元素
		value[index] = obj;
	}
	
	/**
	 * 删除指定下标处的元素，返回删除的元素   Object deleteByIndex(int index)
	 * @param index
	 * @return
	 */
	public Object deleteByIndex(int index){
		//校验下标合法性
		checkIndex(index);
		//定义一个变量保存要删除的元素
		Object obj = value[index];
		//数组的复制方法System.arraycopy();找出复制的数组下标和复制个数
		System.arraycopy(value,index+1,value,index,size-index-1);
		//数量-1
		size--;
		//将删除的元素返回
		return obj;
	}
	
	/**
	 * 删除的首次出现的指定元素     void deleteByElement(Object ele)
	 * @param ele
	 */
	public void deleteByElement(Object ele){
		//调用自己的方法searchByElement(ele)获取要删除元素第一次出现的下标
		int index = searchByElement(ele);
		//根据下标判断当前元素是否存在，如果不存在直接结束方法
		if (index < 0) {
			return;
		}
		//调用自己的方法deleteByIndex(int index)删除指定下标处的元素
		deleteByIndex(index);
	}
	
	/**
	 * 插入指定下标处一个指定元素 void insertByIndex(int index,Object obj)
	 * @param index
	 * @param obj
	 */
	public void insertByIndex(int index,Object obj){
		//检验下标合法性，因为在多处都会使用到校验下标合法性问题，所以将该功能抽象成一个方法
		checkIndex(index);
		//判断数组是否能够装下当前要添加的元素，如果不能，则扩容
		if (size >= value.length) {
			//根据添加元素自动扩容 length*2,将扩容后的新数组地址重新赋值给value保存
			value = Arrays.copyOf(value,value.length*2);
		}
		//数组复制方法System.arraycopy();找出复制的数组下标和复制个数
		System.arraycopy(value, index, value, index+1,size - index);
		//元素个数+1
		size++;
		//给index处元素赋值
		value[index] = obj;
	}
	
	/**
	 * 将对象中所有元素清空 void clear();
	 */
	public void clear(){
		//直接赋值一个新数组地址
		value = new Object[10];
		//将元素个数归零
		size = 0;
	}
}