Java自定义数组

前言

今天有点无聊,写了一个自定义数组,里边主要实现很多js中数组的方法，例如：排序、数组连接、删除、剪切。算是加深对java的一些基础操作的印象。

代码

/**
 * @Auther dbc
 * @Date 2020/9/5 22:03
 * 自定义数组,数组元素为Object类
 * 构造方法：
 *    MyArrayList() 初始化数组,长度为0
 *    MyArrayList(int size) 创建长度为size的数组
 *    MyArrayList(Object... objects) 初始化即加入一些元素
 * 主要方法：
 *    String join()  方法用于根据分隔符把数组中的所有元素放入一个字符串,默认分隔符为","逗号.
 *    String join(String separator) example: 元素为0,1,2,3的数组 使用join("-")得到：0-1-2-3
 *    String toString() 得到数组字符串形式
 *    boolean add(int index,Object o) 在指定索引后增加元素
 *    void add(Object... objects) 在数组末尾添加元素
 *    Object pop() 删除并返回数组最后一个元素
 *    MyArrayList splice(int index,int length) 在原数组从索引index开始剪切length长度个元素,返回剪切后的新的数组
 *    MyArrayList update(int index,Object o) 修改指定索引的元素
 *    Object shift() 删除并返回数组的第一个元素
 *    void unShift(Object... objects)  在数组开头添加元素
 *    MyArrayList slice(int start,int end) 方法可从已有的数组中返回选定的元素
 *    void sortAsc()  对数组进行升序排序(选择排序)   前提:数组元素均为Integer、Double、Float中的一种
 *    void sortDesc()  对数组进行降序排序(冒泡排序)   前提:数组元素均为Integer、Double、Float中的一种
 *    MyArrayList concat(MyArrayList... allList)  方法用于连接两个或多个数组(该方法不会改变现有的数组)
 *    void reverse() 颠倒数组中的元素
 *    Object charAt(int index)  获取索引index处的元素
 *    int indexOf(Object o,int startIndex) 从startIndex开始向后获取某个元素在数组的索引,没有则返回-1
 *    int lastIndexOf(Object o,int startIndex) 从startIndex开始向前获取某个元素在数组的索引,没有则返回-1
 *
 */
public class  MyArrayList {
    private Object[] elementData;//元素
    private int size;//数组长度
    private static final float DEFAULT_EXPAND_FACTOR = 0.75f;//扩容因子
    private static final float DEFAULT_NARROW_FACTOR = 0.5f;//缩小容量的因子
    private static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量
    private static String joinSeparator =","; //join方法默认的分隔符

    /**
     * 从startIndex开始向前获取某个元素在数组的索引,没有则返回-1
     * @param o
     * @param startIndex
     * @return
     */
    public int lastIndexOf(Object o,int startIndex){
        if(startIndex<0) startIndex=0;
        if(startIndex>=size) startIndex=size-1;
        for(int i=startIndex;i>=0;i--){
            if(elementData[i].equals(o)) return i;
        }
        return -1;
    }

    /**
     * 从startIndex开始向后获取某个元素在数组的索引,没有则返回-1
     * @param o
     * @param startIndex
     * @return
     */
    public int indexOf(Object o,int startIndex){
        if(startIndex<0) startIndex=0;
        if(startIndex>=size) startIndex=size-1;
        for(int i=startIndex;i<size;i++){
            if(elementData[i].equals(o)) return i;
        }
        return -1;
    }

    /**
     * 颠倒数组中的元素
     */
    public void reverse(){
        Object o;
        for(int i=0;i<size/2;i++){
            o=elementData[i];
            elementData[i] = elementData[size-i-1];
            elementData[size-i-1] =o;
        }
    }

    /**
     * 连接多个数组
     * @param allList
     * @return
     */
    public MyArrayList concat(MyArrayList... allList){
        MyArrayList concatData =new MyArrayList(this.getElementData());
        for (MyArrayList myArrayList:allList) {
            concatData.add(myArrayList.getElementData());
        }
        return concatData;
    }


    /**
     * 对数组进行升序排序
     */
    public void sortAsc(){
        if(!isAllNumArray()) return;
        Object o;
        //选择排序
        for(int i=0;i<size-1;i++){
            int min = i;//最小数的索引
            for(int j=i+1;j<size;j++){
                if(Double.parseDouble(elementData[i].toString())>Double.parseDouble(elementData[j].toString())){
                    min = j;
                }
            }
            if(min ==i) continue;
            o = elementData[i];
            elementData[i]=elementData[min];
            elementData[min] = o;
        }
    }

    /**
     * 对数组进行降序排序
     */
    public void sortDesc(){
        if(!isAllNumArray()) return;
        Object o;
        //冒泡排序
        for(int i=0;i<size-1;i++){
            for(int j=i+1;j<size;j++){
                if(Double.parseDouble(elementData[i].toString())<Double.parseDouble(elementData[j].toString())){
                    o=elementData[i];
                    elementData[i]=elementData[j];
                    elementData[j]=o;
                }
            }
        }
    }

    /**
     * 方法可从已有的数组中返回选定的元素
     * @param start
     * @param end
     * @return
     */
    public MyArrayList slice(int start,int end){
        if(start<0) return new MyArrayList();
        if(end>=size) end=size-1;
        Object[] sliceData =new Object[end-start+1];
        for(int i=start;i<=end;i++){
            sliceData[i-start]=elementData[i];
        }
        return new MyArrayList(sliceData);
    }

    /**
     * 在数组开头添加元素
     * @param objects
     */
    public void unShift(Object... objects){
        int len =objects.length;
        ensureCapacity(len);
        for(int i=size+len-1;i>=len;i--){
            elementData[i]=elementData[i-len];
        }
        for (int i=0;i<len;i++){
            elementData[i]=objects[i];
        }
        size+=len;
    }

