TArrayList对（ArrayList改写）——顺序表（1.5倍可扩容数组）——JAVA

TArrayList对（ArrayList改写）——顺序表（1.5倍可扩容数组）——JAVA

一、readme

主要实现了数组扩容
一般操作：
增——添加一个元素（可扩容）和，添加数组（一次添加多个元素）（可扩容，三种情况都已经实现）
删——删除一个元素 和，删除所有值为data对象的元素
查——根据index，获取一个元素 和，根据元素，获得位置index，返回一个数组；
改——根据index，修改一个元素 和，用newObject取代所有的oldData;
备注：因为数组的组成的单位是原子性的一个对象，不需要再像链表一样再弄一个结点LNode类（和操作链表类分开）

二、写代码部分

0、总体实现

/**
     * 因为数组的组成的单位是原子性的一个对象，不需要再像链表一样再弄一个结点LNode类（和操作链表类分开）
     * 思路：
     * 1、先写数据域
     * 底层数组
     * 数组中元素个数
     * 数组长度
     * final int DEF_LENGTH = 10;
     * final int MIN_LENGTH = 2;
     * ---
     * 2、再写构造方法
     * 无参构造方法
     * 有参构造方法
     * ---
     * 3、操作方法
     * （1）添加一个元素（可扩容）
     * public void addOneObject(Object e)
     * （2）添加数组（一次添加多个元素）（可扩容，三种情况都已经实现）
     * public void addAllObjects(Object[] es)
     * （3）删除一个元素
     * public Object removeOne(int index)
     * （4）删除所有值为data对象的元素
     * public void removeAll(Object data)
     * （5）根据index，获取一个元素
     * public Object getObject(int index)
     * （6）根据元素，获得位置index，返回一个数组；
     * public TArrayList getAllIndex(Object e)
     * （7）根据index，修改一个元素
     * public void setValue(int index, Object e)
     * （8）用newObject取代所有的oldData;
     * public void replaceAll(Object oldData, Object newData)
     * ---
     */

1、写数据域

    //底层数组
    Object[] values;
    //数组中元素个数
    public int size;
    //数组长度
    int length;
    final int DEF_LENGTH = 10;
    final int MIN_LENGTH = 2;

2、构造方法

    //无参构造方法
    public TArrayList() {
        values = new Object[DEF_LENGTH];
        length = DEF_LENGTH;
        size = 0;

    }

    //有参构造方法,要判断一下，不要太小，只存一个没意义
    public TArrayList(int length) {
        if (length < MIN_LENGTH) {
            throw new IllegalArgumentException(length + "不能小于" + MIN_LENGTH);

        }
        values = new Object[length];
        this.length = length;
        size = 0;

    }

3、添加一个元素（可扩容）

 /**
     * 两种情况 因为最小的数组长度是2，所以不会有第三种情况：1.5倍不够
     * 当前数组中元素个数<length：直接添加
     * 当前数组中元素个数>=length&&当前数组中元素个数<length+(length>>1)：扩容到原来的1.5倍
     * 直接values[size++]=e;
     */
    public void addOneObject(Object 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];

            }
            length = newLength;
            values = newValues;
            System.out.println("扩容完成" + length);

        }
        values[size++] = e;

    }

4、添加数组（一次添加很多元素）（可扩容）

// 三种情况
    /**
     * 当前数组中元素个数+es.length<length：直接添加
     * 当前数组中元素个数+es.length>=length&&当前数组中元素个数+es.length<length+(length>>1)：扩容到原来的1.5倍
     * 当前数组中元素个数+es.length>=length+(length>>1)：扩容到原来的1.5倍+es.length
     * 直接values[size++]=e;
     */
    public void addAllObjects(Object[] es) {
        if (es.length + size < length) {
            for (int i = 0; i < es.length; i++) {
                values[size++] = es[i];
            }
        } else if (es.length + size >= length && es.length + size < length + (length >> 1)) {
            int oldLength = length;
            int newLength = oldLength + (oldLength >> 1);
            Object[] newValues = new Object[newLength];
            for (int i = 0; i < oldLength; i++) {
                newValues[i] = values[i];

            }
            length = newLength;
            values = newValues;
            System.out.println("扩容完成" + length);
            for (int i = 0; i < es.length; i++) {
                values[size++] = es[i];
            }
        } else {
            int oldLength = length;
            int newLength = oldLength + es.length + (es.length >> 1);
            Object[] newValues = new Object[newLength];
            for (int i = 0; i < oldLength; i++) {
                newValues[i] = values[i];

            }
            length = newLength;
            values = newValues;
            System.out.println("扩容完成" + length);
            for (int i = 0; i < es.length; i++) {
                values[size++] = es[i];
            }

        }
    }

5、根据index,删除元素

    /**
     * 先判断是否为空
     * 先判断index是否合法
     * 再判断index是否越界
     * 先保存要删除的元素
     * 再从index开始，后面的元素依次向前移动，覆盖就好
     */
    public Object removeOne(int index) {
        if (size == 0) {
            System.out.println("没有元素可以删除");
            return null;
        }
        if (index < 0 || index >= length) {
            throw new IllegalArgumentException("索引不合法");
        }
        if (index >= size) {
            throw new IllegalArgumentException("索引越界");
        }
        Object e = values[index];
        for (int i = index; i < size - 1; i++) {
            values[i] = values[i + 1];
        }
        return e;

    }

