VB.net学习笔记（十九）数组、集合、泛型_vb.net 集合

相关文章推荐

苦闷的墨镜 · 属性“”isFetching“”在类型“”n ...· 1 周前 ·

潇洒的茶叶 · C#4.0和VS2010新特性（二） - ...· 3 天前 ·

知识渊博的帽子 · WPF上位机自定义控件系列：步骤 ...· 7 月前 ·

力能扛鼎的作业本 · C语言文件读取那些事（open,fopen等 ...· 10 月前 ·

聪明伶俐的跑步鞋 · Springboot项目中应用jasypt进 ...· 1 年前 ·

打盹的针织衫 · VS2017创建DLL项目及调用 - 知乎· 1 年前 ·

腼腆的皮带 · linux ...· 1 年前 ·

变量、数组、集合、泛型的发展

最开始用内存中一个位置映射一个值，用变量来“使用”这个值。

进一步发展，用变量来引用一组值，这就是数组。由数组概念，发展出链表、堆、栈，进行排序、检索等。

但这并不能完全表达，由此发展出集合概念，它是更强大的数组，都依赖于Object基类。

随之而来的是集合中元素并不一定是一样的，于是都得转为Object，涉及到装箱，使性能下降，特别是元素量巨大时。而且

由于我们一般使用同一类型（强类型）更方便操作。由此产生了泛型

泛型简单地说，就是把里面的元素强制指定为特定的类型，也可以说是模板。

Dim a2() As Integer = {1, 2, 3, 4} Dim a3(4, 2) As Integer Dim a4(,) As Integer = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}, {13, 14, 15}} Dim a5() As Integer

a1数组是从a1(0)到a1(20)共21个元素，而不是20个元素。20表示上限。

a2表示4个元素，上限是3，即a2(3)

a3表示的是二维数组

a4也是二维，但其一维和二维的上限由后面的值来确定。

a5表示是不定数组，将在后面的使用中来确定，它是一个重要的概念

2、多维数组

UBound用来提取数组中某维中的上限（注意不是个数），LBound是提取数组的下限，由于下限永远是从0开始，所以这个函数没用了。

另外维数是从左到右，从1开始计数（这与元素索引从0开始计数不同）

需要注意的是： GetUpperBound(0)也是提取上限，例如 : a1.GetUpperBound(0)

它的维数却是以0开始，相当于UBound中维数的1

Module Module1
    Sub Main()
        Dim a(,) As Int32 = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}}
        Dim temp As Int32
        For i As Int32 = 0 To UBound(a)  '即UBound(a,1)
            For j As Int32 = 0 To UBound(a, 2) '将返回其最大可用下标的维度。 对第一维使用 1，对第二维使用 2，
                temp += a(i, j)                '依此类推。 如果省略 Rank，则假定为 1。
        Console.WriteLine(temp)
        Console.Read()
    End Sub
End Module
         保持之意。不定数组经ReDim实例化后，还可再次用ReDim来改变，第二次改变会直接改变第一次实例化中重叠的元素。 
          为了保持元素值，用Preserve来指明。 
          注意Preserve只能修改最后一维的大小。 
    Sub Main()
        Dim a(,) As Int32
        ReDim a(6, 5)
        a(6, 1) = 3
        ReDim a(7, 4)        '正确，无Preserve时，可以修改多维 
        'ReDim Preserve a(5, 4) '错误，有Preserve时，只能修改最后一维的大小
        Console.WriteLine(a(6, 1))
        Console.Read()
    End Sub 
             数组功能很强大，但Array基类并没为数组提供更多的功能，比如排序、动态分配内存。为了更强大的功能产生了集合。 
            集合（Collections)名称空间是System名称空间的一部分，它提供系列高级功能。 
            对不同的用处，System.Collections名称空间提供了几个强大的类： 
                      ArrayList    实现一个数组，其大小在添加元素时自动增加大小（不必烦恼数组的上限或用ReDim、Preserve） 
                      BitArray      管理以位值存储的布尔数组 
                      Hashtable   实现由键组织的值的集合（Key,Value)，排序是基于键的散列完成的（哈希函数） 
                      Queue         实现先进先出集合（排序方式） 
                      Stack            实现后进先出集合 
                      SortedList    实现带有相关的键的值的集合，该值按键来排序，可以通过键或索引来访问 
