C# 自定义List

已于 2023-07-28 11:40:43 修改
阅读量9.2k 收藏 37
点赞数 10
分类专栏： C# 文章标签： c#
于 2022-08-10 15:12:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38693757/article/details/126263502
版权

目录

一、需求

二、List 常用功能

三、自定义List

四、测试

1.Add

2.Clear

3.Contains

4.IndexOf

5.Insert

6.Remove

7.RemoveAt

结束

一、需求

微软官方的 List 在命名空间 System.Collections.Generic 中，在平时的开发中 List 用的特别多，在用的时候我们基本不会考虑在 List 中内部是怎么写的，于是，我也写了一个List，想看看是否能实现和微软官方一样的功能，当然，不是说为了和微软比比谁写的好，也没那个必要，原创轮子等于白费功夫，微软的API基本已经优化的很好了，直接拿来用就行了，我写这篇文章目的只是为了更了解 List 内部的构造，提升自己 C# 基础，功能当然不可能有官方那么多。

二、List 常用功能

Capacity

        用于获取或设置List可容纳元素的数量。当数量超过容量时，这个值会自动增长。您可以设置这个值以减少容量，也可以调用trin()方法来减少容量以适合实际的元素数目。

Count

        获取List中当前元素数量

Item

        通过指定索引获取或设置元素。对于List类来说，它是一个索引器。

Add 

        在List中添加一个对象

AddRange

        在List尾部添加实现了ICollection接口的多个元素

BinarySearch 

        用于在排序的List内使用二分查找来定位指定元素.

Clear

        移除List所有元素

Contains

        测试一个元素是否在List内

CopyTo

        把一个List拷贝到一维数组内

Exists

        测试一个元素是否在List内

Find 

        查找并返回List内的出现的第一个匹配元素

FindAll

        查找并返回List内的所有匹配元素

GetEnumerator

        返回一个用于迭代List的枚举器

Getrange

        拷贝指定范围的元素到新的List内

IndexOf

        查找并返回每一个匹配元素的索引

Insert

        在List内插入一个元素

InsertRange

        在List内插入一组元素

LastIndexOf

        查找并返回最后一个匹配元素的索引

Remove

        移除与指定元素匹配的第一个元素

RemoveAt

        移除指定索引的元素

RemoveRange

        移除指定范围的元素

Reverse

        反转List内元素的顺序

Sort 

        对List内的元素进行排序

ToArray

        把List内的元素拷贝到一个新的数组内

三、自定义List

自定义 List 如下，我将常用的功能封装了一下

public class TList<T>
{
    private const int _defaultCapacity = 4;
    private static readonly T[] _emptyArray;
    private T[] _items;
    private int _size;
    private int _version;

    public int Capacity
    {
        get => this._items.Length;
        set
        {
            if (value < this._size)
            {
                throw new ArgumentOutOfRangeException("容量太小");
            }
            if (value != this._items.Length)
            {
                if (value > 0)
                {
                    T[] destinationArray = new T[value];
                    if (this._size > 0)
                    {
                        Array.Copy(this._items, 0, destinationArray, 0, this._size);
                    }
                    this._items = destinationArray;
                }
                else
                {
                    this._items = _emptyArray;
                }
            }
        }
    }
    
    public int Count => this._size;

    public T this[int index]
    {
        get
        {
            if (index >= this._size)
            {
                throw new ArgumentOutOfRangeException("index不能大于等于数组的长度");
            }
            return this._items[index];
        }
        set
        {
            if (index >= this._size)
            {
                throw new ArgumentOutOfRangeException("index不能大于等于数组的长度");
            }
            this._items[index] = value;
            this._version++;
        }
    }

    /// <summary>
    /// 添加对象到 List 中
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    public int Add(object value)
    {
        if (this._size == this._items.Length)
        {
            this.EnsureCapacity(this._size + 1);
        }
        int index = this._size;
        this._size = index + 1;
        this._items[index] = (T)value;
        this._version++;
        return _size;
    }

    /// <summary>
    /// 从 List 中移除所有项
    /// </summary>
    public void Clear()
    {
        if (this._size > 0)
        {
            Array.Clear(this._items, 0, this._size);
            this._size = 0;
        }
        this._version++;
    }

    /// <summary>
    /// List 中是否包含指定的值
    /// </summary>
    /// <param name="item"></param>
    /// <returns></returns>
    public bool Contains(object item)
    {
        if (item == null)
        {
            for (int j = 0; j < this._size; j++)
            {
                if (this._items[j] == null)
                {
                    return true;
                }
            }
            return false;
        }
        for (int i = 0; i < this._size; i++)
        {
            if (_items[i].Equals(item))
            {
                return true;
            }
        }
        return false;
    }

