• C# 自定义List

    目录

    一、需求

    二、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 如下，我将常用的功能封装了一下

    1. public class TList<T>
    2. {
    3.     private const int _defaultCapacity = 4;
    4.     private static readonly T[] _emptyArray;
    5.     private T[] _items;
    6.     private int _size;
    7.     private int _version;
    8.  
    9.     public int Capacity
    10.     {
    11.         get => this._items.Length;
    12.         set
    13.         {
    14.             if (value < this._size)
    15.             {
    16.                 throw new ArgumentOutOfRangeException("容量太小");
    17.             }
    18.             if (value != this._items.Length)
    19.             {
    20.                 if (value > 0)
    21.                 {
    22.                     T[] destinationArray = new T[value];
    23.                     if (this._size > 0)
    24.                     {
    25.                         Array.Copy(this._items, 0, destinationArray, 0, this._size);
    26.                     }
    27.                     this._items = destinationArray;
    28.                 }
    29.                 else
    30.                 {
    31.                     this._items = _emptyArray;
    32.                 }
    33.             }
    34.         }
    35.     }
    36.     
    37.     public int Count => this._size;
    38.  
    39.     public T this[int index]
    40.     {
    41.         get
    42.         {
    43.             if (index >= this._size)
    44.             {
    45.                 throw new ArgumentOutOfRangeException("index不能大于等于数组的长度");
    46.             }
    47.             return this._items[index];
    48.         }
    49.         set
    50.         {
    51.             if (index >= this._size)
    52.             {
    53.                 throw new ArgumentOutOfRangeException("index不能大于等于数组的长度");
    54.             }
    55.             this._items[index] = value;
    56.             this._version++;
    57.         }
    58.     }
    59.  
    60.     /// 
    61.     /// 添加对象到 List 中
    62.     /// 
    63.     /// 
    64.     /// 
    65.     public int Add(object value)
    66.     {
    67.         if (this._size == this._items.Length)
    68.         {
    69.             this.EnsureCapacity(this._size + 1);
    70.         }
    71.         int index = this._size;
    72.         this._size = index + 1;
    73.         this._items[index] = (T)value;
    74.         this._version++;
    75.         return _size;
    76.     }
    77.  
    78.     /// 
    79.     /// 从 List 中移除所有项
    80.     /// 
    81.     public void Clear()
    82.     {
    83.         if (this._size > 0)
    84.         {
    85.             Array.Clear(this._items, 0, this._size);
    86.             this._size = 0;
    87.         }
    88.         this._version++;
    89.     }
    90.  
    91.     /// 
    92.     /// List 中是否包含指定的值
    93.     /// 
    94.     /// 
    95.     /// 
    96.     public bool Contains(object item)
    97.     {
    98.         if (item == null)
    99.         {
    100.             for (int j = 0; j < this._size; j++)
    101.             {
    102.                 if (this._items[j] == null)
    103.                 {
    104.                     return true;
    105.                 }
    106.             }
    107.             return false;
    108.         }
    109.         for (int i = 0; i < this._size; i++)
    110.         {
    111.             if (_items[i].Equals(item))
    112.             {
    113.                 return true;
    114.             }
    115.         }
    116.         return false;
    117.     }
    118.  
    119.     /// 
    120.     /// 拷贝数组到 List 中指定的位置
    121.     /// 
    122.     /// 
    123.     /// 
    124.     public void CopyTo(T[] array, int arrayIndex)
    125.     {
    126.         Array.Copy(this._items, 0, array, arrayIndex, this._size);
    127.     }
    128.  
    129.     /// 
    130.     /// 获取 List 中特定项的索引
    131.     /// 
    132.     /// 
    133.     /// 
    134.     public int IndexOf(object value)
    135.     {
    136.         return Array.IndexOf(this._items, (T)value, 0, this._size);
    137.     }
    138.  
    139.     /// 
    140.     /// 从 List 中的指定索引处插入一个值
    141.     /// 
    142.     /// 
    143.     /// 
    144.     public void Insert(int index, object value)
    145.     {
    146.         if (index > this._size)
    147.         {
    148.             throw new ArgumentOutOfRangeException("index不能大于数组长度");
    149.         }
    150.         if (this._size == this._items.Length)
    151.         {
    152.             this.EnsureCapacity(this._size + 1);
    153.         }
    154.         if (index < this._size)
    155.         {
    156.             Array.Copy(this._items, index, this._items, index + 1, this._size - index);
    157.         }
    158.         this._items[index] = (T)value;
    159.         this._size++;
    160.         this._version++;
    161.     }
    162.  
    163.     /// 
    164.     /// 从 List 中移除特定对象的第一个匹配项
    165.     /// 
    166.     /// 
    167.     /// 
    168.     public bool Remove(T item)
    169.     {
    170.         int index = this.IndexOf(item);
    171.         if (index >= 0)
    172.         {
    173.             this.RemoveAt(index);
    174.             return true;
    175.         }
    176.         return false;
    177.     }
    178.  
    179.     /// 
    180.     /// 移除位于指定索引处的 List 项。
    181.     /// 
    182.     /// 
    183.     public void RemoveAt(int index)
    184.     {
    185.         if (index >= this._size)
    186.         {
    187.             throw new ArgumentOutOfRangeException("index不能大于等于数组的长度");
    188.         }
    189.         this._size--;
    190.         if (index < this._size)
    191.         {
    192.             Array.Copy(this._items, index + 1, this._items, index, this._size - index);
    193.         }
    194.         this._items[this._size] = default(T);
    195.         this._version++;
    196.     }
    197.  
    198.     private void EnsureCapacity(int min)
    199.     {
    200.         if (this._items.Length < min)
    201.         {
    202.             int num = (this._items.Length == 0) ? 4 : (this._items.Length * 2);
    203.             if (num > 0x7fefffff)
    204.             {
    205.                 num = 0x7fefffff;
    206.             }
    207.             if (num < min)
    208.             {
    209.                 num = min;
    210.             }
    211.             this.Capacity = num;
    212.         }
    213.     }
    214.  
    215.     static TList()
    216.     {
    217.         _emptyArray = new T[0];
    218.     }
    219.  
    220.     public TList()
    221.     {
    222.         this._items = _emptyArray;
    223.     }
    224.  
    225.     public TList(int capacity)
    226.     {
    227.         if (capacity < 0)
    228.         {
    229.             throw new ArgumentOutOfRangeException("List长度不能小于0");
    230.         }
    231.         if (capacity == 0)
    232.         {
    233.             this._items = _emptyArray;
    234.         }
    235.         else
    236.         {
    237.             this._items = new T[capacity];
    238.         }
    239.     }
    240. }

      

    四、测试

    1.Add

    功能：向 List 内添加对象

    1. namespace 计算1
    2. {
    3.     class Program
    4.     {
    5.         static void Main(string[] args)
    6.         {
    7.             TList<int> list = new TList<int>();
    8.             list.Add(15);
    9.             list.Add(62);
    10.             list.Add(23);
    11.             Console.WriteLine("长度：" + list.Count);
    12.             Console.ReadKey();
    13.         }
    14.     }
    15. }

    输出

    2.Clear

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

    1. namespace 计算1
    2. {
    3.     class Program
    4.     {
    5.         static void Main(string[] args)
    6.         {
    7.             TList<int> list = new TList<int>();
    8.             list.Add(15);
    9.             list.Add(62);
    10.             list.Add(23);
    11.             Console.WriteLine("长度：" + list.Count);
    12.             list.Clear();
    13.             Console.WriteLine("长度：" + list.Count);
    14.  
    15.             Console.ReadKey();
    16.         }
    17.     }
    18. }

    输出

    3.Contains

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

    1. namespace 计算1
    2. {
    3.     class Program
    4.     {
    5.         static void Main(string[] args)
    6.         {
    7.             TList<int> list = new TList<int>();
    8.             list.Add(15);
    9.             list.Add(62);
    10.             list.Add(23);
    11.  
    12.             bool res = list.Contains(15);
    13.             Console.WriteLine("是否包含：" + res);
    14.  
    15.             Console.ReadKey();
    16.         }
    17.     }
    18. }

    输出

    4.IndexOf

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

    1. namespace 计算1
    2. {
    3.     class Program
    4.     {
    5.         static void Main(string[] args)
    6.         {
    7.             TList<int> list = new TList<int>();
    8.             list.Add(15);
    9.             list.Add(62);
    10.             list.Add(23);
    11.  
    12.             int index = list.IndexOf(23);
    13.             Console.WriteLine("对应索引：" + index);
    14.  
    15.             Console.ReadKey();
    16.         }
    17.     }
    18. }

    输出

    5.Insert

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

    1. namespace 计算1
    2. {
    3.     class Program
    4.     {
    5.         static void Main(string[] args)
    6.         {
    7.             TList<int> list = new TList<int>();
    8.             list.Add(15);
    9.             list.Add(62);
    10.             list.Add(23);
    11.             //Console.WriteLine("长度：" + list.Count);
    12.  
    13.             list.Insert(1, 45);
    14.  
    15.             for (int i = 0; i < list.Count; i++)
    16.             {
    17.                 Console.WriteLine(list[i]);
    18.             }
    19.  
    20.             Console.ReadKey();
    21.         }
    22.     }
    23. }

    输出

    6.Remove

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

    1. namespace 计算1
    2. {
    3.     class Program
    4.     {
    5.         static void Main(string[] args)
    6.         {
    7.             TList<int> list = new TList<int>();
    8.             list.Add(15);
    9.             list.Add(62);
    10.             list.Add(23);
    11.             list.Add(45);
    12.  
    13.             bool res = list.Remove(23);
    14.             Console.WriteLine("移除结果：" + res);
    15.  
    16.             for (int i = 0; i < list.Count; i++)
    17.             {
    18.                 Console.WriteLine(list[i]);
    19.             }
    20.  
    21.             Console.ReadKey();
    22.         }
    23.     }
    24. }

    输出

    7.RemoveAt

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

    1. namespace 计算1
    2. {
    3.     class Program
    4.     {
    5.         static void Main(string[] args)
    6.         {
    7.             TList<int> list = new TList<int>();
    8.             list.Add(15);
    9.             list.Add(62);
    10.             list.Add(23);
    11.             list.Add(45);
    12.  
    13.             list.RemoveAt(2);
    14.  
    15.             for (int i = 0; i < list.Count; i++)
    16.             {
    17.                 Console.WriteLine(list[i]);
    18.             }
    19.  
    20.             Console.ReadKey();
    21.         }
    22.     }
    23. }

    输出

    结束

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

    end

  • 相关阅读:
    【后端的讲解】
    HTML 绝对定位
    【flask扩展】使用Flask-Mail发送邮件
    栈和队列相关的一些问题
    《软件方法》2023版第1章（09）基本共识上的沟通，SysML
    【重识云原生】第六章容器6.1.12节——Docker网络模型设计
    Unity C# 网络学习（八）——WWW
    springboot建筑造价师资格考试应试网站设计与实现毕业设计源码260839
    SQL server中merge语句添加where条件
    Grid 布局
  • 原文地址：https://blog.csdn.net/qq_38693757/article/details/126263502