List＜ T ＞集合(手把手教你）

cfqq1989

已于 2023-12-03 16:53:32 修改

阅读量3.9k

点赞数

分类专栏： C#基础文章标签： c#

于 2021-09-27 10:39:03 首次发布

本文链接：https://blog.csdn.net/cfqq1989/article/details/120502993

版权

C#基础专栏收录该内容

36 篇文章 4 订阅

订阅专栏

public class MyGenericArray<T>
    {
        private T[] array;
        public MyGenericArray(int size)
        {
            array = new T[size + 1];
        }
        public T getItem(int index)
        {
            return array[index];
        }
        public void setItem(int index, T value)
        {
            array[index] = value;
        }
————————————————
版权声明：本文为CSDN博主「明如正午」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sinat_40003796/article/details/125519861

编程还是像以前那样编程，只是最后把类型，比如 string 替换成 < T > 这样的写法。

泛型是在动态数组的基础上做的升级，用于解决下标动态和类型动态。

泛型的字面意思是通用的。（女人衣服，男人不能穿，那有没有都能穿的衣服？有，西装。
那么，这个西装就是泛型。

泛型是解决数组的问题：
数组使用时，必须确定数据类型和长度。泛型解决了这2个问题。

T 是占位符，在使用的时候把具体的类型替换T的位置。

List< T > 这个 T 是自定义类型Type，可以是int值类型也可以是狗，飞机，学生，成绩表等等对象。

对于下标数量不用确定，数组在定义的时候就必须明确下标数量，集合就不需要。

List< T >

List< in T >

in是引用源参数，参数是引用类型时没区别，但如果源参数是值类型传递时，相当于复制了一个只读参数。类似于只读对象指针，指向源数据地址。对体积很大的struct能提高速度。

List<狗>   群狗 = new List<狗>();

这就意味着可以无限添加下标实例对象

群狗.Add(金毛);
群狗.Add(田园);
群狗.Add(牛头梗);
群狗.Add(拉布拉多);
群狗.Add(边牧);
群狗.Add(京巴);

集合初始化器：

List<string>   strs = new List<string>("1","2","3","4","5","6");

集合的复制：

List<狗>   群狗2 = new List<狗>(群狗);

//复制后，群狗2 和 群狗  是独立的2个对象

既然能添加，就能删除和查找还有排序。

.Add(对象); // 添加对象

.AddRange(数组); //添加数组 .ToArray(); .ToList();

Remove() RemoveALL(T=>T.编号>10002); RemoveAT(下标);

.Count // 返回对象数量

在集合中查找

学生名单.FindALL(t=>t.成绩>60);
bool  含有 = 学生名单.Contains("潘金莲");

public void TraversalList2(List<Course> courseList)
{
  foreach (Course item in courseList)
   {
    Console.WriteLine($"{item.CourseId}\t{item.CourseName}\t{item.ClassHour}\t{item.Teacher}");
    }
}


//集合查询方法1
            List<Course> result1 = courseList.FindAll(c => c.CourseId > 10003);

//集合查询方法2
            var result2 = from c in courseList where c.CourseId > 10003 select c;
            var result3 = result2.ToList();

集合元素排序

.Sort(); 升序

.Reverse(); 反排序（先升序，再反排序，就是降序结果）

.CompareTo(排序条件);

 #region 集合元素排序

        public void ListOrder()
        {
            #region 值类型元素的排序

            Console.WriteLine("\r\n----------------------值类型元素排序------------------\r\n");
            List<int> ageList = new List<int> { 20, 19, 25, 30, 26 };
            ageList.Sort();//默认按照升序排列

            foreach (int item in ageList)
            {
                Console.WriteLine(item);
            }
            ageList.Reverse();
            Console.WriteLine("-------------");
            foreach (int item in ageList)
            {
                Console.WriteLine(item);
            }

            #endregion

            //对象集合元素排序（默认）
            Console.WriteLine("\r\n----------------------集合默认排序------------------\r\n");
            List<Course> courseList = CreateCourses();

            courseList.Sort();

            //以上Sort方法默认会报错的！所以在Course类中实现系统接口IComparable<Course>
            TraversalList1(courseList);
            //以上我们使用默认比较器进行排序，很不方便，如果我们需要多种排序，怎么办？

            //比较器接口：其实就是我们可以任意的指定对象属性排序，从而实现动态排序。
            //集合元素动态排序
            Console.WriteLine("\r\n----------------------集合动态排序------------------\r\n");

            //排序方法的定义： public void Sort(IComparer<T> comparer);
            courseList.Sort(new CourseIdASC());
            Console.WriteLine("-----------按照编号升序---------\r\n");
            TraversalList1(courseList);

            Console.WriteLine("\r\n-----------按照编号将序---------\r\n");
            courseList.Sort(new CourseIdDESC());
            TraversalList1(courseList);

            //其实上面我们的练习，我希望大家，能够自己写出来，但是更重要的是理解多态的原理，因为Sort这个重载的方法就是多态原理的一个应用。
            //我们后面深入学习架构开发等更高级的理论，技能，设计模式等，处处都在用多态！

            //通过上面的练习，我们发现实际应用中，还是有点麻烦的。大家如果跟着常老师深入系统学习VIP课程，会给大家讲解更好的方法。

            //高级阶级我们用的方法：这里先体验（了解）
            Console.WriteLine("\r\n--------后面高级课程中，使用LINQ实现排序------------");
            var list1 = from c in courseList orderby c.CourseId ascending select c;
            TraversalList1(list1.ToList());

            Console.WriteLine("\r\n--------后面高级课程中，使用扩展方法OrderByDescending实现降序------------");
            var list2 = courseList.OrderByDescending(c => c.CourseId);
            TraversalList1(list2.ToList());

            Console.WriteLine("\r\n--------后面高级课程中，使用扩展方法OrderBy实现升序序------------");
            var list3 = courseList.OrderBy(c => c.ClassHour);
            TraversalList1(list3.ToList());

        }

        #endregion

 #region 自定义排序类：根据需要，添加对应个数的排序类

    /// <summary>
    /// 课程编号升序
    /// </summary>
    class CourseIdASC : IComparer<Course>
    {
        public int Compare(Course x, Course y)
        {
            return x.CourseId.CompareTo(y.CourseId);
        }
    }
    /// <summary>
    /// 课程编号降序
    /// </summary>
    class CourseIdDESC : IComparer<Course>
    {
        public int Compare(Course x, Course y)
        {
            return y.CourseId.CompareTo(x.CourseId);
        }
    }
    /// <summary>
    /// 课时升序
    /// </summary>
    class CourseClassASC : IComparer<Course>
    {
        public int Compare(Course x, Course y)
        {
            return x.ClassHour.CompareTo(y.ClassHour);
        }
    }
    #endregion

对象

namespace s数据模型
{
    public class 学员
    {
        public int 学号 { get; set; }
        public string 名字 { get; set; }
        public int 成绩 { get; set; }
    }
}

集合

 List<学员> lst=new List<学员>();

添加集合对象

            lst.Add(new 学员 { 学号 = 1, 名字 = "同学1", 成绩 = 11 });
            lst.Add(new 学员 { 学号 = 2, 名字 = "同学2", 成绩 = 11 });
            lst.Add(new 学员 { 学号 =3, 名字 = "同学3", 成绩 = 11 });
            lst.Add(new 学员 { 学号 = 4, 名字 = "同学4", 成绩 = 11 });

声明时添加对象

 List<学员> lst=new List<学员>() { st1,st2,st3,st4 } ;

       static s数据模型.学员 st1 = new 学员();
       static s数据模型.学员 st2 = new 学员();
        List<学员> lst=new List<学员>() { st1,st2 } ;

集合 -> 数组

Course[]  coursearray2=courselist.ToArray();

数组 -> 集合

List<Course> courselist3=courseArray2.ToList();

获取集合中对象数量.Count；

升序.Sort();

降序.Reverse();

遍历 foreach（学员 item in lst ）

集合添加数组 .AddRange（s数组）；

判断存在 bool j结果=j集合List.Contains("维修电工")；

指定位置插入对象 .Insert(7,"维修电工");

删除对象 .Remove("维修对象");

.RemoveAt(5）；//删除第5个元素

.Clear(); //删除全部

在C#中，`<T>`表示泛型类型参数，可以在类、方法、接口等中使用。
泛型类型参数可以在运行时确定具体的类型，从而实现代码的复用和类型安全。

以下是一个使用泛型类型参数的示例代码：


using System;

public class Example<T>        // 例子<T>
{
    private T[] arr;

    public Example(int size)
    {
        arr = new T[size];
    }

    public void SetItem(int index, T value)
    {
        arr[index] = value;
    }

    public T GetItem(int index)
    {
        return arr[index];
    }
}

public class Program
{
    public static void Main()
    {
        Example<int> intArray = new Example<int>(3);
        intArray.SetItem(0, 1);
        intArray.SetItem(1, 2);
        intArray.SetItem(2, 3);
        Console.WriteLine(intArray.GetItem(1)); // 输出：2

        Example<string> strArray = new Example<string>(2);
        strArray.SetItem(0, "hello");
        strArray.SetItem(1, "world");
        Console.WriteLine(strArray.GetItem(0)); // 输出：hello
    }
}


在上面的示例代码中，`Example<T>`是一个泛型类，`<T>`表示泛型类型参数。
在`Example<T>`中，我们使用了泛型类型参数`T`来定义一个数组`arr`，
并在构造函数中初始化了这个数组。
`SetItem`和`GetItem`方法分别用于设置和获取数组中的元素，
这两个方法的参数和返回值都是泛型类型参数`T`。

在`Main`方法中，我们分别创建了一个`Example<int>`和一个`Example<string>`对象，
并使用`SetItem`方法设置了数组中的元素，
最后使用`GetItem`方法获取了数组中的元素并输出。

定义：

public class GenericClass<T>     //泛型类
{
    private T genericMemberVariable;     //通用成员变量

    public GenericClass(T value)
    {
        genericMemberVariable = value;     //通用成员变量
    }

    public T GenericMethod(T genericParameter) //通用方法
    {
        Console.WriteLine("Parameter type: {0}, value: {1}", typeof(T).ToString(), genericParameter);
        Console.WriteLine("Return type: {0}, value: {1}", typeof(T).ToString(), genericMemberVariable);

        return genericMemberVariable;
    }
}

实例化：

GenericClass<int> intObj = new GenericClass<int>(10);
intObj.GenericMethod(5);

GenericClass<string> stringObj = new GenericClass<string>("Hello, world!");
stringObj.GenericMethod("Goodbye, world!");