使用泛型来创建我们自己的列表

最新推荐文章于 2021-04-19 16:12:33 发布
最新推荐文章于 2021-04-19 16:12:33 发布
阅读量331 收藏 3
点赞数
分类专栏： C#中级篇 文章标签： 泛型 存储 列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37365407/article/details/78110279
版权

在前面我们知道在C#中有一个List类，可以存储长度不限的数据。列表是使用了泛型来创建的，那我们可以通过泛型来创建自己的一个列表，这样我们能够对泛型和列表有个更深刻的了解。

首先，我们知道列表其实就是一个数组，只不过构造的时候不需要指定长度，那么我们首先要定义一个泛型数组和其中元素个数的变量。

class MyList<T> where T:IComparable
    {
        private T[] array; //定义一个泛型数组
        private int count; //元素个数
    }

有了MyList这个类之后，我们要去定义他的构造函数，数组长度可填可不填。

        //构造有参数组
        public MyList(int size)
        {
            if (size >= 0)
            {
                array = new T[size];
            }
        }

        //构造无参数组
        public MyList()
        {
            array = new T[0];
        }

这样我们的列表就可以通过构造函数构造出来了，那么列表的基本属性是什么呢？我们要能够获取这个列表的容量大小和元素个数。因为容量大小和元素个数我们只需要获取它的数值，所以不用设置set方法。

//获取容量大小
        public int Capacity
        {
            get { return array.Length; }
        }

        //获取数组内元素个数
        public int Count
        {
            get { return count; }
        }

现在这个列表的构造函数和属性都已经写好了，那么接下来我们需要写这个列表的功能。功能如下

1.Add（）方法添加元素

//添加元素
        public void Add(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;
                }
            }
            array[Count] = item;
            count++;
        }

2.获取列表的值（为了更方便地访问列表，我们可以使用索引器访问元素）

//获取列表的值
        public T GetItem(int index)
        {
            if (index >= 0 && index <= count - 1)
            {
                return array[index];
            }
            else
            {
                throw new Exception("索引超出范围");
            }
        }

//通过索引访问元素
        public T this[int index] //从源码所获取的方法
        {
            get { return GetItem(index); }
            set
            {
                if (index >= 0 && index <= count - 1)
                {
                    array[index] = value;
                }
                else
                {
                    throw new Exception("索引超出范围");
                }
            }
        }

3.插入元素

public void Insert(int index, T item)
        {
            if (index >= 0 && index <= count - 1)
            {
                //首先判断数组是否已满
                if (Capacity == Count)
                {
                    //再判断数组是否为空
                    if (Capacity == 0)
                    {
                        array = new T[4];
                    }
                    else
                    {
                        //不为空的话数组长度增加为原来的两倍
                        var newArray = new T[Capacity * 2];
                        Array.Copy(array, newArray, count);
                        array = newArray;
                    }
                }
                else
                {
                    for (int i = count - 1; i >= index; i--)
                    {
                        array[i + 1] = array[i];
                    }
                    array[index] = item;
                    count++; //插入完之后元素个数自增
                }
            }
            else
            {
                throw new Exception("索引超出范围");
            }
        }

4.移除指定位置元素

public void RemoveAt(int index)
        {
            if (index >= 0 && index <= count - 1)
            {
                for(int i = index + 1; i <= count - 1; i++)
                {
                    array[i - 1] = array[i]; //将后一个元素的值赋值给前一个元素；
                }
                count--;
            }
            else
            {
                throw new Exception("索引超出范围");
            }
        }

5.从前往后取得元素在列表中的索引

//从前往后取得元素在列表中的索引
        public int IndexOf(T item)
        {
            for(int i = 0; i <= count - 1; i++)
            {
                //if(array[i] == item) 因为泛型不能做比较，所以使用equals方法
                if(array[i].Equals(item))
                {
                    return i;
                }
            }
            return -1;
        }

6.从后往前取得元素在列表中的索引

//从后往前取得元素在列表中的索引
        public int LastIndexOf(T item)
        {
            for(int i = count - 1; i >= 0; i--)
            {
                if (array[i].Equals(item))
                {
                    return i;
                }
            }
            return -1;
        }

7.对列表中的元素进行排序（冒泡排序）

