创建数组（数组基本方法）

组相同类型数据的集合
java中数组特点：
1.数组在内存中是连续分配的
2.在创建数组时，要指明数组的长度
3.访问数组，通过索引，从0开始，到数组长度-1

功能：
1.插入：向索引位置插入一个元素，后面的元素往后平移，由此还可以引申出头部添加元素，尾部添加元素两个功能

2.删除：删除某个索引的元素，并把后面的元素整体前移，由此还可以引申出删除头部元素，删除尾部元素

3.获取：获取数组实际长度，获取数组容量，获取数组索引对应的值，获取由值对应的索引

4.判断：判断数组是否为空，判断是否含有某个元素

5.修改：修改索引位置的值

6.toString：重写toString方法，把数组中的元素转换成String类型便于显示出

package com.algo.lesson02;

import java.util.Random;

public class MyArr<T> {
    private  T[] data;//保存数据
    int size;//数组中实际存放元素的个数
    int capacity;//容积
    public MyArr(int capacity)
    {
        if(capacity<=0)
        {
            this.capacity=10;
        }else
        {
            this.capacity=capacity;

        }
        this.size=0;
        this.data=(T[])(new Object[this.capacity]);
    }

    //获取数组中实际存放元素的个数
    public int getSize()
    {
        return  size;
    }
    //获取空间大小
    public int getCapacity()
    {
        return capacity;
    }
    //判断数组是否为空
    public boolean isEmpty()
    {
        return size==0;
    }
    //像数组中添加元素尾插法
    public void add(T item)
    {
        insert(size, item);
    }
    //头插法
    public void addByHead(T item)
    {
         insert(0, item);
    }

    //插入元素
    public void insert(int index,T value)
    {
        //入参判断
        if(index<0||index>this.size){
            throw new IllegalArgumentException("index is invaild");
        }
        size++;
        if(capacity<=size)
        {
            addSize(2*size);
        }
        for (int i = size; i > index; i--) {
            data[i]=data[i-1];
        }
        this.data[index]=value;
    }

    //扩容
    public void addSize(int newCapacity)
    {
        T[] newData=(T[])(new Object[newCapacity]);
        for (int i = 0; i < size; i++) {
            newData[i]=data[i];
        }
        //改变容器
        this.data=newData;
        capacity=newCapacity;
    }



    //向数组中插入
    public void modifyValueByIndex(int index,T value)
    {
        //入参判断
        if(index<0||index>this.size){
            throw new IllegalArgumentException("index is invaild");
        }
        this.data[index]=value;
    }

    //获取指定位置的值
    public T getValueByIndex(int index)
    {
        if(index<0||index>=this.size){
            throw new IllegalArgumentException("index is invaild");
        }
        return this.data[index];
    }
    //判断是否含有值
    public int containsValue(T val)
    {
        for(int i=0;i<this.size;i++)
        {
            if(val.equals(data[i]))
            {
                return i;
            }
        }
        return-1;
    }

    //根据索引删除从数组中删除元素,返回删除的元素数据
    public T removeByIndex(int index)
    {
        if(index<0||index>=this.size){
          return null;
        }
        //找到需要删除的元素的位置
        T devalue=this.data[index];
        for(int i=index;i<size;i++)
        {
            data[i]=data[i+1];
        }
        size--;
        if (size<=capacity/4&&capacity/2>0)
        {
            addSize(capacity/2);
        }
        return devalue;
    }

    public T removeFromLast(){
        return removeByIndex(this.size - 1);
    }

    //获取数组中最后一个元素
    public T getLastValue()
    {

        return getValueByIndex(this.size-1);
    }
    //输出重写toString方法
    @Override
    public String toString() {
        StringBuffer stringBuffer=new StringBuffer("{");
        for (int i = 0; i < size; i++) {
            stringBuffer.append(data[i]);
            if(i<size-1)
            {
                stringBuffer.append(",");
            }
        }
        stringBuffer.append("}");
        return stringBuffer.toString();
    }
    //是否包含某元素
    public boolean contain(T data){
        for (int i = 0; i < this.size; i++) {
            if(data==this.value[i]){
                return true;
            }
        }
        return false;
    }




}

泛型：

我们的数组不仅是能存放int类型，当传参传入什么类型时，就应该保存什么类型，所以我们需要用到泛型