1、ArrayList  数组列表 
             ArrayList 仅一维且不保证是排序的。 可使用一个整数索引访问此集合中的元素。 此集合中的索引从零开始。 
             在执行需要对 ArrayList 排序的操作（如 BinarySearch）之前，必须对 ArrayList 进行排序。
 
            ArrayList 的容量是 ArrayList 可以包含的元素数。 随着向 ArrayList 中添加元素，容量通过重新分配按需自动增加。 
            可通过调用 TrimToSize 或通过显式设置 Capacity 属性减少容量。对于非常大 ArrayList 对象，则在运行时环境
           (ide) 中增加最大容量为 20亿在 64 位系统的元素通过设置 gcAllowVeryLargeObjects 配置元素的 enabled 属性设置为 true 。
 
             ArrayList 集合接受 null 引用（在 Visual Basic 中为 Nothing） 作为有效值并且允许重复的元素。
  
Module Module1
    Sub Main()
        '使用大小会根据需要动态增加的数组来实现 IList 接口
        Dim objArryList As New System.Collections.ArrayList
        Dim objItem As Object
        Dim intLine As Int32 = 1
        Dim strHello As String = "Hello"
        Dim objWorld As New System.Text.StringBuilder("World")
        objArryList.Add(intLine)
        objArryList.Add(strHello)
        objArryList.Add(" "c)
        objArryList.Add(objWorld)
        objArryList.Insert(1, ". ") '在索引1处插入。（索引从0开始）
        For Each objItem In objArryList
            Console.WriteLine(objItem.ToString)
        Console.Read()
    End Sub
End Module 
          可以看到使用很方便：1、不需要声明数组大小 
                                                   2、不需要重写定义数组大小 
                                                   3、不需要用Preserve来保持数据 
          ArrayList都会自动完成这样的功能。 
3、SortedList  排序列表
              hashtable是没有排序的，所以新增元素会比较快。而SortedList 存储的键值对，是按key进行排序了的， 
            因为要排序，所以新增元素时，要先查找元素的位置再插入，相对慢些，但是在查找时比较快。
  
            下面，每变动一次元素，自动会按Key进行排序，所以最后不需排序，就可得到排序的结果： 
