二次封装java数组且实现动态扩容

     今天呢，我在这里跟大家分享一下关于数据结构与算法中的基础(数组)，数组对于学软件的来说一定不陌生，什么c，c++，java，go，javascript等等语言都会有。但是大家在使用的过程中可能并没有去深究数组底层到底是如何实现的，所以，在这里封装了一个java的动态数组，代码如下：：：：：：：：

package com.zp;

import com.sun.xml.internal.ws.server.sei.ValueGetter;

/**
 *二次封装数组,动态数组
 * @author zhaopeng
 * @create 2019-12-22 21:52
 */
public class Array<E>{
   private E[] data;//存放数据的数组

   private int size;//记录数据的个数

   public Array(int capaticy){
       data=(E[])new Object[capaticy];//java不支持泛型数组的创建，需要强制转换
   }

   public Array(){//默认的为10
       this(10);
   }

   //获取数组的元素个数
   public int getSize(){
       return size;
   }
   //获取数组的容量
   public int getCapacity(){
       return data.length;
   }

   //判断是否为空
   public boolean isEmpty(){
       return size==0;
   }

   //在元素后添加数据
   public void addLast(E e){
          add(size,e);
   }

   //向所有的元素前添加一个新的元素
    public void addFirst(E e){
       add(0,e);
    }

   //在指定的索引插入新的元素
   public void add(int index,E e){
       if(size==data.length){
           resize();//扩容
       }
       if(index<0||index>size){  //index    0-----size
          throw new IllegalArgumentException("索引越界");
       }
       for(int i=size-1;i>=index;i--){
           data[i+1]=data[i];
       }
      // System.arraycopy(data,index,data,index+1,data.length-index-1);
       data[index]=e;
       size++;
   }

   //根据索引获取值
   public E get(int index){
       if(index<0||index>=size){  //index    0-----size
           throw new IllegalArgumentException("索引越界");
       }
       return data[index];
   }

   //获取最后一个值
   public E getLast(){
       return get(size-1);
   }

   //获取第一个值
   public E getFirst(){
       return get(0);
   }
   //设置相应位置的值
   public void set(int index,E e){
       if(index<0||index>=size){  //index    0-----size
           throw new IllegalArgumentException("索引越界");
       }
       data[index]=e;
   }

   //查找数组中是否存在元素e
   public boolean contains(E e){
       for(int i=0;i<size;i++){
           if(data[i].equals(e)){
              return true;
           }
       }
     return false;
   }

   //查找数组中元素e所在的第一个索引，如果不存在元素e就返回-1
   public int find(int e){
       for(int i=0;i<size;i++){
           if(data[i].equals(e)){
               return i;
           }
       }
     return -1;
   }


   //查找数组中元素e所在的所有索引
   public int[] findAll(int  e){
       int[] res=new int[size];
       for(int i=0;i<size;i++){
         if(data[i].equals(e)){
             res[i]=1;
         }
       }
       return res;
   }

   //删除指定位置的元素,并返回该元素
   public E remove(int index){
       if(index<0||index>=size){  //index    0-----size
           throw new IllegalArgumentException("索引越界");
       }
       E res=data[index];
       for(int i=index+1;i<size;i++){
           data[i-1]=data[i];
       }
       size--;
       data[size]=null;
       if(size==data.length/4&&data.length/2!=0){//缩小数组容量大小,,,防止复杂度的动荡
           resize(data.length/2);
       }else if(size==0){
           resize(10);//设置默认的容量大小为10
       }
       return res;
   }

   //删除第一个元素
   public E removeFirst(){
        return remove(0);
   }

   //删除最后一个元素
   public E removeLast(){
       return remove(size-1);
   }

    //根据元素的值进行删除第一个与该值相等的元素
    public boolean removeElement(int e){
        int index = find(e);
        if(index!=-1){
            remove(find(e));
            return true;
        }
        return false;
    }

    //根据元素值来删除该值的所有元素
    public void removeAllElement(int e){
        while(true){
            int index=find(e);
            if(index==-1){
                break;
            }
            remove(find(e));
        }
    }

    //实现数组的扩容,,,设置为默认扩大到原来的1.5倍
    public void resize(){
         int oldcapacity=data.length;//原来的容量
         int newcapacity=oldcapacity+(oldcapacity>>1);//新的容量
         E[] newarray=(E[])new Object[newcapacity];
        // System.arraycopy(data,0,newarray,0,data.length);//数组的copy
         for(int i=0;i<data.length;i++){
             newarray[i]=data[i];
         }
         data=newarray;
    }

    //指定量的扩容
    public void resize(int newcapacity){
        E[] newarray=(E[])new Object[newcapacity];
        for(int i=0;i<size;i++){
            newarray[i]=data[i];
        }
        data=newarray;//指向新的数组
    }

    //重写toString方法
   @Override
   public String toString(){
       StringBuilder res= new StringBuilder();
       res.append(String.format("Array:size = %d，capacity = %d\n",size,data.length));
       res.append("[");
       for(int i=0;i<size;i++){
         res.append(data[i]);
         if(i!=size-1){
           res.append(",");
         }
       }
       res.append("]");
        return res.toString();
   }
}

 

文章到此结束，测试代码大家可自行书写，谢谢大家的阅读。如果有什么问题，欢迎大家评论区留言哦！！！