6、删除所有值为data对象的元素

    /**
     * 先判断是否为空
     * for循环遍历所有元素，如果values[i].equals(data)，就把后面的元素依次向前移动，覆盖就好
     */
    public void removeAll(Object data) {
        if (size == 0) {
            System.out.println("没有元素可以删除");
            return;
        }
        for (int i = 0; i < size; i++) {
            if (values[i].equals(data)) {
                for (int j = i; j < size - 1; j++) {
                    values[j] = values[j + 1];
                }
                size--;
                i--;
            }
        }
    }

7、根据index，获取一个元素

 /**
     * 先判断是否为空
     * 先判断index是否合法
     * 再判断index是否越界
     * 直接返回values[index]
     */
    public Object getObject(int index) {
        if (size == 0) {
            System.out.println("没有元素可以获取");
            return null;
        }
        if (index < 0 || index >= length) {
            throw new IllegalArgumentException("索引不合法");

        }
        if (index >= size) {
            throw new IllegalArgumentException("索引越界");
        }
        return values[index];
    }

8、根据元素，获得位置index，返回一个数组；

/**
     * 先判断是否为空
     * 先判断index是否合法
     * 再判断index是否越界
     * 创建一个TArrayList对象place
     * for循环遍历，如果values[i].equals(e)，那么place.addOneObject(i);
     * 返回place
     */
    public TArrayList getAllIndex(Object e) {
        TArrayList place = new TArrayList(10);
        if (size == 0) {
            System.out.println("没有元素可以获取");
            return place;
        }
        for (int i = 0; i < size; i++) {
            if (values[i].equals(e)) {
                place.addOneObject(i);
            }
        }
        return place;
    }

9、根据index，修改一个元素

 /**
     * 先判断index是否合法
     * 再判断index是否越界
     * 直接values[index] = e;
     */
    public void setValue(int index, Object e) {
        if (index < 0 || index >= length) {
            throw new IllegalArgumentException("索引不合法");

        }
        if (index >= size) {
            throw new IllegalArgumentException("索引越界");
        }
        values[index] = e;
    }

10、用newObject取代所有的oldData;

 /**
     * 先判断是否为空
     * 然后for循环遍历，如果values[i].equals(oldData)，那么values[i] = newData;
     */
    public void replaceAll(Object oldData, Object newData) {
        if (size == 0) {
            System.out.println("没有元素可以替换");
            return;
        }
        for (int i = 0; i < size; i++) {
            if (values[i].equals(oldData)) {
                values[i] = newData;
            }
        }
    }

附录所有代码如下：

package TArrayList;

import java.io.PrintWriter;
import java.util.ArrayList;

public class TArrayList {
    /**
     * 因为数组的组成的单位是原子性的一个对象，不需要再像链表一样再弄一个结点LNode类（和操作链表类分开）
     * 思路：
     * 1、先写数据域
     * 底层数组
     * 数组中元素个数
     * 数组长度
     * final int DEF_LENGTH = 10;
     * final int MIN_LENGTH = 2;
     * ---
     * 2、再写构造方法
     * 无参构造方法
     * 有参构造方法
     * ---
     * 3、操作方法
     * （1）添加一个元素（可扩容）
     * public void addOneObject(Object e)
     * （2）添加数组（一次添加多个元素）（可扩容，三种情况都已经实现）
     * public void addAllObjects(Object[] es)
     * （3）删除一个元素
     * public Object removeOne(int index)
     * （4）删除所有值为data对象的元素
     * public void removeAll(Object data)
     * （5）根据index，获取一个元素
     * public Object getObject(int index)
     * （6）根据元素，获得位置index，返回一个数组；
     * public TArrayList getAllIndex(Object e)
     * （7）根据index，修改一个元素
     * public void setValue(int index, Object e)
     * （8）用newObject取代所有的oldData;
     * public void replaceAll(Object oldData, Object newData)
     * ---
     */

    //属性
    //底层数组
    Object[] values;
    //数组中元素个数
    public int size;
    //数组长度
    int length;
    final int DEF_LENGTH = 10;
    final int MIN_LENGTH = 2;

    //无参构造方法
    public TArrayList() {
        values = new Object[DEF_LENGTH];
        length = DEF_LENGTH;
        size = 0;

    }

    //有参构造方法
    public TArrayList(int length) {
        if (length < MIN_LENGTH) {
            throw new IllegalArgumentException(length + "不能小于" + MIN_LENGTH);

        }
        values = new Object[length];
        this.length = length;
        size = 0;

    }