4、Queue 队列 
           表示对象的先进先出集合。 
          队列在按接收顺序存储消息方面非常有用，以便于进行顺序处理。 此类将队列作为循环数组实现。 存储在 Queue 中的对象在一端插入，从另一端移除。 
          Queue 的容量是 Queue 可以包含的元素数。 随着向 Queue 中添加元素，容量通过重新分配按需自动增加。 可通过调用 TrimToSize 来减少容量。 
          等比因子是当需要更大容量时当前容量要乘以的数字。 在构造 Queue 时确定增长因子。 默认增长因子为 2.0。 Queue 的容量将始终加 4， 
          无论增长因子是多少。 例如，当需要更大的容量时，增长因子为 1.0 的 Queue 的容量将始终增加四倍。 
          Queue 接受 null 引用（在 Visual Basic 中为 Nothing） 作为有效值并且允许重复的元素 
               Do  Until...Loop 
                        同理，越过：Continue While        或Continue Do 
                                    退出：Exit While                  或Exit  While 
       (3)Thread.Sleep() 
             大循环或无限循环中，会一直占用线程，给造成界面假死现象，可用Thread.Sleep（），这样仅在给定时间才执行，以避免 
              消耗过多的处理器时间。 
                     while   i=1 
                                 system.Threading.Thread.Sleep(500)   
                      end while 
         （1）什么是装箱？ 
                  值类型存储在栈上，引用类型存储在堆上。 
                  当值类型向引用类型转变，即从栈向堆上转移，这时值就变成了一对象，就好像值类型外面包装了一层东西，这个过程叫装箱（Boxing）   
        '不需要装箱，都是值类型
        Dim a1(20) As Integer
        Dim a2 As Integer = 1
        a1(0) = 0
        a1(1) = a2
        '需要装箱，String是引用类型
        Dim b1 As New System.Text.StringBuilder()
        Dim b2 As New System.Collections.SortedList()
        Dim i As Integer
        For i = 1 To 100
            b1.Append(i) '未装箱，直接接收
            b2.Add(i, i) '装箱，参数需要两个对象，要转换integer为对象
           （2）装箱的影响 
                    显然装箱会使“值”的外层多了一些“无用”的东西，会使得性能稍有下降。 
                    集合中元素都来自Object（引用类型），即，它是在堆上，都涉及到一个装箱，如果数据量大时，性能下降得就可观了。 
                   当需要时其中的“值”时，又需要把箱子，从堆上转移到栈上，即引用类型变成值类型，这个过程叫拆箱。 
             （3）为什么要有泛型？ 
                     集合中，任何引用或值类型都将隐式地向上强制转换为Object。如果项是值类型，添加到列表中时，进行装箱操作，在检索时进行取消装箱操作。 
                     这样，强制转换以及装箱和拆箱操作都会降低性能。 
                     另一个限制是缺少编译时类型检查。同一个集合可接收不同类型，所有项都强制转换为 Object，在编译时无法检查是否可以收这种类型，还是人为 
                     错误输入了另一个类型，同时智能感应只会提示Object的方式，使得检查错误变得艰难。
 
 
                     如果我们对其中的类型进行一些限制，使之成为统一的类型，虽然稍微增加了编码的复杂性，但好处是可以创建一个 更安全并且速度更快的列表， 
                    校验错误也变得容易。 
                     鉴于这种情况，催生了泛型的产生。 
2、泛型的使用 
         泛型主要的目的是创建强类型化的集合，使处理速度加快。所以前面使用Object的普通集合类，最好使用泛型。 
         泛型内置于.net中，允许定义代码模板，然后使用这个模板声明变量，它实际上是创建了一个新的数据类型。 
         .net基类库（BCL）里有许多泛型模板，多位于System.Collections.Generic名称空间，也有分布在其它BCL中。 
          泛型带来的性能提升，可以让任何使用集合数据类型的地方都应当使用泛型代替。 
           泛型通常使用List(of   T)形式，List是类型（或者类）的名称 ，字母T是点位符类似于参数。它表示 必须提供一个用来定制泛型 
           的特定类型值，同时也限定的它只能是这个类型。 
        Dim data1 As New List(Of Date) '元素只能是Date类型
        '===================================
        Dim data2 As New ArrayList  '未限定元素类型，任意。（object)
        data2.Add(5)
        data2.Add("xxx")
        data2.Add(3.2)
        For Each i As Object In data2
            TextBox1.AppendText(i.ToString & Environment.NewLine)
             上面可以看到，当没有限定时，它是Object，因为可能是integer,String，double等，最终将转向Object。也就是说 
              普通集合中元素是多种情况，只有当用了泛型才进行了统一，这样处理更快。 
               当用了泛型后，类型参数指明后，将不能再用其它类型，如下： 
        Dim data1 As New List(Of Integer) '元素只能是Integer类型
        data1.Add(33)           '正确
        data1.Add("Hello")      '错误，不能为string                 
               泛型有两种形式：泛型类型和泛型方法 
                        List(of  T)是泛型类型，定义了完整的类型或类的模板。 
                        泛型 方法是一种方法模板，使用时必须指明方法使用的“具体类型”。 
