java之数据结构一(简单实现ArrayList)

简单实现ArrayList

List接口
List.java

/**
 * 线性表接口
 * 和存储结构无关
 * @author Administrator
 *
 */
public interface List {
	// 返回线性表的大小，即数据元素的个数。
	public int size();

	// 返回线性表中序号为 i 的数据元素
	public Object get(int i);

	// 如果线性表为空返回 true，否则返回 false。
	public boolean isEmpty();

	// 判断线性表是否包含数据元素 e
	public boolean contains(Object e);

	// 返回数据元素 e 在线性表中的序号
	public int indexOf(Object e);

	// 将数据元素 e 插入到线性表中 i 号位置
	public boolean add(int i, Object e);

	// 将数据元素 e 插入到线性表末尾
	public boolean add(Object e);

	// 将数据元素 e 插入到元素 obj 之前
	public boolean addBefore(Object obj, Object e);

	// 将数据元素 e 插入到元素 obj 之后
	public boolean addAfter(Object obj, Object e);

	// 删除线性表中序号为 i 的元素,并返回之
	public Object remove(int i);

	// 删除线性表中第一个与 e 相同的元素
	public boolean remove(Object e);

	// 替换线性表中序号为 i 的数据元素为 e，返回原数据元素
	public Object replace(int i, Object e);
}

实现类ArrayList
ArrayList.java

import java.util.Arrays;

/**
 *顺序表底层采用的是数组
 *
 */
public class ArrayList implements List {

    private static int size;//不是数组分配了空间,而是元素的个数
    private Object[] elementData;//底层是一个数组,目前还没有组确定长度
    //private Object[] elementData1;//替换数组
    //private Object[] elementData2;//替换数组  可已使用Array.copy()

    //private int size;//

    private static int resize = 4;


    public ArrayList(){
        //没有指定长度
        this(resize);
        //没有指定长度,长度是0
        //elementData = new Object[]{};
    }
    //数组的初始长度

    private ArrayList(int initialCapacity) {
        //给数组分配指定数量的空间
        elementData = new Object[initialCapacity];

        //指定顺序表的元素个数
        //size = 0;

    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public Object get(int i) {

        if(i < 0 || i >= size){
            throw new MyArrayIndexOutOfBoundsException("数组索引越界异常!" + i);
        }

        return elementData[i];
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public  boolean contains(Object e) {

        return indexOf(e) >= 0;
    }

    @Override
    public int indexOf(Object e) {
        if(e == null){
            for (int i = 0; i < size; i++) {
                if (elementData[i] == null)
                    return i;
            }
        }else{

        }
            for (int i = 0; i < size; i++){
                if (e.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    @Override
    public boolean add(int i, Object e) {
        if(i>size +1){
            return false;
        }
        //size ++;
        resize();

//      elementData[i] = e;
//       第一种实现方式  但是得添加数组  在add添加elementData2
//      for(int j = i + 1;j<size;j++){
//           elementData[j] = elementData2[j-1];
//        }

        //第二种实现方式

        System.arraycopy(elementData, i, elementData, i+1,size - i);
        elementData[i] = e;
        size++;

        return true;
    }

    @Override
    public boolean add(Object e) {

        resize();
        //给数组赋值
        elementData[size] = e;
        //数组长度+1
        size ++;
        //elementData2 = elementData;  这是添加的数组
        return true;
    }

    @Override
    public boolean addBefore(Object obj, Object e) {
        if(contains(obj)){
            add(index(obj),e);
             return true;
         }else{
             throw new NoDateException("无指定数据!!!!!!");
         }
    }

    @Override
    public boolean addAfter(Object obj, Object e) {
        if(contains(obj)){
            int index = index(obj);
            System.arraycopy(elementData,index + 1,elementData, index + 1 ,size - index );
            elementData[index +1] = e;
            return true;
        }else{
            throw new NoDateException("无指定数据!!!!!!");
        }

    }

    @Override
    public Object remove(int i) {
        Object object = elementData[i];
        System.arraycopy(elementData,i + 1,elementData,i,size - i-1);
        size --;
        return object;
    }

    // 删除线性表中第一个与 e 相同的元素
    @Override
    public boolean remove(Object e) {
        System.out.println(contains(e));
        if (contains(e)) {
            int index = index(e);
            System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
            size--;
            return true;
        }
        return false;
    }

    // 替换线性表中序号为 i 的数据元素为 e，返回原数据元素
    @Override
    public Object replace(int i, Object e) {

        if(i<=size){
            Object object = elementData[i];
            elementData[i] = e;
            return object;
        }else{
            throw new NoDateException("无指定数据!!!!!!");
        }

    }

    //重新定义数组长度
    private  boolean resize() {
        if (size >= resize){
            resize = (resize * 3)/2;
//            elementData1 = new Object[resize];
//            for (int i = 0; i < elementData.length; i++) {
//                elementData1[i] = elementData[i];
//            }
//            elementData = new Object[resize];
//            elementData = elementData1;

            //上面方法太麻烦
            elementData = Arrays.copyOf(elementData,resize);

            return true;
        }
        return false;
    }
    //求索引
    private int index(Object obj){
        int i = 0;
        for (i = 0; i < size; i++) {
            if (elementData[i].equals(obj)){
                return i;
            }
        }

        return -1;
    }
}

自定义异常类
MyArrayIndexOutOfBoundsException.java

public class MyArrayIndexOutOfBoundsException extends RuntimeException{
    public MyArrayIndexOutOfBoundsException() {
    }

    public MyArrayIndexOutOfBoundsException(String message) {
        super(message);
    }
}

自定义异常类
NoDateException.java

public class NoDateException extends RuntimeException{
    public NoDateException() {
    }

    public NoDateException(String message) {
        super(message);
    }
}

测试类自己写就ok了