    /// <summary>
    /// 拷贝数组到 List 中指定的位置
    /// </summary>
    /// <param name="array"></param>
    /// <param name="arrayIndex"></param>
    public void CopyTo(T[] array, int arrayIndex)
    {
        Array.Copy(this._items, 0, array, arrayIndex, this._size);
    }

    /// <summary>
    /// 获取 List 中特定项的索引
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    public int IndexOf(object value)
    {
        return Array.IndexOf<T>(this._items, (T)value, 0, this._size);
    }

    /// <summary>
    /// 从 List 中的指定索引处插入一个值
    /// </summary>
    /// <param name="index"></param>
    /// <param name="value"></param>
    public void Insert(int index, object value)
    {
        if (index > this._size)
        {
            throw new ArgumentOutOfRangeException("index不能大于数组长度");
        }
        if (this._size == this._items.Length)
        {
            this.EnsureCapacity(this._size + 1);
        }
        if (index < this._size)
        {
            Array.Copy(this._items, index, this._items, index + 1, this._size - index);
        }
        this._items[index] = (T)value;
        this._size++;
        this._version++;
    }

    /// <summary>
    /// 从 List 中移除特定对象的第一个匹配项
    /// </summary>
    /// <param name="item"></param>
    /// <returns></returns>
    public bool Remove(T item)
    {
        int index = this.IndexOf(item);
        if (index >= 0)
        {
            this.RemoveAt(index);
            return true;
        }
        return false;
    }

    /// <summary>
    /// 移除位于指定索引处的 List 项。
    /// </summary>
    /// <param name="index"></param>
    public void RemoveAt(int index)
    {
        if (index >= this._size)
        {
            throw new ArgumentOutOfRangeException("index不能大于等于数组的长度");
        }
        this._size--;
        if (index < this._size)
        {
            Array.Copy(this._items, index + 1, this._items, index, this._size - index);
        }
        this._items[this._size] = default(T);
        this._version++;
    }

    private void EnsureCapacity(int min)
    {
        if (this._items.Length < min)
        {
            int num = (this._items.Length == 0) ? 4 : (this._items.Length * 2);
            if (num > 0x7fefffff)
            {
                num = 0x7fefffff;
            }
            if (num < min)
            {
                num = min;
            }
            this.Capacity = num;
        }
    }

    static TList()
    {
        _emptyArray = new T[0];
    }

    public TList()
    {
        this._items = _emptyArray;
    }

    public TList(int capacity)
    {
        if (capacity < 0)
        {
            throw new ArgumentOutOfRangeException("List长度不能小于0");
        }
        if (capacity == 0)
        {
            this._items = _emptyArray;
        }
        else
        {
            this._items = new T[capacity];
        }
    }
}

  

四、测试

1.Add

功能：向 List 内添加对象

namespace 计算1
{
    class Program
    {
        static void Main(string[] args)
        {
            TList<int> list = new TList<int>();
            list.Add(15);
            list.Add(62);
            list.Add(23);
            Console.WriteLine("长度：" + list.Count);
            Console.ReadKey();
        }
    }
}

输出

2.Clear

功能：清除 List 内所有的对象

namespace 计算1
{
    class Program
    {
        static void Main(string[] args)
        {
            TList<int> list = new TList<int>();
            list.Add(15);
            list.Add(62);
            list.Add(23);
            Console.WriteLine("长度：" + list.Count);
            list.Clear();
            Console.WriteLine("长度：" + list.Count);

            Console.ReadKey();
        }
    }
}

输出

3.Contains

功能：LIst 是否包含指定的值

namespace 计算1
{
    class Program
    {
        static void Main(string[] args)
        {
            TList<int> list = new TList<int>();
            list.Add(15);
            list.Add(62);
            list.Add(23);

            bool res = list.Contains(15);
            Console.WriteLine("是否包含：" + res);

            Console.ReadKey();
        }
    }
}

输出

4.IndexOf

功能：获取 List 中特定项的索引

namespace 计算1
{
    class Program
    {
        static void Main(string[] args)
        {
            TList<int> list = new TList<int>();
            list.Add(15);
            list.Add(62);
            list.Add(23);

            int index = list.IndexOf(23);
            Console.WriteLine("对应索引：" + index);

            Console.ReadKey();
        }
    }
}

输出

5.Insert

功能：从 List 中的指定索引处插入一个值

namespace 计算1
{
    class Program
    {
        static void Main(string[] args)
        {
            TList<int> list = new TList<int>();
            list.Add(15);
            list.Add(62);
            list.Add(23);
            //Console.WriteLine("长度：" + list.Count);

            list.Insert(1, 45);

            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }

            Console.ReadKey();
        }
    }
}