3、Nullabel   可空类型 
        简言之：可以有空值的类型。 比如数据库有字段有integer型，但有时是DBNULL（空值），在取时会出错，这个类型就有用处了。 
        Nullable不是值类型。 
        Dim intValue1 As New Nullable(Of Integer) '可为空的Integer类型
        Dim intValue2 As Integer?   '与上句等效
        intValue1 = 3
        intValue1 = Nothing '可为空，正确
        intValue2 = Nothing           
        'KeyValuePair(Of Integer, String) 键值对元素
        For Each o As KeyValuePair(Of Integer, String) In data
            TextBox1.AppendText(o.Key & "," & o.Value & vbCrLf)
        '==========================
        Dim data2 As New Generic.Dictionary(Of Guid, Date)
        data2.Add(New Guid, Now)
        For Each o As KeyValuePair(Of Guid, Date) In data2
            TextBox1.AppendText(o.Key.ToString & "," & o.Value) 'Guid须转String
           Generic.Dictionary(Of K，T)泛型，与List（Of  T)类型类似，但需两个类型参数来提供键与值（Key，Value）。 
           新的Dictionary类型只接受特定类型的键与值，如上面第一个是Integer与String。第二个只接收Guid与Date。 
             上面是声明时的情况，下面是作返回值的情况 
    Private Function reGeneric() As Generic.Dictionary(Of Integer, String) '返回值类型
        Dim data As New Generic.Dictionary(Of Integer, String)
        data.Add(3, "dx")
        data.Add(2, "qxj")
        data.Add(1, "ase")
        Return data  '返回泛型
    End Function 

             可以这样调用上面函数： 
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim data As New Generic.Dictionary(Of Integer, String)
        data = reGeneric() '调用，取得泛型
        For Each o As KeyValuePair(Of Integer, String) In data
            TextBox1.AppendText(o.Key & "," & o.Value & vbCrLf)
    End Sub 

           泛型还可以作为传参： 
    Private Sub useGeneric(ByVal k As Generic.Dictionary(Of Integer, String)) '泛型作参数
        'add code
    End Sub 
         （2）继承 
             定义新类时，可以继承泛型类型。 
             例如：.net BCL定义的System.ComponentModel.BindingList(Of  T)泛型类型，它用于创建支持数据绑定的集合。 
                          可以将其作用基类，创建支持数据绑定的强类型集合。 
Public Class Form1
    Dim list As New CustomerList
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles Me.Load
        DataGridView1.DataSource = list
    End Sub
End Class
Public Class Customer
    Public Property Name() As String
End Class
Public Class CustomerList
    Inherits System.ComponentModel.BindingList(Of Customer) '必须指明具体的类型（如Customer)
    Private Sub CustomerList_AddingNew(ByVal sender As Object, ByVal e As System.ComponentModel.AddingNewEventArgs) Handles Me.AddingNew
        Dim cust As New Customer
        cust.Name = "<new>"
        e.NewObject = cust
    End Sub
End Class 
        上面继承时，必须指明具体类型，于是可以用BindingList(Of  Customer) 
        常规继承概念也可以用在其中，比如：重载、重写、事件等。              
         泛型方法不必只在定义的泛型类型中使用，还可以任意的类型和模块中使用泛型方法。 
          泛型方法的好处是：不需要使用Ctype或DirectCast转换不同类型的参数与返回值。（因为泛型是CType与DirectCast替换的机制，它实际上仍然会转换） 
           下面重载泛型方法： 
Public Class Form1
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim result As Boolean
        result = AreEqual(1, 2)
        result = AreEqual("one", "two")
        result = AreEqual(1, "two") '均正确写法，转为object比较
        '使用泛型
        result = AreEqual(Of Integer)(1, 2)
        result = AreEqual(Of String)("one", "two") '正确写法
        result = AreEqual(Of Integer)(1, "two") '错误
    End Sub
    '不使用泛型
    Public Function AreEqual(ByVal a As Object, b As Object) As Boolean
        Return a.Equals(b)
    End Function
    '使用泛型（重载）
    Public Function AreEqual(Of T)(ByVal a As T, b As T) As Boolean
        Return a.Equals(b)
    End Function
