java中对数组的基本操作（增删改查。。。）

1、向数组后添加元素

数组后添加元素很简单，只要在当前size外置放置即可，并且更新size，size后移一位，size++。

2、向数组指定位置添加元素

指定位置添加元素原则：若该位置无元素直接放入，若该位置有元素占据，从该位置起往后所有元素往后挪1位，将位置腾出来后放入要插入的元素即可。

3 在数组中查询元素

（1）通过索引查询某个位置的元素

（2）通过索引替换某个位置元素

（3）通过遍历查看是否元素e

（4） 通过遍历搜索元素e的位置

4 从数组中删除元素

1 删除指定位置元素

删除元素后的元素依次向前覆盖，size最后也要减减，但是要注意只是覆盖原位置的元素，不是删除，最后size指向一个数，不影响，因为用户会检查合法性，读取数据是限定在0到size-1这些位置元素上的。

最后删除结束数组的模样

public class Array{
    pritvate int[] data;
    private int size;
//私有成员变量 数组类型，名字，存储数
// 构造函数，传入数组的容量capacity构造Array
public Array(int capacity){
      data = new int[capacity];
      size = 0;
}

//无参数的构造函数，默认数组的容量capacity=10
public Array(){
     this(capacity: 10);
}
//获取数组中元素的个数
public int getSize(){
   return size;
}
//获取数组的容量
public int getCapacity(){
   return data.length;
}
//返回数组是否为空
public boolean isEmpty(){
   return size==0;
}
//向所有元素后添加一个新元素
public void addlast(int e){
//if(size == data.length)
  //  throw new IllegalArgumentException("AddLast failed. Array is full.")
//data[size] = e;
//size++;
       add(size, e);
}
//在所有元素前面添加一个元素
public void addFirst(int e){
    add(index:0, e);
}
 //在第index位置插入一个新元素（指定位置插入）e
public void add(int index , int e){
   if（size == data.length)
        throw new IllegalArgumentException("Add failed. Array is full.")
   if(index < 0 ||index >size）
          throw new IllegalArgumentException("Add failed. Require index >= 0 and  index<= size.")
   for(int i = size - 1 ; i >=index ; i --)
       data[i+1] = data[i];
   data[index] = e;
   size ++;
 }
// 获取index索引位置的元素
int get(int index){
     if(index < 0 || index >=size)
        throw new IllegalArgumentException("Get failed. Index is illegal.");
     return data[index];
}
//修改index索引位置的元素为e
void set（int index ， int e）{
   if（index < 0 || index >= size)
       throw new IllegalArgumentException（” get failed, index is Illegal");
   data[index] = e;
}
//查找数组中是否有元素e （是否包含e）
public boolean contains(int e){
     for(int i = 0; i < size ; i ++){
         if(data[i] == e)
             return true;
}
      return false;
}
//查找数组中元素e所在的索引，如果不存在元素e，则返回 -1(搜素元素e）
public int find(int e){
     for(int i = 0; i < size ; i ++){
        if(data[i] == e)
            return i;
}
     return -1;
}
//从数组中伤处index位置的元素，返回删除元素
public int remove(int index){
   if(index < 0 || index >= size)
      throw new IllegalArgumentException("Remove failed. Index is Illegal.")
 
   int ret = data[index]
   for(int i = index +1 ; i < size ; i ++)
       data[i-1] = data[i];
   size --;
   return ret;
}
//从数组中删除第一个元素
public int removeFirst(){
          return remove(index: 0);
}
//从数组中删除最后一个元素，返回删除的元素
public int removeLast(){
    return remove(index:size -1);
}
//从数组中删除元素e
public void removeElement(int e){
  int index = find(e)
  if(index != -1)
    remove(index);
}

@Override
public String toString(){
       StringBuilder res = new StringBuilder();
       res.append(String.format("Array: size = %d ,capacity = %d, 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();
  }
}
                res.append(", ");
 

主函数部分

public class Main {
      public static void main(String[] args) {
            Array arr = new Array(capacity:20);
            for(int i = 0; i < 10 ; i ++)
               arr.addLast(i);
            System.out.println(arr);

            arr.add(index:1, e:100);
            System.out.println(arr);
            
            arr.addFirst(e:-1);
            System.out.println(arr);
            
            arr.remove(index:2);
            System.out.println(arr);
            
            arr.removeElement(e:4)
            System.out.println(arr);
            
            arr.removeFirst();
            System.out.println(arr);
    }
}