我使用的编程工具是Visual studio,先创建一个项目,添加一个类,我把它命名为Hylist,然后再类名后面添加< T >改为泛型类
我要在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
没有发生错误