End Class 
           泛型方法会有两套参数（分别用两个括号）： 
                  第一套参数（第一个括号）用来定义方法中使用的类型 
                  第二套参数（第二个括号）与我们平时的参数列表一样，只不过用T等来代替要用的类型。            上面如果在Option  Strict On时 
           下面创建链表，为了适合不同类型情况，使用泛型。在这个嵌套类中先定义结点类Node: 
Public Class SingleLinkedList(Of ValueType) '单向链表类。其中，自定类型ValueType
#Region "Node Class"
    Public Class Node '每个结点由当前值、指向下一个结点的引用，这两个元素组成
        Private mValue As ValueType
        Public ReadOnly Property Value() As ValueType '当前结点的值
                Return mValue
            End Get
        End Property
        Public Property NextNode() As Node '下个结点的引用
        Public Sub New(ByVal value As ValueType, ByVal newNode As Node) '创建新结点
            mValue = value
            NextNode = newNode
        End Sub
    End Class
#End Region
End Class 

       这样在声明使用中就可以使用具体类型，比如用Double类型的链表：  
        Dim list As New SingleLinkedList(Of Double)
       这时，在类的的ValueType实际上就变成了:
         Private mValue As Double
  
        实际上，在设计时（ValueType类型），被当作了Object（类型），故只能使用System.object类型上的方法： 
                     Equals()、  GetHashValue()、     GetType()、   ReferenceEquals()、    Tostring() 
        这将限制我们操作，并且智能化提示也受限，后面将用约束概念，来明确选择的类型，这样扩展功能增强智能化提示。 
         然后，使用Node完善链表类：         
Public Class SingleLinkedList(Of ValueType) '单向链表类。其中，自定类型ValueType
#Region "Node Class"
    Public Class Node '每个结点由当前值、指向下一个结点的引用，这两个元素组成
        Private mValue As ValueType
        Public ReadOnly Property Value() As ValueType '当前结点的值
                Return mValue
            End Get
        End Property
        Public Property NextNode() As Node '下个结点的引用
        Public Sub New(ByVal value As ValueType, ByVal newNode As Node) '创建新结点
            mValue = value
            NextNode = newNode
        End Sub
    End Class
#End Region
    Private mHead As Node '头结点，也是当前结点。（按倒序加入结点，参看后图）
    Default Public ReadOnly Property Item(ByVal index As Integer) As ValueType '获取第N个结点值
            Dim current As Node = mHead
            For i As Integer = 1 To index
                current = current.NextNode
                If current Is Nothing Then
                    Throw New Exception("Item not found in list")
                End If
            Return current.Value
        End Get
    End Property
    Public Sub Add(ByVal value As ValueType) '添加结点到链表
        mHead = New Node(value, mHead)
    End Sub
    Public Sub Remove(ByVal value As ValueType) '从链表中移除结点
        Dim current As Node = mHead
        Dim preNode As Node = Nothing
        While current IsNot Nothing
            If current.Value.Equals(value) Then
                If preNode Is Nothing Then '是否为头结点
                    mHead = current.NextNode
                    preNode.NextNode = current.NextNode '非头结点（参看下图）
                End If
                Exit Sub '已移除，退出
            End If
            preNode = current
            current = current.NextNode
        End While
        Throw New Exception("Item not found in list") '链表中未找到
    End Sub
    Public ReadOnly Property Count() As Integer '统计结点数
            Dim result As Integer = 0
            Dim current As Node = mHead
            While current IsNot Nothing
                result += 1
                current = current.NextNode
            End While
            Return result
        End Get
    End Property
End Class 
           定义好链表类后，下面使用： 
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim list As New SingleLinkedList(Of String)
        list.Add("one")
        list.Add("two")
        list.Add("three")
        list.Add("sichuan")
        list.Add("dazhou")
        TextBox1.Clear()
        TextBox1.AppendText(list.Count & vbCrLf)
        For i As Integer = 0 To list.Count - 1 '这里只能从0，因为你不能预知是否有结点。
            TextBox1.AppendText(list.Item(i) & vbCrLf)
    End Sub          运行，结果如下： 
    Private mMoney As Double
    Public Sub New(ByVal value As T, ByVal data As V, ByVal money As Double) '带两个类型参数及一个普通类型参数
        mValue = value
        mData = data
        mMoney = money
    End Sub