输出

6.Remove

功能：从 List 中移除特定对象的一个匹配项

namespace 计算1
{
    class Program
    {
        static void Main(string[] args)
        {
            TList<int> list = new TList<int>();
            list.Add(15);
            list.Add(62);
            list.Add(23);
            list.Add(45);

            bool res = list.Remove(23);
            Console.WriteLine("移除结果：" + res);

            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }

            Console.ReadKey();
        }
    }
}

输出

7.RemoveAt

功能：移除位于指定索引处的 List 项

namespace 计算1
{
    class Program
    {
        static void Main(string[] args)
        {
            TList<int> list = new TList<int>();
            list.Add(15);
            list.Add(62);
            list.Add(23);
            list.Add(45);

            list.RemoveAt(2);

            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }

            Console.ReadKey();
        }
    }
}

输出

结束

如果这个帖子对你有用，欢迎 关注 + 点赞 + 留言，谢谢

end

熊思宇
关注
  • 10
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C#数据结构——List
IncompleteEncy的博客
08-01 982
类的泛型版本,相较于自由的ArrayList，List需要在定义时提前指定其内部元素的数据类型，但相对的，List相较于ArrayList在使用其内部元素时也不需要进行装箱、拆箱等操作，在存储元素为值类型的情况下List会有更为优秀的性能表现。这个构造函数事实上是用于指定List生成后的容量，即List.Capacity，在已知元素大致数量的情况下，使用该构造函数可以减少List的扩容，从而减少性能损耗。与ArrayList相同，当使用List.Add()向List当中置入数据时，若List空间不足，则。
Unity学习（C#）——列表List的创建和使用
weixin_45045387的博客
06-18 1万+
集合类：数组的大小是固定的，有时候不方便，需要使用集合来管理，列表是集合类的一组，且可以方便的添加和删除数据。 创建和访问、插入数据。 static void Main(string[] args) { List<int> scoreList = new List<int>(); var scoreList1 = new List<int>(); var scoreList2 = n
C# list集合
最新发布
m0_47020592的博客
05-30 515
C# list集合使用
C# List介绍及具体用法
12-23
一、# List泛型集合 集合是OOP中的一个重要概念，C#中对集合的全面支持更是该语言的精华之一。 为什么要用泛型集合？ 在C# 2.0之前，主要可以通过两种方式实现集合： a.使用ArrayList 直接将对象放入ArrayList，操作直观，但由于集合中的项是Object类型，因此每次使用都必须进行繁琐的类型转换。 b.使用自定义集合类 比较常见的做法是从CollectionBase抽象类继承一个自定义类，通过对IList对象进行封装实现强类型集合。这种方式要求为每种集合类型写一个相应的自定义类，工作量较大。泛型集合的出现较好的解决了上述问题，只需一行代码便能创建指定类型的集合。 什么是
C# List使用详解
sunyao1314的博客
03-08 6538
在 C# 中，List 和数组都是用于存储一组元素的数据结构，但它们之间有一些关键的区别和各自的优缺点。
C# List用法 List介绍
深海地平线的博客
07-31 9465
一、List泛型集合 　　集合是OOP中的一个重要概念，C#中对集合的全面支持更是该语言的精华之一。 　　　　为什么要用泛型集合？ 　　　　在C# 2.0之前，主要可以通过两种方式实现集合： 　　　　a.使用ArrayList 　　　　直接将对象放入ArrayList，操作直观，但由于集合中的项是Object类型，因此每次使用都必须进行繁琐的类型转换。 　　　　b.使用自定义集合类 　　　　比较常见的做法是从CollectionBase抽象类继承一个自定义类，通过对IList对象进行封装实现强
C# List 的一般用法
Peter的博客
07-21 2万+
List泛型集合是C#编程中的经常使用的集合之一，相对数组它可以动态的添加元素而不是声明的时候就必须指定大小。相对于ArrayList集合和Hashtable集合的优势是其元素的数据类型可以确定。而不是默认的父类类型object。 List泛型集合的声明与元素添加 1.List泛型集合的声明： List<数据类型> 变量名=new list<数据类型>(); 2.List泛型集合的声明案例： //声明一个List泛型集合的变量listNew List<strin..
C#自定义List类
myesn的博客
06-21 1776
代码如下： using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MyArrayList { public class MyArrayList { //容量 private const int _def
C#实现List
派大星PatrickStar的博客
11-01 735
前言使用泛型和索引器来自己实现一个集合类MyList，我们主要实现功能如下：1.Capacity获取容量大小2.Add()方法添加元素3.Insert()方法插入元素4.[index]访问元素(索引器)5.Count属性访问元素个数6.RemoveAt()方法移除指定位置的元素7.IndexOf()方法取得一个元素所在列表中的索引位置LastIndexOf()上面的方法是从前往后搜索，这个是从后往前
C#使用IComparer自定义List类实现排序的方法
09-03
本篇将详细介绍如何在C#中使用IComparer自定义List类实现排序。 首先，我们来看一个例子，假设我们有一个`Person`类，包含`Name`（姓名）和`Age`（年龄）属性。对于这样的自定义类型，系统默认的比较方式可能无法...
C# 传入自定义列表List 到Oracle存储过程
09-11
本文将详细讲解如何在C#中使用自定义列表(List)作为参数调用Oracle存储过程，以及实现这一功能的关键技术和注意事项。 首先，我们需要了解Oracle数据库中的PL/SQL类型，例如VARCAR2、NUMBER等，它们对应于C#中的...
c# 自定义特性demo
06-29
本示例“c# 自定义特性demo”将引导我们深入了解如何在C#中定义和使用自定义特性。 首先，让我们了解一下如何定义自定义特性。在C#中，自定义特性是通过继承`System.Attribute`基类来创建的。例如，我们可以创建一...
C# 自定义纵向打印（报表打印）
05-17
综上所述，C#自定义纵向打印涉及到数据处理、页面布局设计、图形绘制、打印控制等多个层面的技术。理解并掌握这些知识点，开发者可以创建出满足各种需求的报表打印应用。在实践中，不断优化代码性能，提高用户体验，...
c#自定义泛型类的实现
09-05
以下是对C#自定义泛型类实现的详细解析。 首先，我们需要理解泛型的基本概念。泛型类定义了一个或多个类型参数，这些参数在类实例化时会被具体的类型替换。类型参数通常以大写字母T开头，如`T`、`U`等。例如，在...
C# winForm自定义控件多选框
09-12
C# 中WinForm 自定义 多选框， 不过改自定义控件的性能不太好，欢迎大家多多协助改进。 软件架构 使用微软最新dotNet6 框架开发，里面的自定定义控件理论上能在net 所有winform 系列中通用 使用说明 初始化选中...
C#集合篇之--列表List＜T＞
白衣胜雪
06-28 4854
列表 .NET Framework 为动态列表提供了泛型类List<T> 这个类实现了 Llist、ICollection、IEnumerable、IList<T> 、ICollection<T>和IEnumerable<T> 接口。 1、创建列表 调用默认的构造函数就可以创建列表对象：var int intList=new List<int>(); 这是一个int 类型的List 泛型类。 使用默认的构造函数创建一个空列表。当我们将元素添加到列表
List属性和方法
03-05 1603
1.在添加对象前,必须要创建新对象 2.List属性和方法Count 属性，用于获取数组中当前元素数量Item( ) 通过指定索引获取或设置元素。对于List类来说，它是一个索引器。Add( ) 在List中添加一个对象的公有方法AddRange( ) 公有方法，在List尾部添加实现了ICollection接口的多个元素BinarySearch( ) 重载的公有方法，
C#中列表List的创建与使用
热门推荐
不积跬步无以至千里
04-15 6万+
集合类 列表List 当我们有很多类型一样的数据时，可以使用数组来进行存储并管理，但是这样的缺点是数组的大小是提前给定的、是固定的。 如果我们有许多类型一样但数量不定的数据，我们可以使用集合类来进行管理——例如列表List。我们可以使用列表List很方便的添加数据，删除数据以及其他的一些数据操作。 创建方法1： List&lt;int&gt; scoreList = new List&...
c# list 自定义类型 contains
05-11
如果你想在C#的List中查找是否包含某个自定义类型的对象，可以考虑实现该自定义类型的相等比较方法（Equals方法和GetHashCode方法），并在List的Contains方法中使用该方法进行比较。 下面是一个示例代码： ```csharp public class Person { public string Name { get; set; } public int Age { get; set; } public override bool Equals(object obj) { if (obj == null || GetType() != obj.GetType()) { return false; } Person p = (Person)obj; return Name == p.Name && Age == p.Age; } public override int GetHashCode() { return (Name + Age.ToString()).GetHashCode(); } } List<Person> people = new List<Person> { new Person {Name = "Alice", Age = 25}, new Person {Name = "Bob", Age = 30} }; bool containsAlice = people.Contains(new Person {Name = "Alice", Age = 25}); ``` 在上面的代码中，我们创建了一个Person类，并在该类中实现了Equals方法和GetHashCode方法。然后我们创建了一个List<Person>对象，并在其中添加了两个Person对象。最后，我们使用List的Contains方法查找是否包含一个名为"Alice"，年龄为25岁的Person对象，并将结果存储在containsAlice变量中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

熊思宇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值