实现基于数组的List

实现基于数组的List

1，关于泛型

1.1 基本方法

类似于C++中的模板，使用方法如下

//泛型方法：该方法在调用时可以接收不同类型的参数
public static <T> void printArray(E[] inputArray){
    for(E element:inputArray){
        System.out.println(element);
    }
    System.out.println();
}
//泛型类：可以包括多个类型参数
public class Box<T,E,...>{
    private T t;
    private E e;
    public void add(T t){
        this.t=t;
    }
    public T get(){
        return T;
    }
}

1.2 有界类型的参数

• <? extends T> 表示该通配符所代表的类型是T类型的子类。
• <? super T> 表示该通配符所代表的类型是T类型的父类。

   // 比较三个值并返回最大值
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {                     
      T max = x; // 假设x是初始最大值
      if ( y.compareTo( max ) > 0 ){
         max = y; //y 更大
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // 现在 z 更大           
      }
      return max; // 返回最大对象
   }

1.3 类型通配符

类型通配符一般是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是 List，List 等所有 List<具体类型实参> 的父类。

//即，该函数可以接受List泛型类的所有具体类
public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
}

通配符也可以限定其上下限

//如此定义就是通配符泛型值接受Number及其下层子类类型。
public static void getUperNumber(List<? extends Number> data) {
    System.out.println("data :" + data.get(0));
}
List<? super Number> //表示类型只能接受 Number 及其上层父类类型，

public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn) {
    return uniApplyStage(asyncPool, fn);
}

2，关于List类的功能分析

• 属性

  • 储存数据的数组
  • 已存储数量
  • 总长度（默认的长度）

• 构造方法

  • 无参构造
  • 有参构造
    • 长度（容量）
    • 数组，链表，本类，对类

• 方法

  • 增：这个过程要注意容量变化，即使扩容，一般为当前容量的1.5倍
    • 下标添加
    • 尾部添加
  • 查
    • 下标查找（返回对象）
    • 值查找（返回本类的一个Integer的MyList对象，为对应的下标）
    • 查找两个MyList对象的并集
  • 删：注意这个过程的数组前移与缩容
    • 下标删除（返回boolean）
    • 值删除（先查后删除，返回boolean）
  • 改
    • 下标修改（返回boolean）
    • 值修改（先查后改，返回被修改元素的对应下标的MyList）
  • 合并
    • 去重合并（考虑排序去重与合并）
  • 排序
    • 数值类型的排序
    • 比较器的排序

3，具体实现

3.1 MyList类的定义

public class MyList<T>{
    private Object[] valueArray={};
    private int length;
    private int maxSize;
    private int defaultMaxSize=10;
    
    public int length(){return length;}
}

3.2 构造方法

//无参构造
    public MyList(){
        maxSize = defaultMaxSize;
        valueArray = new Object[maxSize];
        length = 0;
    }
//有参构造：初始大小
	public MyList(int initSize){
        if(initSize <= 0){
            System.err.println ("输入不合法！！");
        }
        if(initSize > 0 && initSize <= 10){
            maxSize = defaultMaxSize;
            valueArray = new Object[maxSize];
            length = 0;
        }
        if(initSize > 10 && initSize < Integer.MAX_VALUE - 100){
            maxSize = initSize;
            valueArray = new Object[maxSize];
            length = 0;
        }
        if(initSize > Integer.MAX_VALUE - 100){
            System.err.println ("可以考虑使用大数量数组队列 ");
        }
    }

3.3 增

//扩容方法：获取更长的指针空间，将指针指向原来的对象
    private void grow(){
        // 扩容
        // 先计算 需要新数组长度
        int oldLength = maxSize;
        int newLength = oldLength+(oldLength>>1);
        maxSize = newLength;
        Object[] newArray = new Object[maxSize];
        // 遍历拷贝数组
        for(int i = 0; i < oldLength; i++){
            newArray[i]=valueArray[i];
        }
        valueArray =  newArray;
        newArray=null;
    }
//值添加
    /**
     * 添加数据
     * @param value
     */
    public void add(T value){
        if(length >= maxSize){
            grow ();
        }
        valueArray[length++]=value;

    }
//指定位置添加
    public void add(T value,int index){
        if(index<0||index>=length){
            System.out.println("输入下标不合法");
        }
        if(length >= maxSize){
            grow ();
        }
        moveBackward(1,index);
        valueArray[index]=value;
        length++;
    }
//数据后移方法：从某个数据开始之后的所有数据向后移动指定长度
    /**
     * 添加数据
     * @param lens,index（后移长度，开始下标）
     */
    private void moveBackward(int lens,int index){
        while((lens+length)>maxSize){
            grow();
        }
        for(int i=length-1;i>=index;i--){
            valueArray[i+lens]=valueArray[i];
        }
    }

3.4 查

//按下标查找，返回值
    /**
     * 根据下标查找数据
     * @param index
     */
    public Object searchByIndex(int index){
        if(index<0||index>=length){
            System.out.println("输入下标不合法");
        }
        return (T)valueArray[index];
    }