End Class 
'泛型继承泛型
Public Class GenericSubClass2(Of V) '在使用时（声明）指明V类型
    Inherits GenericBase(Of V)  '与上V相同，故类型由子类传递回父类
    'add code
End Class
'复杂子类泛型传递回父类
Public Class GenericSubClass3(Of V)
    Inherits GenericBase(GenericBase(of V)) '子类型传回父类
    'add code
End Class 
Public Class ARegularClass
    Implements Icool(Of String) '必须指明类型
    Implements Icool(Of Integer)
    '============String时情况==============
    Public Sub DoWork(data As String) Implements Icool(Of String).DoWork
        'add code
    End Sub
    Public Function GetAnswer() As String Implements Icool(Of String).GetAnswer
        'add code
    End Function
    '==========Integer时情况=================
    Public Sub DoWork1(data As Integer) Implements Icool(Of Integer).DoWork
        'add code
    End Sub
    Public Function GetAnswer1() As Integer Implements Icool(Of Integer).GetAnswer
        'add code
    End Function
End Class

上面泛型接口定义中无法明确类型，它依赖于ARegularClass中接口类型的定义（有两个：Integer、String）

'模块中使用泛型
Public Module Comparisons1
    Public Function AreEqual(Of T)(ByVal a As T, ByVal b As T) As Boolean
        Return a.Equals(b)
    End Function
End Module
'类中使用泛型
Public Class Comparisons2
    Public Function AreEqual(Of T, R)(ByVal a As T, ByVal b As R) As R '返回也可为R
        'add code
    End Function
End Class

四、约束（限制）

泛型类型、泛型方法在编写代码时，类型参数都被当作System.Object类型处理，这限制了使用类型参数的参数与变量的功能。

即，只能进行赋值和调用所有System.Object变量的几个方法，大大限制了泛型的用途。

约束就是来突破这种限制，并提供控制机制。约束提供指定规则，声明运行时可以代替类型参数类型。

使用约束，可以限定类型参数必须是一个类或结构，也可限定类型参数必须实现接口或继承某基类。这样智能提示就生效了。

通俗地说：约束暗示了某具体类型，使得智能提示生效。

1、类型约束

这是常用约束，它限制某类型参数必须是指定类的子类或者必须实现指定的接口。

改变上面的链接类成为ComparableLinkedList，这里泛型指明了ValueType，同时也指明它是一个接口IComparable。

因此，智能提示会对ValueType类型提示IComparable的属性和方法：

Public Class Form1
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim list As New ComparableLinkedList(Of String)
        list.Add("one")
        list.Add("two")
        list.Add("three")
        list.Add("sichuan")
        list.Add("dazhou")
        TextBox1.Clear()
        TextBox1.AppendText(list.Count & vbCrLf)
        For i As Integer = 0 To list.Count - 1 '这里只能从0，因为你不能预知是否有结点。
            TextBox1.AppendText(list.Item(i) & vbCrLf)
    End Sub
End Class
Public Class ComparableLinkedList(Of ValueType As IComparable) '类型参数同时也是接口（用于比较）
#Region "Node Class"
    Public Class Node
        Private mValue As ValueType
        Public ReadOnly Property Value() As ValueType
                Return mValue
            End Get
        End Property
        Public Property NextNode() As Node
        Public Sub New(ByVal value As ValueType, ByVal newNode As Node)
            mValue = value
            NextNode = newNode
        End Sub
    End Class
