数组：数据结构中最基本的一个结构就是线性结构，而线性结构又分为连续存储结构和离散存储结构。所谓的连续存储结构其实就是数组。
优点： 查询较快如果知道坐标可以快速去地存取
缺点： 删除慢,大小固定

public class Array{
    private E[] data;
    private Integer size;
　　/**
　　 * 无参构造器
　　 */
    public Array(){
          this(10);
    }
    public Array(int capacity){
          data = (E[])new Object[capacity];
          size = 0;
    }
　　/**
     * 获取数组中的元素个数
     * @return
     */
    public Integer getSize(){
        return size;
    }
    /**
     * 获取数组的容量
     * @return
     */
    public Integer getCapacity(){
        return data.length;
    }

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

　　// 增：添加代码

　　//指定位置添加内容
　　public void add(int index, E param){
　　　　if(index < 0 || index >= size){
　　　　　　throw new IllegalArgumentException("Add fail, Because index is illegal");
　　　　}
　　　　//当内容大小size等于数组长度length，进行扩容处理
　　　　if(size == data.length){ 
　　　　　　resize(data.length * 2);
　　　　]
　　　　for(int i = size-1; i >= index; i--){
　　　　　　data[i + 1] = data[i];
　　　　}
　　　　data[index] = param;
　　　　size ++;
　　}
　　//在首位添加
　　public void addFirst(E param){
　　　　add(0,E param);
　　}
　　//在尾部添加
　　public void addLast(E param){
　　　　add(size - 1, param);
　　}
　　
　　//改：修改代码

　　//修改指定位置的内容
　　public void set(int index, E param){
　　　　if(index < 0 || index >= size ){
　　　　　　throw new IllegalArgumentException("Set Fail, Because index is illegal.");
　　　　}
　　　　data[index] = param;
　　}
　　
　　//查：查询代码
　　　
　　//返回指定位置的内容
　　public E get(int index){
　　　　if(index < 0 || index >= size){
　　　　　　throw new IllegalArgumentException("Get Fail, Because index is illegal");
　　　　}
　　　　return data[index];
　　}
　　//是否包含指定元素
　　public boolean contains(E param){
　　　　for(int i=0; i< size; i++){
　　　　　　if(Objects.equals(data[i],param)){
　　　　　　　　return true;
　　　　　　}
　　　　}
　　　　return false;
　　}
　　//返回指定内容第一个索引值
　　public Integer find(E param){
　　　　for(int i=0; i< size; i++){
　　　　　　if(Objects.equals(data[i],param)){
　　　　　　　　return i;
　　　　　　}
　　　　}
　　　　return -1;
　　}
　　//返回指定内容的所有索引值
　　public Integer[] findAll(E param){
　　　　int temp = 0;
　　　　Integer[] indexs = new Integer[size];
　　　　for(int i=0; i< size; i++){
　　　　　　if(Objects.equals(data[i],param)){
　　　　　　　  index[temp] = i;
　　　　　　　  temp ++;
　　　　　　}
　　　　}
　　　　return indexs;
　　}

　　//删：删除代码

　　//指定位置删除内容
　　public E remove(int index){
　　　　if(index < 0 || index >= size){
　　　　　　throw new IllegalArgumentException("Remove fail. Because index is illegal");
　　　　}
　　　　E delResult = data[index];
　　　　//将索引index之前的内容，统一向前移动一个位置
　　　　for(int i = index; i< size - 1; i++){
　　　　　　data[i] = data[i + 1];
　　　　}
　　　　size --;
　　　　//当内容长度小于等于data长度的四分之一，且data.length大于0，进行减容处理
　　　　if(size <= data.length/4 && data.length > 2){
　　　　　　　resize(data.length / 2);
　　　　}
　　　　return delResult;
　　}
　　//删除第一位
　　public E removeFirst(){
　　　　return remove(0);
　　}
　　//删除最后一位
　　public E removeLast(){
　　　　return remove(size - 1);
　　}
　　//移除指定内容.如果存在 删除成功，否则失败
　　public boolean removeElement(E param){
　　　　int paramIndex = find(param);
　　　　if(paramIndex != -1){
　　　　　　remove(paramIndex);
　　　　　　return true;
　　　　}
　　　　return false;
　　}
　　//移除所有，遍历删除
　　public void removeAllElement(E param){
　　　　for(int i = 0; i< size; i++){
　　　　　　removeElement(param);
　　　　}
　　}

　　//数组容积处理
　　public void resize(int newCapacity){
　　　　E[] newData = (E[])new Object[newCapacity];
　　　　for(int i=0; i< size; i++){
　　　　　　newData[i] = data[i];
　　　　}
　　　　data = newData;
　　}

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