    /**
     * 删除并返回数组的第一个元素
     * @return
     */
    public Object shift(){
        if(size<=0) return null;
        Object o = elementData[0];
        for(int i=0;i<size-1;i++){
            elementData[i]=elementData[i+1];
        }
        size--;
        return o;
    }

    /**
     * 修改指定位置的元素
     * @param index
     * @param o
     * @return
     */
    public MyArrayList update(int index,Object o){
        if(index<0 || index>=size) return this;
        this.elementData[index]=o;
        return this;
    }

    /**
     * 删除元素,并返回被删除的元素数组
     * @param index 从index索引开始删除
     * @param length 删除的长度。若删除超过数组下标,默认从索引index一直删除到数组的最后一个元素。
     * @return
     */
    public MyArrayList splice(int index,int length){
        if(index<0 || index>size-1) return new MyArrayList();
        if(length<=0) return new MyArrayList();
        if(index+length>size) length =size-index;
        Object[] removeList =new Object[length];
        //开始删除
        for(int i=0;i<length;i++){
            removeList[i] =elementData[index+i];
            if(i+length<elementData.length){
                elementData[index+i] =elementData[index+length+i];
            }else {
                elementData[index+i]=null;
            }
        }
        for(int i=index+length;i<size;i++){
            if(i+length>=elementData.length) break;
            elementData[i] = elementData[i+length];
        }
        size-=length;
        return new MyArrayList(removeList);
    }



    /**
     * 删除并返回数组的最后一个元素
     */
    public Object pop(){
        if(size<=0) return null;
        Object removeEle=elementData[size-1];
        elementData[--size]=null;
        return removeEle;
    }

    /**
     * 增加元素 方式二:指定下标的后面添加
     * @param o 新元素
     * @param index 索引
     */
    public boolean add(int index,Object o){
        if(index<0 || index>=size) return false;
        ensureCapacity(1);//检测容量
        for(int i=size;i>index+1;i--){
            elementData[i] =elementData[i-1];
        }
        elementData[index+1]=o;
        size++;
        return true;
    }

    /**
     * 增加元素 方式一:末尾添加
     * js中的push()方法
     */
    public void add(Object... objects){
        //检测容量
        ensureCapacity(objects.length);
        //末尾增加
        for(int i=0;i<objects.length;i++){
            elementData[size++] =objects[i];
        }
    }

    /**
     * 获取数组长度
     *
     */
    public int getSize(){
        return this.size;
    }
    /**
     * toString
     */
    public String toString(){
        StringBuffer sb =new StringBuffer("[");
        for(int i=0;i<size;i++){
            sb.append(elementData[i]);
            sb.append(",");
        }
        String str;
        if(size>0){
            str = sb.substring(0, sb.length() - 1);
            str+="]";
        }else{
            sb.append("]");
            str =sb.toString();
        }
        return str;
    }
    /**
     * join() 方法用于把数组中的所有元素放入一个字符串
     * 元素是通过指定的分隔符进行分隔的
     * 使用默认的方法
     */
    public String join(){
        StringBuffer sb =new StringBuffer();
        for(int i=0;i<size;i++){
            sb.append(elementData[i]);
            sb.append(joinSeparator);
        }
        if(size==0) return "";
        return sb.substring(0, sb.length() - 1);
    }
    /**
     * join() 方法用于把数组中的所有元素放入一个字符串
     * 元素是通过指定的分隔符进行分隔的
     * 使用默认的方法
     */
    public String join(String separator){
        StringBuffer sb =new StringBuffer();
        for(int i=0;i<size;i++){
            sb.append(elementData[i]);
            sb.append(separator);
        }
        if(size==0) return "";
        return sb.substring(0, sb.length() - 1);
    }

    /**
     * @param addNum 此次添加的数目
     * 检测数组容量与实际元素个数是否达到扩容标准,若达到则扩容,否则不管
     */
    private void ensureCapacity(int addNum){
        //容量*扩容因子>size && 容量*缩容因子<size
        if(size+addNum<elementData.length*DEFAULT_EXPAND_FACTOR
                && size+addNum<elementData.length*DEFAULT_NARROW_FACTOR) return;
        //达到扩容要求,计算新的容量
        int capacity = (int)((size+addNum)/DEFAULT_EXPAND_FACTOR);
        //大于最大容量,不管了只有
        if(capacity>MAXIMUM_CAPACITY) capacity =MAXIMUM_CAPACITY;
        elementData= Arrays.copyOf(elementData,capacity);
    }

    /**
     * 获取所有数组元素
     * @return
     */
    public Object[] getElementData(){
        return Arrays.copyOf(this.elementData,size);
    }
    /**
     * 获取数组某个元素
     * @return
     */
    public Object charAt(int index){
        if(index<0 || index>=size) return null;
        return this.elementData[index];
    }

    /**
     * 判断数组元素是否都是数字
     * @return
     */
    private boolean isAllNumArray(){
        for(int i=0;i<size;i++){
            if(elementData[i] instanceof Integer || elementData[i] instanceof Float
                    || elementData[i] instanceof Double) {
            }
            else return false;
        }
        return true;
    }

    public MyArrayList(){
        this.size =0;
        this.elementData =new Object[0];
    }

    /**
     * 定义长度为size的空数组
     * @param size
     */
    public MyArrayList(int size){
        if(size<0) size=0;//确保不为负数
        this.elementData =new Object[size];
        this.size=0;
    }
    /**
     * 初始化数组,并初始化数组内容
     * @param objects
     */
    public MyArrayList(Object... objects){
        this.size=objects.length;
        elementData=Arrays.copyOf(objects,size);
        ensureCapacity(1);//扩容

    }
}