创建MyList泛型类

//where T:IComparable 可比较的接口
class MyList where T:IComparable
{
    /// 

    /// 用来存储元素的数组
    /// 
    private T[] array;

    /// 

    /// 当前添加元素的个数
    /// 
    private int count = 0;

    /// 

    /// 有参的构造方法
    /// 
    /// 
    public MyList(int size)
    {
        if (size >= 0)
        {
            //设置数组大小
            array = new T[size];
        }
    }
    /// 

    /// 无参的构造方法
    /// 
    public MyList()
    {
        //MyList(0);
        //或者 默认创建空的数组
        array = new T[0];
    }

    /// 

    /// 获取容量的大小
    /// 
    /// 返回容量大小（int类型）
    public int Capacity {   get{ return array.Length; }  }

    /// 

    /// 标识位，用来标识当前元素的个数
    /// 
    /// 返回当前添加的元素的个数
    public int Count {  get{ return count; }  }


    /// 

    /// 添加
    /// 
    /// 添加的元素
    public void Add(T item)
    {
        //判断元素个数和列表容量是否一样大，一样大的时候需要创建新的数组
        if (Capacity == Count)
        {
            //当数组长度为0的时候，创建一个长度是4的数组
            if (Capacity ==0)
            {
                array = new T[4];
            }
            else
            {
                //不是0的时候不用管，创建一个长度为之前的2倍的数组
                var newArray = new T[Capacity * 2];
                //把原来数组的元素复制到新的数组中
                Array.Copy(array,newArray,Count);
                //把新数组的引用给旧数组，可以把旧数组引用删除，换成新的引用。旧引用被GC机制回收
                array = newArray;
            }
        }
        //添加数据
        array[Count] = item;
        count++; //元素个数自增
    }

    /// 

    /// 访问
    /// 
    /// 索引
    /// 返回索引对应的元素
    public T Getitem(int index)
    {
        //索引范围
        if (index >= 0 && index < count)
        {
            return array[index];
        }
        else
        {
            //抛出异常
            throw new Exception("索引超出范围");
        }
    }

    /// 

    /// 索引器
    /// 
    /// 索引
    /// /返回Getitem方法（返回索引对应的元素）
    public T this[int index]
    {
        get     {       return Getitem(index);   }
        //通过索引设置数组索引元素的值
        set
        {
            //索引范围
            if (index >= 0 && index < count )
            {
                array[index] = value;
            }
            else
            {
                //抛出异常
                throw new Exception("超出索引的范围");
            }
        }
    }

    /// 

    /// 插入
    /// 
    /// 索引
    /// 元素
    public void Insert(int index, T item)
    {
        //索引范围
        if (index >= 0 && index < count)
        {
            //判断元素个数和列表容量是否一样大，一样大的时候需要创建新的数组（容量不够，就扩容）
            if (Capacity == Count)
            {
                //创建一个长度为之前的2倍的数组
                var newArray = new T[Capacity * 2];
                //把原来数组的元素复制到新的数组中
                Array.Copy(array, newArray, Count);
                //把新数组的引用给旧数组，可以把旧数组引用删除，换成新的引用。旧引用被GC机制回收
                array = newArray;
            }

            //把插入位置的元素和插入位置以后的元素向后移动一个单位，索引加 1
            for (int i = Count - 1; i >= index; i--)
            {
                array[i + 1] = array[i];//向后移动
            }
            array[index] = item;//插入
            count++;//自增数量
        }
        else
        {
            throw new Exception("超出索引范围");
        }
    }

    /// 

    /// 移除
    /// 
    /// 索引
    public void RemoveAt(int index)
    {
        if (index >= 0 && index < count)
        {
            // 插入位置以后的元素向前移动一个单位，索引加 - 1，覆盖需要移除的元素
            for (int i = index + 1; i < count; i++)
            {
                array[i - 1] = array[i];
            }
            count--;//元素个数自减
        }
        else
        {
            throw new Exception("索引超出范围");
        }
    }


    /// 

    /// 从前往后查找
    /// 
    /// 元素
    /// 返回对应索引
    public int IndexOf(T item)
    {
        for (int i = 0; i < count; i++)
        {
            //两个泛型之间用无法用双等号，用Equals（确定指定的对象是否等于当前对象）
            if (array[i].Equals(item))
            {
                return i;//找到就返回对应索引
            }
        }
        return -1;//没有返回-1
    }


    /// 

    /// 从后往前查找
    /// 
    /// 元素
    /// 返回对应索引
    public int LastIndexOf(T item)
    {
        for (int i = count - 1; i >= 0; i--)
        {
            if (array[i].Equals(item))
            {
                return i;//找到就返回对应索引
            }
        }
        return -1;//没有返回-1
    }

    /// 

    /// 从小到大排序
    /// 
    public void Sort()
    {
        //冒泡排序
        for (int j = 0; j < count - 1; j++)
        {
            for (int i = 0; i < count - 1 - j; i++)
            {
                if (array[i].CompareTo(array[i + 1]) > 0)
                {
                    var temp = array[i];
                    array[i] = array[i + 1];
                    array[i + 1] = temp;
                }
            }
        }

    }

}