    // 方法
    // 添加一个元素（可扩容）
    /**
     * 两种情况 因为最小的数组长度是2，所以不会有第三种情况：1.5倍不够
     * 当前数组中元素个数<length：直接添加
     * 当前数组中元素个数>=length&&当前数组中元素个数<length+(length>>1)：扩容到原来的1.5倍
     * 直接values[size++]=e;
     */
    public void addOneObject(Object 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];
            }
            length = newLength;
            values = newValues;
            System.out.println("扩容完成" + length);

        }
        values[size++] = e;

    }

    //添加数组（一次添加很多元素）（可扩容）
    // 三种情况
    /**
     * 当前数组中元素个数+es.length<length：直接添加
     * 当前数组中元素个数+es.length>=length&&当前数组中元素个数+es.length<length+(length>>1)：扩容到原来的1.5倍
     * 当前数组中元素个数+es.length>=length+(length>>1)：扩容到原来的1.5倍+es.length
     * 直接values[size++]=e;
     */
    public void addAllObjects(Object[] es) {
        if (es.length + size < length) {
            for (int i = 0; i < es.length; i++) {
                values[size++] = es[i];
            }
        } else if (es.length + size >= length && es.length + size < length + (length >> 1)) {
            int oldLength = length;
            int newLength = oldLength + (oldLength >> 1);
            Object[] newValues = new Object[newLength];
            for (int i = 0; i < oldLength; i++) {
                newValues[i] = values[i];

            }
            length = newLength;
            values = newValues;
            System.out.println("扩容完成" + length);
            for (int i = 0; i < es.length; i++) {
                values[size++] = es[i];
            }
        } else {
            int oldLength = length;
            int newLength = oldLength + es.length + (es.length >> 1);
            Object[] newValues = new Object[newLength];
            for (int i = 0; i < oldLength; i++) {
                newValues[i] = values[i];

            }
            length = newLength;
            values = newValues;
            System.out.println("扩容完成" + length);
            for (int i = 0; i < es.length; i++) {
                values[size++] = es[i];
            }

        }
    }


    //根据index,删除一个元素
    /**
     * 先判断是否为空
     * 先判断index是否合法
     * 再判断index是否越界
     * 先保存要删除的元素
     * 再从index开始，后面的元素依次向前移动，覆盖就好
     */
    public Object removeOne(int index) {
        if (size == 0) {
            System.out.println("没有元素可以删除");
            return null;
        }
        if (index < 0 || index >= length) {
            throw new IllegalArgumentException("索引不合法");
        }
        if (index >= size) {
            throw new IllegalArgumentException("索引越界");
        }
        Object e = values[index];
        for (int i = index; i < size - 1; i++) {
            values[i] = values[i + 1];
        }
        size--;
        return e;

    }
    //删除所有值为data对象的元素
    /**
     * 先判断是否为空
     * for循环遍历所有元素，如果values[i].equals(data)，就把后面的元素依次向前移动，覆盖就好
     */
    public void removeAll(Object data) {
        if (size == 0) {
            System.out.println("没有元素可以删除");
            return;
        }
        for (int i = 0; i < size; i++) {
            if (values[i].equals(data)) {
                for (int j = i; j < size - 1; j++) {
                    values[j] = values[j + 1];
                }
                size--;
                i--;
            }
        }
    }
    //根据index，获取一个元素
    /**
     * 先判断是否为空
     * 先判断index是否合法
     * 再判断index是否越界
     * 直接返回values[index]
     */
    public Object getObject(int index) {
        if (size == 0) {
            System.out.println("没有元素可以获取");
            return null;
        }
        if (index < 0 || index >= length) {
            throw new IllegalArgumentException("索引不合法");

        }
        if (index >= size) {
            throw new IllegalArgumentException("索引越界");
        }
        return values[index];
    }

    //根据元素，获得位置index，返回一个数组；
    /**
     * 先判断是否为空
     * 先判断index是否合法
     * 再判断index是否越界
     * 创建一个TArrayList对象place
     * for循环遍历，如果values[i].equals(e)，那么place.addOneObject(i);
     * 返回place
     */
    public TArrayList getAllIndex(Object e) {
        TArrayList place = new TArrayList(10);
        if (size == 0) {
            System.out.println("没有元素可以获取");
            return place;
        }
        for (int i = 0; i < size; i++) {
            if (values[i].equals(e)) {
                place.addOneObject(i);
            }
        }
        return place;
    }

    //根据index，修改一个元素

    /**
     * 先判断index是否合法
     * 再判断index是否越界
     * 直接values[index] = e;
     */
    public void setValue(int index, Object e) {
        if (index < 0 || index >= length) {
            throw new IllegalArgumentException("索引不合法");

        }
        if (index >= size) {
            throw new IllegalArgumentException("索引越界");
        }
        values[index] = e;
    }

    //用newObject取代所有的oldData;

    /**
     * 先判断是否为空
     * 然后for循环遍历，如果values[i].equals(oldData)，那么values[i] = newData;
     */
    public void replaceAll(Object oldData, Object newData) {
        if (size == 0) {
            System.out.println("没有元素可以替换");
            return;
        }
        for (int i = 0; i < size; i++) {
            if (values[i].equals(oldData)) {
                values[i] = newData;
            }
        }
    }


}