public void Sort()
        {
            for(int i = 0; i < count - 1; i++)
            {
                for(int j = 0; j < count - 1 - i; j++) //减去一个i是不遍历已经排序过的元素，提高效率
                {
                    //if (array[i] < array[i + 1]) 因为泛型无法比较大小，所以让泛型使用Compare接口
                    if (array[j].CompareTo(array[j + 1]) > 0)
                    {
                        var temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }

在这些功能里，有些地方值得注意一下

  1. 使用泛型声明的元素，当判断是否相等的时候，不能使用”==”来判断，只能使用Equals()方法来判断是否相等。
  2. 使用泛型声明的元素，当判断两者的大小时，不能使用”>”或”<”来判断，我们需要在类名后面加上”where T:ICompareble”，给泛型继承ICompareble接口，然后使用CompareTo()方法，当比较完的值>0时，说明前面那个数比后面的数大，<0时说明前面的数比后面的数小。

下面贴出源代码

class MyList<T> where T:IComparable
    {
        private T[] array; //定义一个泛型数组
        private int count; //元素个数

        //构造有参数组
        public MyList(int size)
        {
            if (size >= 0)
            {
                array = new T[size];
            }
        }

        //构造无参数组
        public MyList()
        {
            array = new T[0];
        }

        //获取容量大小
        public int Capacity
        {
            get { return array.Length; }
        }

        //获取数组内元素个数
        public int Count
        {
            get { return count; }
        }

        //添加元素
        public void Add(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;
                }
            }
            array[Count] = item;
            count++;
        }

        //获取列表的值
        public T GetItem(int index)
        {
            if (index >= 0 && index <= count - 1)
            {
                return array[index];
            }
            else
            {
                throw new Exception("索引超出范围");
            }
        }

        //通过索引访问元素
        public T this[int index] //从源码所获取的方法
        {
            get { return GetItem(index); }
            set
            {
                if (index >= 0 && index <= count - 1)
                {
                    array[index] = value;
                }
                else
                {
                    throw new Exception("索引超出范围");
                }
            }
        }

        //插入元素
        public void Insert(int index, T item)
        {
            if (index >= 0 && index <= count - 1)
            {
                //首先判断数组是否已满
                if (Capacity == Count)
                {
                    //再判断数组是否为空
                    if (Capacity == 0)
                    {
                        array = new T[4];
                    }
                    else
                    {
                        //不为空的话数组长度增加为原来的两倍
                        var newArray = new T[Capacity * 2];
                        Array.Copy(array, newArray, count);
                        array = newArray;
                    }
                }
                else
                {
                    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 - 1; i++)
                {
                    array[i - 1] = array[i]; //将后一个元素的值赋值给前一个元素；
                }
                count--;
            }
            else
            {
                throw new Exception("索引超出范围");
            }
        }

        //从前往后取得元素在列表中的索引
        public int IndexOf(T item)
        {
            for(int i = 0; i <= count - 1; i++)
            {
                //if(array[i] == item) 因为泛型不能做比较，所以使用equals方法
                if(array[i].Equals(item))
                {
                    return i;
                }
            }
            return -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 i = 0; i < count - 1; i++)
            {
                for(int j = 0; j < count - 1 - i; j++) //减去一个i是不遍历已经排序过的元素，提高效率
                {
                    //if (array[i] < array[i + 1]) 因为泛型无法比较大小，所以让泛型使用Compare接口
                    if (array[j].CompareTo(array[j + 1]) > 0)
                    {
                        var temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }
    }

//主函数
class Program
    {
        static void Main(string[] args)
        {
            MyList<int> myList = new MyList<int>();
            myList.Add(128);
            myList.Add(27);
            myList.Add(94);
            myList.Add(18);
            myList.Add(349);
            myList.Add(83);
            myList.Add(837);
            myList.Add(250);
            myList.Add(430);
            myList.Add(678);
            myList.Insert(0, 1000);
            myList.RemoveAt(8);
            for(int i = 0; i < myList.Count; i++)
            {
                Console.Write(myList[i] + " ");
            }
            Console.WriteLine();
            Console.WriteLine(myList.IndexOf(83));
            Console.WriteLine(myList.LastIndexOf(18));
            Console.WriteLine();
            myList.Sort();
            for (int i = 0; i < myList.Count; i++)
            {
                Console.Write(myList[i] + " ");
            }
            Console.ReadKey();
        }
    }
Lymon_z
关注
专栏目录
自己实现vector不使用泛型
09-06
但如果我们不使用模板，那么我们需要为每种数据类型创建一个单独的类，这显然不是一种高效的方法。 不过，为了满足题目需求，我们可以创建一个固定类型的`Vector`类，例如只处理`int`类型的数据。`Vector`类应包含...
C#泛型类创建与使用的方法
08-30
在本篇中，我们将深入探讨如何创建和使用C#中的泛型类。 首先，让我们看看如何创建一个泛型类。在C#中，我们使用尖括号`<>`来声明泛型类，其中的`T1, T2`等是类型参数，代表未知的数据类型。以下是一个简单的泛型类...
泛型之列表的创建和使用
qq_37365407的博客
09-25 571
在前面，我们需要存储很多类型一样的数据的时候，我们一般都使用数组来存储并且管理，但是数组有个缺点就是数组的大小是固定的，那么当我们不确定数据的个数的时候，该怎么存储呢？ 我们可以使用集合类来进行存储数据，列表List就是集合类的一种。我们可以使用列表很方便的添加、删除数据以及其他的操作。列表的创建 列表可以存储任何类型的数据，在创建列表对象的时候，我们首先要指定要创建的这个对象要存储什么类型的（
【Java】泛型数组列表
Kaimar的博客
04-19 570
文章目录1、ArrayList1.1 概述1.2 创建ArrayList1.3 添加元素1.4 访问数组列表元素2、类型化与原始数组列表的兼容性3、对象包装器与自动装箱4、相关API参考 1、ArrayList 1.1 概述 许多语言，如C/C++，必须在编译时就确定整个数组的大小。Java中，允许在运行时确定数组的大小。 为解决动态修改数组的问题，在Java中，解决这个问题最简单的方法是使用一个类，名为ArrayList。类似于数组，但在添加或删除元素时，能够自动地调整数组容量。 1.2 创建Arra
ArrayList 中的泛型
deng_1987的专栏
11-12 216
上回也在javaeye看了一篇文章，讲的是ArrayList泛型，不过不是普通的add，而是通过[color=yellow]反射[/color]来加入对象。 先把代码贴出来[code="java"] public class Test01 { public static void main(String[] args) throws Exception{ ...
泛型对象列表的写法
亲测，只为展现最完美的有效！
07-11 435
ArrayList<Person>(){}.getClass()
5.3 泛型数组列表
Dreamlate_Spider的博客
07-03 129
ArraryList,使用起来有点儿像数组，但在删除和添加元素时，具有自动调节数组容量的功能。 如果调用add且内部数组已经满了，数组列表就将自动地创建一个更大的数组，并将所有的对象从较小的数组中拷贝到较大的数组中。 如果已经清楚或者估计出数组可能存储的元素数量，就可在填充数组之前调用ensureCapacity方法。 list.ensureCapacity(100); 还可以把初...
如何在Java中使用泛型来创建类型安全的集合？
最新发布
09-07
使用泛型创建类型安全的集合的基本步骤如下： 1. 定义泛型集合：在声明集合变量时，使用尖括号`<>`指定集合可以存储的对象类型。例如，创建一个只存储`String`类型对象的`ArrayList`： ```java List<String> ...
java使用泛型实现栈结构示例分享
09-04
在这个实例中，我们将探讨如何使用泛型来实现一个栈数据结构。栈是一种后进先出（LIFO）的数据结构，常见的操作有压入（push）和弹出（pop）。在Java中，虽然有内置的`java.util.Stack`类，但为了演示泛型的用法，...
（第二季） 233-创建我们自己的列表MyList
taotaoahui
04-25 432
230-操作列表的属性和方法 1,Capacity获取容量大小 2,Add()方法添加元素 3,Insert()方法插入元素 4,[index]访问元素 5,Count属性访问元素个数 6,RemoveAt()方法移除指定位置的元素 7,IndexOf()方法取得一个元素所在列表中的索引位置   LastIndexOf()上面的方法是从前往后搜索，这个是从后往前搜索，搜索到满足
java创建泛型对象数组
hello world
11-27 2432
  这样创建是对的     此时数组里的元素都是null 但是数组本身不是null 对象数组创建之后 里面的对象元素初始化为null   这样是错的  
Java 创建泛型类型的数组
热门推荐
云聪的技术错题集
05-10 1万+
1.不能像下面这样直接利用泛型变量创建数组：               T[] a = new T[]; 但可以先创建一个Object类型的数组，再强制类型转化为泛型数组：               T[] a = (T[]) new Object[length]; 这条语句是对的，因为对于没有限定的类型变量，类型擦除后用Object代替T，上面语句变为：
关于创建一个泛型数组
断盏灯轻的博客
07-27 3617
遇到一个关于创建泛型数组的问题，在网上百度了很多，给出的方法基本上都是 E[] array= (E[]) new Object[length]; 但是在我本地运行时却一直报错，下面是报错的代码，报错位置为第三行 private static &lt;E extends Comparable&lt;E&gt;&gt; void mergeSort(E[] list){ ...
2018-10-11泛型 创建自己的List类
qq_31726339的博客
10-11 327
自己写了一个list类 简单实现了 CapaciTy获取列表容量大小 Count访问元素个数 Add()添加数据 Insert()指定索引处添加数据 [index]访问元素（索引器） IndexOf()返回数据的下标 LastIndexOf()从后往前返回数据的下标 Sort()对列表中的数据进行从大到小排序 using System; using System.Collecti...
java创建泛型类_java-创建泛型类列表
weixin_30564897的博客
02-12 803
我有一个实用程序方法,可以从某些对象中创建一个元素列表：public static final List list(T t) {final List rv = new ArrayList<>();rv.add(t);return rv;}我也有一个接受类型为List< Class>的参数的方法.因此,我必须创建该类型的对象.这是我尝试做的事情：final Class&gt...
where（泛型类型约束）
adsfa23124的博客
01-06 302
定义：在定义泛型的时候，我们可以使用where 限制参数的范围。 使用：在使用泛型的时候，你必须尊守 where限制参数的范围，否则编译不会通过。 六种类型的约束： T：类（类型参数必须是引用类型；这一点也适用于任何类、接口、委托或数组类型。） class MyClass<T, U> where T : class///约束T参...
C# 使用泛型和索引器来实现一个集合类列表MyList
cuijiahao的专栏
02-09 725
有下面的方法和属性 1、Capacity获取容量大小 2、Add()方法添加元素 3、Insert()方法插入元素 4、[index]访问元素(索引器) 5、Count属性访问元素个数 6、RemoveAt()方法移除指定位置的元素 7、IndexOf()方法取得一个元素所在列表中的索引位置 LastIndexOf()上面的方法是从前往后搜索，这个是从后往前搜索，搜索到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值