动态扩容数组笔记

动态数组类属性

1.底层的存储数组：Object[] values
2.元素个数size
3.数组长度length

动态数组类的主要方法

1.初始化

给数组赋予初始长度

	static final int DEFAULT_LENGTH = 10;
	public Arr(){//若创建数组时未指定长度，则赋予默认长度 DEFAULT_LENGTH
        this(DEFAULT_LENGTH);
    }
    public  Arr(int initLength){//若创建数组时指定长度，则赋予参数initLength
        if(initLength <= 1){//赋值前先判断initLength是否合法，初始长度应大于等于1
            throw new RuntimeException("Error");//不合法，报错
        }
        values = new Object[initLength];//合法，创建调用指定长度的底层数组
        size = 0;
        length = initLength;//初始化size和length
    }

2.添加元素

	public void addValue(E e){//E 泛型
		if(size == length){// 数组满了
			int oldLength = length;
			int newLength = oldLength + (oldLength >> 1);//数组扩充为原来的1.5倍
			// 根据新长度创建新数组
			Object[] newValues = new Object[newLength];
			// 将旧数组中的元素复制到新数组中
			for(int i = 0; i < oldLength; i++){
				newValues[i] = values[i];
			}
		// 更新数组引用
			values = newValues;
			length = newLength;
			System.out.println ("数组扩容了+ length=" + length);
		}
		values[size++] = e;
	}

泛型E
声明： 类名的右边加上 E是自己设定的模板标识符
使用： 类中就可以使用 E 作为一个类型来使用了
作为参数类型 作为返回值类型
注意： 泛型不能直接实例化对象 不能 new

3.删除元素

	public E removeValue(int index){//根据数组下标删除元素
        for(int i = index;i<size;i++){//将下表为index后的元素前移一位
            values[i]=values[i+1];
        }
        size=size-1;//元素个数-1
        return null;
    }
    public int removeValue(E e){//删除数组中所有值为e的元素
        for(int i=0;i<size;i++) {//遍历数组
            if(values[i]==e){//找到为e的所有元素的下标
                removeValue(i);//调用removeValue（int index)操作
                i=i-1;//由于第i位被删除，i回滚到i-1
            }
        }
        return 0;
    }

4.查询元素

	public E getValue(int index){
        if(index < 0 || index >= size){//所输入的下标超出素组范围
            throw new RuntimeException("ERROR");//报错
        }
        return (E) values[index];//返回数值
    }

整体代码

public class Arr<E> {
    Object[] values;
    int size;
    int length;
    static final int DEFAULT_LENGTH = 10;
    public Arr(){
        this(DEFAULT_LENGTH);
    }
    public  Arr(int initLength){
        if(initLength <= 1){
            throw new RuntimeException("Error");
        }
        values = new Object[initLength];
        size = 0;
        length = initLength;
    }
    public void addValue(E e){
        if(size == length){
            int oldlength = length;
            int newlength = oldlength + (oldlength >> 1);
            Object[] newValues = new Object[newlength];
            for(int i = 0; i < oldlength; i++){
                newValues[i] = values[i];
            }
            values = newValues;
            length = newlength;
            System.out.println("Arr was extended "+ length);
        }
        values[size++]=e;
    }
    public E getValue(int index){
        if(index < 0 || index >= size){
            throw new RuntimeException("ERROR1");
        }
        return (E) values[index];
    }
    public void addAll(E[] earr){
        for(int i = 0;i< earr.length;i++){
            addValue(earr[i]);
        }
    }
    public boolean contains(E e){
        for (int i=0;i<size;i++){
            if(values[i]==e)return true;
        }
        return false;
    }
    public int indexOF(E e){
        for(int i=0;i<size;i++){
            if(values[i]==e){
                return i;
            }
        }
        return -1;
    }
    public int lastIndexOF(E e){
        for (int i = size-1;i>=0;i++){
            if(values[i]==e){
                return i;
            }
        }
        return -1;
    }
    public E removeValue(int index){
        for(int i = index;i<size;i++){
            values[i]=values[i+1];
        }
        size=size-1;
        return null;
    }
    public int removeValue(E e){
        for(int i=0;i<size;i++) {
            if(values[i]==e){
                removeValue(i);
                i=i-1;
            }
        }
        return 0;
    }
    public E[] removeValue(int fromIndex,int toIndex){
        for(int i=fromIndex;i<size;i++){
            values[i]=values[i+toIndex-fromIndex+1];
        }
        size=size-(toIndex-fromIndex+1);
        return null;
    }
    public void insertValue(int index,E e){
        if(size == length){
            int oldlength = length;
            int newlength = oldlength + (oldlength >> 1);
            Object[] newValues = new Object[newlength];
            for(int i = 0; i < oldlength; i++){
                newValues[i] = values[i];
            }
            values = newValues;
            length = newlength;
            System.out.println("Arr was extended "+ length);
        }
        size++;
        for(int i=size-1;i>index;i--){
            values[i]=values[i-1];
        }
        values[index]=e;
    }
    public E replaceValue(int index,E e){
        values[index]=e;
        return null;
    }
}