我使用的编程工具是Visual studio,先创建一个项目,添加一个类,我把它命名为Hylist,然后再类名后面添加< T >改为泛型类

list 一次索引多个变量_ci

我要在Hylist类里实现的有下面的方法和属性

1,Capacity获取容量大小 
 2,Add()方法添加元素 
 3,Insert()方法插入元素 
 4,[index]访问元素(索引器) 
 5,Count属性访问元素个数 
 6,RemoveAt()方法移除指定位置的元素 
 7,IndexOf()方法取得一个元素所在列表中的索引位置 
 LastIndexOf()上面的方法是从前往后搜索,这个是从后往前搜索,搜索到满足条件的就停止 
 上面的两个方法,如果没有找到指定元素就返回-1 
 8,Sort()对列表中是元素进行从小到大排序


代码如下

class HyList<T> where T:IComparable
    {
        private T[] array; //创建一个数组
        private int capacity=0;//创建一个capacity参数,用来得到列表容量
        private int count=0;//创建一个count参数,用来得到列表元素个数
        public HyList()//构造方法,空形参时创建一个长度为0的数组
        {
            array = new T[0];
        }

        public HyList(int size)//构造方法,有形参时创建一个长度为4的数组
        {
             array = new T[size];
        }

        public int Capacity//设置列表容量属性
        {
            get
            {
                capacity = array.Length;
                return capacity;//把数组的长度返回为列表的容量
            }
        }

        public int Count//设置元素个数属性
        {
            get
            {
                return count;//返回参数count为Count
            }
        }

        public void Add(T item)//设置Add方法,形参为泛型
        {
            if (Capacity == Count)//当列表容量和元素相同时
            {
                if (Capacity == 0)//列表容量为0时,创建一个长度为4的数组
                {
                    array = new T[4];
                }
                else//其他情况
                {
                    var newAarray = new T[Capacity * 2];//创建一个新的数组,容量为capacity的两倍
                    Array.Copy(array, newAarray, Count);//把array数组的元素复制到新数组中
                    array = newAarray;//再把新数组的数据赋值给array,达成扩容的效果
                }            
            }
            array[Count] = item;
            count++;//添加的一个元素,所以元素个数的参数count需要自增
        }

        public T Getitem(int index)//设置类型为T的获取列表元素方法,索引形参为int类型
        {
            if (index >= 0 && index <= Count - 1)//索引不得小于0和大于Count-1
            {
                return array[index];//返回数组array[index]的参数
            }
            else
            {
                throw new Exception("超出索引范围");
            }
        }

        public T this[int index]//设置索引的方法,this表示当前对象
        {
            get
            {
                return Getitem(index);//返回Getitem方法,因为Getitem方法就是返回数组索引的元素
            }

            set
            {
                if (index >= 0 && index <= Count - 1)
                {
                    array[index] = value;//设置数组索引元素的值
                }
                else
                {
                    throw new Exception("超出索引的范围");
                }
            }
        }


        public void Insert(int index,T item)//设置插入元素方法,第一个形参为索引值,第二个形参为元素
        {
            //{此段方法含义同上
            if (Capacity == Count)
            {
                if (Capacity == 0)
                {
                    array = new T[4];
                }
                else
                {
                    var newArray = new T[Capacity * 2];
                    Array.Copy(array, newArray, Count);
                    array = newArray;
                }
            }
            //此段方法含义同上}
            if (index >= 0 && index <= Count)
            {
                for(int i = Count-1; i>=index; i--)//从最后一个元素开始遍历,移动到i+1的位置,如果从前往后会覆盖后一个的数据
                {
                    array[i + 1] = array[i];
                }
                array[index] = item;
                count++;//插入了一个元素,所以元素个数的参数count需要自增
            }
            else
            {
                throw new Exception("超出索引范围");
            }
        }

        public void RemoveAt(int index)//设置移除的方法,形参为索引值
        {
            if (index >= 0 && index < Count)
            {
                for(int i = index + 1; i < Count; i++)//从index+1开始,元素往前位移一个位置,index所在的索引元素被覆盖,达到移除效果
                {
                    array[i - 1] = array[i];
                }
                count--;//覆盖了一个元素,,所以元素个数的参数count需要自减
            }         
            else
            {
                throw new Exception("索引超出范围");
            }
        }

         public int IndexOf(T item)//寻找元素所在的索引位置方法,从前往后
        {
            for(int i = 0; i < Count; i++)//遍历array[i],
            {
                if (array[i].Equals(item))//两个泛型之间用无法用==号,用Equals来进行指定相等
                {
                    return i;//当输入的实参item等于array[i]时返回i
                }
            }
            return -1;//当输入的实参item不等于array[i]时返回-1
        }

        public int LastIndexOf(T item)//寻找元素所在的索引位置方法,从后往前,逻辑同上
        {
            for (int i =Count-1; i >=0; i--)//从索引的最后一位往前遍历
            {
                if (array[i].Equals(item))
                {
                    return i;
                }
            }
            return -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)//CompareTo是指定对象进行比较的一个方法,运用前需要在类名后添加where T:IComparable接口
                    {
                        var temp = array[i];
                        array[i] = array[i + 1];
                        array[i + 1] = temp;
                    }
                }
            }

        }
    }
}

写完上面的功能后就可以在Main方法里进行实现了

class Program
    {
        static void Main(string[] args)
        {
            HyList<int> hy = new HyList<int>();//新建一个列表对象
            hy.Add(55);//添加元素55
            hy.Add(85);//添加元素85
            hy.Add(64);//添加元素64
            hy.Insert(1, 66);//在索引1插入元素66
            hy.RemoveAt(2);//移除索引为2的元素
            hy.IndexOf(85);//从前往后查找元素85的索引位置
            hy.LastIndexOf(66); //从后往前查找元素66的索引位置
            hy.Sort();//对列表的元素进行排列
            Console.WriteLine("Capacity:"+hy.Capacity);//输出列表的容量
            Console.WriteLine("Count:"+hy.Count);//输出元素的个数
            Console.WriteLine(hy.IndexOf(85));//输出从前往后查找元素85的索引位置
            Console.WriteLine(hy.LastIndexOf(66)); //输出从后往前查找元素66的索引位置
            for (int i = 0; i < hy.Count; i++)//遍历列表,输出列表的所有元素
            {
                Console.WriteLine(hy[i]);//hy[i]为索引器
            }
            Console.ReadKey();


        }
    }
}

运行的结果如下

Capacity:4 
 Count:3 
 -1 
 2 
 55 
 64 
 66

没有发生错误