//按值查找
    /**
     * 根据值查找数据
     * @param value
     */
    public MyList searchByValue(T value){
        MyList<Integer> res=new MyList<>();
        for(int i=0;i<length;i++){
            if(((T)valueArray[i]).equals(value))
                res.add(i);
        }
        return res;
    }
//查找与MyList的交集
    /**
     * 根据MyList对象查找并集（基本方法）
     * @param myList
     */
    /**
     * 根据MyList对象查找交集（基本方法）
     * @param myList
     */
    public MyList searchInterSection_Prim(MyList<T> myList){
        MyList resList=new MyList();
        for(int i=0;i<length;i++){
            for(int j=0;j< myList.length;j++){
                if(((T)valueArray[i]).equals((T) myList.valueArray[j])) {
                    resList.add(valueArray[i]);
                    break;
                }
            }
        }
        return resList;
    }
    /**
     * 根据MyList对象查找并集（消除了过量元素）
     * @param myList
     */
    public MyList searchInterSection(MyList myList){
        MyList resList=new MyList();
      resList=myList.searchInterSection_Prim(searchInterSection_Prim(myList));
        return resList;
    }

3.5 删

//数组前移方法
	/**
     * 向前移动数组，将从[index,end)元素向前移动lens个位置
     * @param lens,index
     */
    private void moveForward(int lens,int index){
        if(lens>index){
            System.out.println("输入不合法1");
            return;
        }
        System.out.println(lens+" "+index+" ");
        for(int i=index;i<length;i++){
            valueArray[i-lens]=valueArray[i];
        }
    }
//减容方法
    private void reduce() {
        int oldMaxSize = maxSize;
        int newMaxsize = (oldMaxSize/3)*2+2;
        maxSize = newMaxsize;
        Object[] newArray = new Object[maxSize];
        // 遍历拷贝数组
        for(int i = 0; i < length; i++){
            newArray[i]=valueArray[i];
        }
        valueArray =  newArray;
        newArray=null;//便于回收器回收
    }
//根据下标删除
    /**
     * 根据下标删除
     * @param index
     */
    public boolean deleteByIndex(int index){
        if(index<0||index>=length){
            System.out.println("输入下标不合法");
            return false;
        }
        moveForward(1,index+1);//数据前移
        length--;
        if(length<(maxSize>>1))
            reduce();
        return true;
    }
//根据值删除
    /**
     * 根据值删除，返回删除的个数
     * @param value
     */
    public int deleteByValue(T value){
        MyList delList=searchByValue(value);
        int i=0;
        for(i=0;i<delList.length;i++){
            //每次前移之后，真实的对象的位置会前移一个
            moveForward(1,((Integer) delList.valueArray[i])+1-i);
            length--;
        }
        if(length<(maxSize>>1))
            reduce();
        return delList.length;
    }

3.6 改

//根据下标修改
	/**
     * 根据下标改元素
     * @param index,value
     */
    public boolean modifyByIndex(int index,T value){
        if(index<0||index>=length){
            System.out.println("输入不合法");
            return false;
        }
        valueArray[index]=value;
        return true;
    }
//根据值修改
    /**
     * 根据值修改，返回修改的个数
     * @param value
     */
    public int modifyByValue(T value,T newValue){
        MyList modList=searchByValue(value);
        for (int i = 0; i < modList.length; i++) {
            valueArray[(Integer) modList.valueArray[i]]=newValue;
        }
        return modList.length;
    }

3.7 排序（仅对数值类型）

//快排
    /**
     * Sort(快排实现)
     * @param
     */
    public MyList sort_quick(){
        MyList sortedList=this.clone();
        quickSort(sortedList.valueArray,0,length-1);
        return sortedList;
    }
    private void quickSort(Object[] target,int left,int right){
        if(left>=right)
            return;
        int pivot=(Integer) target[left];
        Object temp;
        int i=left,j=right;
        while(i<j){
            while((Integer)target[j]>=pivot&&i<j)
                j--;
            while((Integer)target[i]<=pivot&&i<j)
                i++;
            if(i<j){
                temp=target[i];
                target[i]=target[j];
                target[j]=temp;
            }
        }
        target[left]=target[j];
        target[j]=pivot;
        quickSort(target,left,j-1);
        quickSort(target,j+1,right);
    }
//冒泡
    public MyList sort_bubble(){
        MyList sortedList=this.clone();
        bubbleSort(sortedList.valueArray,sortedList.length);
        return sortedList;
    }
    public void bubbleSort(Object[] sortedList,int length){
        for (int i = 0; i < length-1; i++) {
            for (int j = 0; j < length-1-i; j++) {
                if((Integer)sortedList[j]>(Integer)sortedList[j+1]){
                    Object temp=sortedList[j+1];
                    sortedList[j+1]=sortedList[j];
                    sortedList[j]=temp;
                }
            }
        }
    }

3.7 打印，equals

    public void printMyList(){
        for (int i = 0; i < length; i++) {
            System.out.print((T)valueArray[i]+" ");
        }
        System.out.println();
    }
    public boolean equals(MyList myList){
        if(this.length!=myList.length){
            return false;
        }
        for (int i = 0; i < this.length; i++) {
            if(((T)valueArray[i]).equals((T)myList.valueArray[i])) {
                return false;
            }
        return true;
    }