#End Region
    Private mHead As Node
    Default Public ReadOnly Property Item(ByVal index As Integer) As ValueType
            Dim current As Node = mHead
            For i As Integer = 1 To index
                current = current.NextNode
                If current Is Nothing Then
                    Throw New Exception("Item not found in list")
                End If
            Return current.Value
        End Get
    End Property
    '=========这是原来不是接口时的添加元素的方法=========
    Public Sub Add1(ByVal value As ValueType)
        mHead = New Node(value, mHead)
    End Sub
    '======现在类型参数同时是接口（可用于比较）的方法=====
    Public Sub Add(ByVal value As ValueType)
        If mHead Is Nothing Then
            mHead = New Node(value, mHead) '链表无结点时，直接添加
            Dim current As Node = mHead
            Dim preNode As Node = Nothing
            While current IsNot Nothing
                If current.Value.CompareTo(value) > 0 Then '===关键，接口使用（比较）
                    If preNode Is Nothing Then
                        mHead = New Node(value, mHead) '链表头
                        preNode.NextNode = New Node(value, current) '链表中
                    End If
                    Exit Sub
                End If
                preNode = current
                current = preNode.NextNode
            End While
            preNode.NextNode = New Node(value, Nothing) '链表尾
        End If
    End Sub
    Public Sub Remove(ByVal value As ValueType)
        Dim current As Node = mHead
        Dim preNode As Node = Nothing
        While current IsNot Nothing
            If current.Value.Equals(value) Then  
                If preNode Is Nothing Then
                    mHead = current.NextNode
                    preNode.NextNode = current.NextNode
                End If
                Exit Sub
            End If
            preNode = current
            current = current.NextNode
        End While
        Throw New Exception("Item not found in list")
    End Sub
    Public ReadOnly Property Count() As Integer
            Dim result As Integer = 0
            Dim current As Node = mHead
            While current IsNot Nothing
                result += 1
                current = current.NextNode
            End While
            Return result
        End Get
    End Property
End Class
'约束类型参数必须是某类的子类（下例为Control的泛型方法）
Public Shared Sub ChangControl(Of C As Control)(ByVal con As C)
    con.Anchor = AnchorStyles.top Or AnchorStyles.left
End Sub
'===========================================================
'约束类型参数为特定的泛型
Public Class ListClass(Of T, V As Generic.List(Of T))
    'add code
End Class
'使用时这样：
Dim list As ListClass(Of Integer, Generic.List(Of Integer))           上面还限制了部分参数须是某泛型类型（V） 
Public Class Factories(Of T As New)
    Public Function CreateT() As T    '必须确保T有默认的构造函数，否则出错
        Return New T
    End Function
End Class 
          类型参数T必须有公共的默认构造函数。若给T没指定构造函数的类型会出错。有了T的默认构造函数后，就可以CreateT创建实例。 
       下面约束：必须是引用类型，且必须有公共的默认构造函数： 
Public Class Factories(Of T As {New, Class}) '限制类型参数可以为多种情况(花括号）
    Public Function CreateT() As T
        Return New T
    End Function
End Class 
         泛型的变量与参数在模板代码中被当作Object处理，虽然用约束解决了部分问题、扩展了变量类型，但仍受限制。 
         比如，并不知道指定的类型是否支持+-等运算符重载： 
Public Function Add(Of T)(ByVal a As T, ByVal b As T) As T
    Return a + b '错误，因不知道是否支持运算符重载
End Function
'改为下面(option strict off)
Public Function Add1(Of T)(ByVal a As T, ByVal b As T) As T
    Return CObj(a) + CObj(b) '此时应重载+，这样才不会出错
End Function            
         例如Animal是父类，Dog是从Animal继承的子类。 
          如果一个方法要接受Dog参数，那么另一个接受Animal参数的方法肯定也可以接受这个方法的参数，这是Animal向Dog方向的转变是逆变。 
          如果一个方法要求的返回值是Animal，那么返回Dog的方法肯定是可以满足其返回值要求的，这是Dog向Animal方向的转变是协变。 
         它们的主要应用场合是多态。 
      子--->父 
Public Class Parent(Of T)
    'add code
End Class
Public Class ChildClass(Of T)
    Inherits Parent(Of T)
    'add code
