04.0手写ArrayList

数组

• 特性：
  • 简单 功能少
  • 可以重复
  • 数组长度固定
  • 通过下标访问-增删查
  • 最大长度限制-length是int的最大值
  • 插入 查询 扩容操作都不太方便

MyList

属性

• 存储长度

• 长度

• 长度范围

  • 最大长度
  • 最小长度

• 默认长度

构造器

• 空参数构造器
  • 初始化–完全默认
• 带长度的构造器
  • 判断长度的是否合法，然后初始化
• 带数据结构的构造器
  • 转型为List

方法

• 添加数据：add();
  • 默认从最后的位置，根据当前元素个数所处的下标添加
• 插入数据：
  • 根据所需要添加元素的插入的下标，其后的所有元素都需要往后移

• 删除：

  • 清空： 遍历删除 或者 产生新数组
  • 按照下标删除： 被删除元素之后的所有数据都需要前移
  • 按照元素删除： 存在删除多个的情况

• 查找获取：

  • 根据下标查找： 返回元素对象
  • 根据元素查找： 返回元素个数，元素所在的下标数组

• 修改：替换

  • 根据下标替换 - 直接替换
  • 根据元素对象替换 - 替换多个

• 合并 数组 List 链表 …

  • 完全合并
  • 去重合并

• 子集查找

  • 相同
  • 包含
  • 部分包含
  • 是否有包含关系

• tostring

• sort

List接口

public interface List<E> {

    /**
     * 返回当前存储的元素个数
     * @return size
     */
    int size();

    /**
     * 返回当前底层容器的长度
     * @return 容量 length
     */
    int length();

    /**
     * 默认从最后的位置添加数据
     * @param e
     */
    void add(E e);


    /**
     *去除index位置的元素，并返回元素
     * @param index
     * @return
     */
    E remove(int index);

    /**
     * 去除指定元素，成功返回T，失败返回F
     * @param e
     * @return
     */
    boolean remove(E e);

    /**
     * 清空整个list
     */
    void removeAll();

    /**
     * 返回指定index的元素
     * @param index
     * @return
     */
    Object get(int index);

    /**
     * 返回元素所在的下标
     * @param e
     * @return
     */
    Integer[]  get(E e);

    /**
     *根据index替换list中的元素为e
     * @param index
     * @return
     */
    void replace(int index,E e);

    /**
     * 将元素e1替换为元素e2
     * @param e1
     * @param e2
     * @return
     */
    void replace(E e1,E e2);

    /**
     * 将list1中的元素替换为list2中的元素
     * @param list1
     * @param list2
     * @return
     */
    void replace(E[] list1,E[] list2);



    String toString();

    /**
     * 进行排序
     */
    void sort();


}

MyArrayList

public class MyArrayList<E> implements List<E>{

    int size = 0;
    int length = 0;
    Object[] arrvalue;
    static final int defLength = 10;
    static final int min_length = 10;
    static final int max_length = Integer.MAX_VALUE - 10;

    /**
     * 构造方法：
     */
    public MyArrayList () {
        length = defLength;
        arrvalue = new Object[length];
        size = 0;
    }
    public MyArrayList (int listlength) {
        if (listlength <= 0) {
            System.err.println ("给定的初始化长度不符合长度规范！！");
        }
        if (listlength > 0 && listlength <= min_length) {
            length = min_length;
            arrvalue = new Object[length];
            size = 0;
        }
        if (listlength >= max_length) {
            length = max_length;
            arrvalue = new Object[length];
            size = 0;
        } else {
            length = listlength;
            arrvalue = new Object[length];
            size = 0;
        }

    }



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

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

    @Override
    public void add(E e) {
        if (size>=length){
            int oldLength = length;
            int newLength = oldLength+(oldLength>>1);
            length = newLength;
            Object[] newarr = new Object[length];

            for (int i=0;i<oldLength;i++){
                newarr[i] = arrvalue[i];
            }
            arrvalue = newarr;
        }else {
            arrvalue[size++] =e;
        }


    }

    private void MyArrayCopy(Object[] src,int srcPos,Object[] dest,int destPos,int length){
         for (int i=srcPos;i<srcPos+length;i++){
             dest[destPos++] = src[i];
         }

    }

    public void add(MyArrayList<E> list) {
        int nowLength = size+list.length;
        if (nowLength>=length){
            int newLength = nowLength+(nowLength>>1);
            length = newLength;
            Object[] newarr = new Object[length];

            MyArrayCopy(arrvalue,0,newarr,0,size);
            MyArrayCopy(list.arrvalue,0,newarr,size,list.size);
            size = this.size+list.size;

            arrvalue = newarr;

        }else {
            MyArrayCopy(list.arrvalue,0,arrvalue,size+1,list.size);
            size = this.size+list.size;
        }

    }

