【JAVA】简单实现MyArrayList

package com.tulun.src1;

import java.util.Arrays;

/**
 * 函数重载：
 * 条件：（同一个类） 1. 函数名相同 2.参数列表不同（个数，类型）
 *
 * this关键字的用法：
 * 1）this指向当前对象
 *     实例成员变量跟对象有关，有隐含的this引用。一个对象有一份实例变量
 * 2)this调用构造方法
 * 注意： 2.1）this()位于当前构造方法有效代码的第一行
 *        2.2）构造方法不能相互调用
 *        2.3）一个构造函数不能调用多个构造函数
 * static关键字：
 *    People p1 = new People(),p1 = new People(),p3 = new People();
 *  static:
 * 静态变量和实例变量的区别：
 * 1. 实例变量和对象有关，一个对象（一次new）对应一份成员变量
 *                       this->指向当前对象
 *    静态变量和类有关，跟对象无关，当前的静态变量没有隐含的this引用
 *    存储位置：实例变量（堆new）  静态变量（方法区）
 *    调用方式：实例变量：引用变量.   People p = new People();  p.name;
 *              静态变量：类名.    Arrays.copyOf();
 *
 *   静态方法：
 *      1.静态方法不能提供this引用
 *      2.成员方法里面包含隐含的this
 *      1.2 -> 静态方法不能直接调用非静态方法，必须通过对象调用
 *
 *      成员方法能不能调用静态方法???   可以
 *
 *     static: 有没有this, 跟对象有无关系
 *
 */

public class MyArrayList {
    private int[] element;
    private int size;//有效个数
    private final static int INTT = 10;//常量

    public MyArrayList(){
        this.element = new int[INTT];
        size = 0;
    }
    private void grow(){

        element = Arrays.copyOf(element,element.length+(element.length>>1));//1.5倍扩容
    }
    private void esureCapacity(){
        if(size == element.length){
            grow();
        }
    }
    public void addTail(int value){//尾插元素
        //是否需要扩容
        esureCapacity();
        element[size] = value;
        size++;
    }
    public void addHead(int value){//头插元素
        esureCapacity();
        //数据移动：
        for(int i=size-1;i>=0;i--){
            element[i+1] = element[i];
        }
        element[0] = value;
        size++;
    }

    public void deleteValue(int value){// 删除元素
        for(int i=0;i<size;i++){
            if(element[i] == value) {
                //移动数据进行覆盖
                for (int j = i + 1; j < size; j++) {
                    element[j - 1] = element[j];
                }
                size--;
                i--;
            }
        }
    }


    public void deleteIndex(int index){// 删除下标元素
        if(index < 0 || index >= size){
            return;
        }
        //数据移动
        for(int j = index+1;j<size;j++){
            element[j-1] = element[j];
        }
        size--;
    }

    public void deleteRange(int beginIndex,int endIndex){//删除范围元素
        if(beginIndex > endIndex || beginIndex<0||beginIndex>=size
                ||endIndex < 0){
            return;
        }
        if(endIndex >= size){
            endIndex = size-1;
        }
        int differ = endIndex - beginIndex+1;
        //数据移动
        for(int j = endIndex+1;j<size;j++){
            element[j-differ] = element[j];
        }
        size-=differ;
    }

    public void show(){
        for(int i=0;i<size;i++){
            System.out.print(element[i]+"  ");
        }
    }
}

测试结果

package com.tulun.src1;

import com.tulun.src1.MyArrayList;

import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        com.tulun.src1.MyArrayList my = new MyArrayList();
        my.addTail(1);
        my.addTail(1);
        my.addHead(2);
        my.addHead(2);
        my.show();

//        my.deleteValue(2);//删除2值
//        my.deleteIndex(0);//删除0号下标
//        my.deleteRange(6,9);//删除范围下标元素

    }
}