End Class
'多态应用中，协变
Public Class CoVariance
    Public Sub MainMethod()
        Dim cc As New ChildClass(Of String)
        Dim dad As Parent(Of String)
        dad = cc    '子类赋值给父类，协变
    End Sub
End Class

Public Class ContraVariance '封装一个方法，有一个参数且无返回值，即baseMethod(byval param as Base) Private baseMethod As Action(Of Base) = Sub(param As Base) 'add code End Sub 'derivedMethod(byval param as Derived) Private derivedMethod As Action(Of Derived) = baseMethod Public Sub MainMethod() Dim d As Derived = New Derived() derivedMethod(d) baseMethod(d) End Sub End Class Module Module1 Sub Main() Dim a(,) As Int32 = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}} Dim temp As Int32 For i As Int32 = 0 To UBound(a) '即UBound(a,1) For j As Int32

集合是一些有共同特征的独立数据项组成的，通过集合，我们可以可以使用相同的调用代码来处理一个集合的所有元素，而不用单独处理每一个单独的项。.net的集合诸如（System.Array类以及 System.Collections命名空间）数组、列表、队列、堆栈、哈希表、字典甚至（System.Data下)DataSet、DataTable，还有2.0中加入的集合的泛型版本（System.Collections.Generic和 System.Collections.ObjectModel），4.0中引入的有效线程安全操作的集合（System.Collections.Concurrent）。

//在 .NET种又2种集合一种是 VB的 collection 集合另一种是 .NET Framework 的泛型集合 ////VB的collection 集合和 .NET下的泛型集合泛型集合限定了键值对的类型 1. VB的collection 集合 Module Module1 Sub Main() Dim col As New Microsoft.VisualBasi...

C# 泛型和数组在 C# 2.0 中，下限为零的一维数组自动实现 IList。这使您可以创建能够使用相同代码循环访问数组和其他集合类型的泛型方法。此技术主要对读取集合中的数据很有用。IList 接口不能用于在数组中添加或移除元素；如果试图在此上下文中调用 IList 方法（如数组的 RemoveAt），将引发异常。下面的代码示例演示带有 IList 输入参数的单个泛型方法如何同时循环访问列表和数组，本例中为整数数组。 C# 泛型和数组代码代码如下: class Program { static void Main() { int[] arr = { 0, 1, 2,

基于多条记录有多种存储方法，而我们在选择使用哪种方法时考虑最多的还是其执行哪种方法的执行速度比较快，本人特编写了此程序，用于对比四种最常用的方法（数组、集合、列表、数据表）的执行速度。又因为列表与数据表两种方案又有多种查询方法，此程序又加上了列表的find与findindex方法的比较和数据表的rows.find方法与其对应的dataview的findrows方法、filter方法的执行速度比较程序用vb2010编写，需要.net 4.0框架支持，运行前请先安装4.0框架

泛型集合 12.3.4 泛型集合泛型的场景：定义泛型：12.3.5 Colletions工具类 12.3.4 泛型集合概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致；编译时即可检查，而非运行时抛出异常；访问时，不必类型转换（拆箱）；不同泛型之间引用不能相互赋值，泛型不存在多态； import java.util.List; import java.util.Vector; import java.util.ArrayList; import java.util.LinkedList; public class TestBasicGeneric { public s

Iterator<String> iterator = list.iterator(); while(iterator.hasNext()) { String fruit = iterator.next(); System.out.println(fruit); 无论是使用增强for循环还是迭代器，都可以很方便地遍历ArrayList 数组泛型集合。

(06)基础强化:ArrayList与Hashtable,比较器Comparer,泛型集合List＜T＞与Dictionary＜K,V＞,枚举器与迭代器,泛型的协变与逆变 CSDN-Ada助手: 恭喜你，获得了 2023 博客之星评选的入围资格，请看这个帖子（https://bbs.csdn.net/topics/615728442?utm_source=blogger_star_comment）。请在这里提供反馈： https://blogdev.blog.csdn.net/article/details/129986459?utm_source=blogger_star_comment。