C#基礎知識整理 基礎知識（17）ILiest介面－泛型
對於ArrayList中如果插入值類型會引發裝箱操作，而取出值類型又需要拆箱，如下
ArrayList myArrayList = new ArrayList();
myArrayList.Add(40);//装箱
myArrayList.Add(80);//装箱
Int32 a1 = (Int32)myArrayList[0];//拆箱
Int32 a2 = (Int32)myArrayList[1];//拆箱登入後複製
從而造成性能的消耗。至於裝箱的詳細解說請見下一篇。
為了解決這些問題，C#中有支援泛型的IList
/// <summary>
/// 泛型集合类
/// </summary>
/// <typeparam name="T"></typeparam>
public class List<T> : IList<T>, IList
{
/// <summary>
/// 泛型迭代器
/// </summary>
/// <typeparam name="T"></typeparam>
public struct Enumertor<T> : IEnumerator, IEnumerator<T>
{
//迭代索引
private int index;
//迭代器所属的集合对象引用
private List<T> list;
public Enumertor(List<T> container)
{
this.list = container;
this.index = -1;
}
public void Dispose()
{
}
/// <summary>
/// 显示实现IEnumerator的Current属性
/// </summary>
object IEnumerator.Current
{
get
{
return list[index];
}
}
/// <summary>
/// 实现IEnumerator<T>的Current属性
/// </summary>
public T Current
{
get
{
return list[index];
}
}
/// <summary>
/// 迭代器指示到下一个数据位置
/// </summary>
/// <returns></returns>
public bool MoveNext()
{
if (this.index < list.Count)
{
++this.index;
}
return this.index < list.Count;
}
public void Reset()
{
this.index = -1;
}
}
/// <summary>
/// 保存数据的数组，T类型则体现了泛型的作用。
/// </summary>
private T[] array;
/// <summary>
/// 当前集合的长度
/// </summary>
private int count;
/// <summary>
/// 默认构造函数
/// </summary>
public List()
: this(1)
{
}
public List(int capacity)
{
if (capacity < 0)
{
throw new Exception("集合初始长度不能小于0");
}
if (capacity == 0)
{
capacity = 1;
}
this.array = new T[capacity];
}
/// <summary>
/// 集合长度
/// </summary>
public int Count
{
get
{
return this.count;
}
}
/// <summary>
/// 集合实际长度
/// </summary>
public int Capacity
{
get
{
return this.array.Length;
}
}
/// <summary>
/// 是否固定大小
/// </summary>
public bool IsFixedSize
{
get
{
return false;
}
}
/// <summary>
/// 是否只读
/// </summary>
public bool IsReadOnly
{
get
{
return false;
}
}
/// <summary>
/// 是否可同属性
/// </summary>
public bool IsSynchronized
{
get
{
return false;
}
}
/// <summary>
/// 同步对象
/// </summary>
public object SyncRoot
{
get
{
return null;
}
}
/// <summary>
/// 长度不够时，重新分配长度足够的数组
/// </summary>
/// <returns></returns>
private T[] GetNewArray()
{
return new T[(this.array.Length + 1) * 2];
}
/// <summary>
/// 实现IList<T>Add方法
/// </summary>
/// <param name="value"></param>
public void Add(T value)
{
int newCount = this.count + 1;
if (this.array.Length < newCount)
{
T[] newArray = GetNewArray();
Array.Copy(this.array, newArray, this.count);
this.array = newArray;
}
this.array[this.count] = value;
this.count = newCount;
}
/// <summary>
/// 向集合末尾添加对象
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
int IList.Add(object value)
{
((IList<T>)this).Add((T)value);
return this.count - 1;
}
/// <summary>
/// 实现IList<T>索引器
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public T this[int index]
{
get
{
if (index < 0 || index >= this.count)
{
throw new ArgumentOutOfRangeException("index");
}
return this.array[index];
}
set
{
if (index < 0 || index >= this.count)
{
throw new ArgumentOutOfRangeException("index");
}
this.array[index] = value;
}
}
/// <summary>
/// 显示实现IList接口的索引器
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
object IList.this[int index]
{
get
{
return ((IList<T>)this)[index];
}
set
{
((IList<T>)this)[index] = (T)value;
}
}
/// <summary>
/// 删除集合中的元素
/// </summary>
/// <param name="index"></param>
/// <param name="count"></param>
public void RemoveRange(int index, int count)
{
if (index < 0)
{
throw new ArgumentOutOfRangeException("index");
}
int removeIndex = index + count;
if (count < 0 || removeIndex > this.count)
{
throw new ArgumentOutOfRangeException("index");
}
Array.Copy(this.array, index + 1, this.array, index + count - 1, this.count - removeIndex);
this.count -= count;
}
/// <summary>
/// 实现IList<T>接口的indexOf方法
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public int IndexOf(T value)
{
int index = 0;
if (value == null)
{
while (index < this.count)
{
if (this.array[index] == null)
{
return index;
}
++index;
}
}
else
{
while (index < this.count)
{
if (value.Equals(this.array[index]))
{
return index;
}
++index;
}
}
return -1;
}
/// <summary>
/// 显示实现IList接口的IndexOf方法
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
int IList.IndexOf(object value)
{
return ((IList<T>)this).IndexOf((T)value);
}
/// <summary>
/// 查找对应数组项
/// </summary>
/// <param name="o"></param>
/// <param name="compar"></param>
/// <returns></returns>
public int IndexOf(object o, IComparer compar)
{
int index = 0;
while (index < this.count)
{
if (compar.Compare(this.array[index], o) == 0)
{
return index;
}
++index;
}
return -1;
}
/// <summary>
/// 实现IList<T>接口的Remove方法
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public bool Remove(T value)
{
int index = this.IndexOf(value);
if (index >= 0)
{
this.RemoveRange(index, 1);
return true;
}
return false;
}
/// <summary>
/// 显示实现IList接口的Remove方法，此处显示实现
/// </summary>
/// <param name="value"></param>
void IList.Remove(object value)
{
((IList<T>)this).Remove((T)value);
}
/// <summary>
/// 从集合指定位置删除对象的引用
/// </summary>
/// <param name="index"></param>
public void RemoveAt(int index)
{
RemoveRange(index, 1);
}
/// <summary>
/// 弹出集合的最后一个元素
/// </summary>
/// <returns></returns>
public object PopBack()
{
object o = this.array[this.count - 1];
RemoveAt(this.count - 1);
return o;
}
/// <summary>
/// 弹出集合第一个对象
/// </summary>
/// <returns></returns>
public object PopFront()
{
object o = this.array[0];
RemoveAt(0);
return o;
}
/// <summary>
/// 实现IList<T>接口的Insert方法
/// </summary>
/// <param name="index"></param>
/// <param name="value"></param>
public void Insert(int index, T value)
{
if (index >= this.count)
{
throw new ArgumentOutOfRangeException("index");
}
int newCount = this.count + 1;
if (this.array.Length < newCount)
{
T[] newArray = GetNewArray();
Array.Copy(this.array, newArray, index);
newArray[index] = value;
Array.Copy(this.array, index, newArray, index + 1, this.count - index);
this.array = newArray;
}
else
{
Array.Copy(this.array, index, this.array, index + 1, this.count - index);
this.array[index] = value;
}
this.count = newCount;
}
/// <summary>
/// 显示实现IList接口的Insert方法
/// </summary>
/// <param name="index"></param>
/// <param name="value"></param>
void IList.Insert(int index, object value)
{
((IList<T>)this).Insert(index, (T)value);
}
/// <summary>
/// 实现IList<T>接口的Contains方法
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public bool Contains(T value)
{
return this.IndexOf(value) >= 0;
}
/// <summary>
/// 显示实现IList<T>接口的Contains方法
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
bool IList.Contains(object value)
{
return ((IList<T>)this).IndexOf((T)value) >= 0;
}
/// <summary>
/// 将集合压缩为实际长度
/// </summary>
public void TrimToSize()
{
if (this.array.Length > this.count)
{
T[] newArray = null;
if (this.count > 0)
{
newArray = new T[this.count];
Array.Copy(this.array, newArray, this.count);
}
else
{
newArray = new T[1];
}
this.array = newArray;
}
}
/// <summary>
/// 清空集合
/// </summary>
public void Clear()
{
this.count = 0;
}
/// <summary>
/// 实现IEnumerable接口的GetEnumerator方法
/// </summary>
/// <returns></returns>
public IEnumerator<T> GetEnumerator()
{
Enumertor<T> ator = new Enumertor<T>(this);
return ator;
}
/// <summary>
/// 显示实现IEnumerable接口的GetEnumerator方法
/// </summary>
/// <returns></returns>
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<T>)this).GetEnumerator();
}
/// <summary>
/// 实现ICollection<T>接口的CopyTo方法
/// </summary>
/// <param name="array"></param>
/// <param name="index"></param>
public void CopyTo(T[] array, int index)
{
Array.Copy(this.array, 0, array, index, this.count);
}
/// <summary>
/// 显示实现实现ICollection<T>接口的CopyTo方法
/// </summary>
/// <param name="array"></param>
/// <param name="index"></param>
void ICollection.CopyTo(Array array, int index)
{
Array.Copy(this.array, 0, array, index, this.count);
}
}登入後複製
調用：
static void Main(string[] args)
{
//由于已经指定了int，因此加入值类型不会有装箱拆箱操作。
List<int> tList = new List<int>();
tList.Add(25);
tList.Add(30);
foreach (int n in tList)
{
Console.WriteLine(n);
}
Console.ReadLine();
}登入後複製
以上是C#基礎知識整理 基礎知識（17）ILiest介面－泛型 的內容，更多相關內容請關注PHPcn中文（www.php.cn）！
本網站聲明
本文內容由網友自願投稿，版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容，請聯絡admin@php.cn
熱AI工具
Undresser.AI Undress
人工智慧驅動的應用程序，用於創建逼真的裸體照片
AI Clothes Remover
用於從照片中去除衣服的線上人工智慧工具。
Undress AI Tool
免費脫衣圖片
Clothoff.io
AI脫衣器
Video Face Swap
使用我們完全免費的人工智慧換臉工具，輕鬆在任何影片中換臉！
熱門文章
Windows 11 KB5054979中的新功能以及如何解決更新問題
3 週前
By DDD
如何修復KB5055523無法在Windows 11中安裝？
2 週前
By DDD
Inzoi：如何申請學校和大學
4 週前
By DDD
如何修復KB5055518無法在Windows 10中安裝？
2 週前
By DDD
Roblox：Dead Rails - 如何召喚和擊敗Nikola Tesla
4 週前
By 尊渡假赌尊渡假赌尊渡假赌
熱工具
記事本++7.3.1
好用且免費的程式碼編輯器
SublimeText3漢化版
中文版，非常好用
禪工作室 13.0.1
強大的PHP整合開發環境
Dreamweaver CS6
視覺化網頁開發工具
SublimeText3 Mac版
神級程式碼編輯軟體(SublimeText3)
泛型函數在Golang中解決可變參數類型的問題嗎？
Apr 16, 2024 pm 06:12 PM
Go中的泛型函數解決了可變參數類型的問題：泛型函數允許使用類型參數，在運行時指定。這使得編寫可以處理不同類型參數的函數成為可能。例如，Max函數是一個泛型函數，它接受兩個可比較參數並傳回較大值。透過使用泛型函數，我們可以編寫更靈活通用的程式碼，可處理不同類型的參數。
golang中泛型的具體應用場景
May 04, 2024 am 11:45 AM
泛型在Go中的應用場景：集合運算：建立適用於任何類型的集合運算，例如篩選。資料結構：編寫通用的資料結構，如佇列，堆疊和映射，可儲存和操作各種類型的資料。演算法：編寫通用的演算法，如排序，搜尋和歸約，可處理不同類型的資料。
Java 函數泛型的上限和下限是什麼？如何使用？
Apr 26, 2024 am 11:45 AM
Java函數泛型允許設定上限和下限。上限（extends）指定函數接受或傳回的資料類型必須是指定類型的子類型，例如。下限（super）指定函數接受或傳回的資料類型必須是指定類型的超類型，例如。泛型使用可提高程式碼的可重複使用性和安全性。
Java 泛型在 Android 開發的應用
Apr 12, 2024 pm 01:54 PM
泛型在Android開發中的應用加強了程式碼的可重複使用性、安全性和靈活性。其語法包括宣告一個類型變數T，可用於操作類型參數化的資料。泛型實戰案例包括自訂資料適配器，允許適配器適應任何類型的自訂資料物件。 Android還提供了泛型清單類別（如ArrayList）和泛型方法，允許操作不同類型的參數。使用泛型的好處包括程式碼可重複使用性、安全性和靈活性，但需要注意指定正確的界限並適度使用，以確保程式碼的可讀性。
探討Golang中泛型的優勢與用途
Apr 03, 2024 pm 02:03 PM
答案：Golang泛型是提高程式碼可重複使用性、靈活性、型別安全性和可擴充性的強大工具。詳細描述：優勢：程式碼可重複使用性：通用演算法和資料結構靈活性：執行階段建立特定類型實例類型安全性：編譯時類型檢查可擴展性：易於擴展和自訂用途：通用函數：排序、比較等通用資料結構：列表、映射、堆疊等類型別名：簡化類型聲明約束泛型：確保類型安全性
Golang泛型對函數簽章和參數的影響是什麼？
Apr 17, 2024 am 08:39 AM
泛型對Go函數簽章和參數的影響包括：型別參數：函數簽章可包含型別參數，指定函數可使用的型別。類型約束：類型參數可具有約束，指定其必須滿足的條件。參數類型推斷：編譯器可推斷未指定型別參數的型別。指定類型：可明確指定參數類型以呼叫泛型函數。這提高了程式碼的可重複使用性和靈活性，允許編寫可與多種類型一起使用的函數和類型。
Java 枚舉類型如何與泛型搭配使用？
May 04, 2024 am 08:36 AM
Java中枚舉型別與泛型的結合：宣告帶有泛型的枚舉時需加上尖括號，T為型別參數。建立泛型類別時，同樣需新增尖括號，T為可儲存任何類型的類型參數。此結合可提高程式碼靈活性、類型安全性，並簡化程式碼。