    @Override
    public E remove(int index) {
        if (index<0 || index>size){
            System.err.println ("给定索引无值");
        }
        E value = (E) arrvalue[index];
        MyArrayCopy(arrvalue,index+1,arrvalue,index,size-index);
        size=size-1;

        return value;
    }

    @Override
    public boolean remove(E e) {
          boolean isRemove = false;
          int count =0;
        for (int i=0;i<size;i++){
            if (e.equals(arrvalue[i])){
                MyArrayCopy(arrvalue,i+1,arrvalue,i,size-i);
                i=i-1;
                isRemove = true;
                count++;
            }
        }
        size -= count;
        return isRemove;
    }

    @Override
    public void removeAll() {
        Object[] newarr = new Object[length];
        arrvalue = newarr;
    }

    @Override
    public Object get(int index) {
        if (index<0 || index>size){
            System.err.println ("给定索引无值");
        }
        E value = (E) arrvalue[index];
        return value;
    }

    @Override
    public Integer[] get(E e) {
        Integer[] arr = new Integer[length];
        int count=0;
        for (int i=0;i<=size;i++){
            if (e.equals(arrvalue[i])){
                arr[count++]=i;
            }
        }
        Integer[] arr1 = new Integer[count];
        MyArrayCopy(arr,0,arr1,0,count);

        return arr1;
    }

    @Override
    public void replace(int index, E e) {
        if (index<0 || index>length){
            System.err.println ("给定索引越界");
        }

        arrvalue[index] = e;
    }

    @Override
    public void replace(E e1, E e2) {
        int count =0;
        for (int i=0;i<=size;i++){
            if (e1.equals(arrvalue[i])){
               arrvalue[i] = e2;
               count++;
            }
        }
        System.out.println("完成替换："+count+"次");
    }

    @Override
    public void replace(E[] list1, E[] list2) {
         int count = 0;
        for (int i=0;i<list1.length;i++){
            for (int j=0;j<=size;j++){
                if (list1[i].equals(arrvalue[j])){
                    count++;
                    break;
                }
            }
        }

        if (count == list1.length){
            for (int i=0;i<list1.length;i++){
                for (int j=0;j<=size;j++){
                    if (list1[i].equals(arrvalue[j])){
                       arrvalue[j]=list2[i];
                       break;
                    }
                }
            }
        }

    }

    @Override
    public String toString(){
        System.out.print("[");
        for (int i=0;i<size-1;i++){
            System.out.print(arrvalue[i]+",");
        }
        System.out.println(arrvalue[size-1]+"]");
        return null;
    }

    @Override
    public void sort() {
        if (arrvalue == null || this.size< 2) {
        }else{
            Object[] newarr= new Object[size];
            MyArrayCopy(arrvalue,0,newarr,0,size);
            Arrays.sort(newarr);
            this.length = this.size;

            arrvalue=newarr;
        }


    }
}

测试类

public class MyArrayListTest {
    public static void main(String[] args) {
        MyArrayList<Integer> arr1=  new MyArrayList();
        MyArrayList<Integer> arr2=  new MyArrayList();

        //测试add()
        arr1.add(0);
        arr1.add(1);
        arr1.add(2);
        arr1.add(3);
        arr1.add(4);
        arr1.add(5);
        arr1.add(6);
        System.out.print("arr1:");
        arr1.toString();

        arr2.add(7);
        arr2.add(8);
        arr2.add(9);
        arr2.add(10);
        arr2.add(11);
        System.out.print("arr2:");
        arr2.toString();

        arr1.add(arr2);
        System.out.print("arr1:");
        arr1.toString();

        System.out.println("************************************");

        //测试remove()
        System.out.println(arr1.remove(0));
        System.out.print("arr1:");
        arr1.toString();

        arr1.add(11);
        System.out.print("arr1:");
        arr1.toString();
        System.out.println(arr1.remove((Integer) 11));
        System.out.print("arr1:");
        arr1.toString();

        System.out.println("*****************************");

        //测试get()
        System.out.println( arr1.get(5));
        System.out.print("arr1:");
        arr1.toString();

        arr1.add(5);
        System.out.print("arr1:");
        arr1.toString();
        Integer[] arr = arr1.get((Integer) 5);
        System.out.print("[");
        for (int i=0;i<arr.length-1;i++){
            System.out.print(arr[i]+",");
        }
        System.out.println(arr[arr.length-1]+"]");

        System.out.println("*********************************");

        //测试replace()
        System.out.print("arr1:");
        arr1.toString();
        arr1.replace(5,(Integer) 5);
        System.out.print("arr1:");
        arr1.toString();

        arr1.replace((Integer)5,(Integer)6);
        System.out.print("arr1:");
        arr1.toString();

        Integer array[] = {1,2,3,4};
        Integer array1[] = {11,22,33,44};
        arr1.replace(array,array1);
        System.out.print("arr1:");
        arr1.toString();

        System.out.println("****************");
        arr1.sort();
        System.out.print("arr1:");
        arr1.toString();



    }


}