C#笔记——【面向对象基础】（四）集合在OOP中的应用

最新推荐文章于 2023-07-16 16:20:59 发布
最新推荐文章于 2023-07-16 16:20:59 发布
阅读量307 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/forever_008/article/details/104085928
本文详细介绍了C#中的泛型集合List和Dictionary的使用方法，包括初始化、添加、删除、遍历等操作，以及如何对集合中的对象进行排序，涵盖了默认排序和自定义排序的实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

（一）泛型集合List

1）引入

数组的局限性：
  • 数组元素个数是固定的，数组一旦定义，就无法改变元素总数。如果需求变化，则必须修改源码；
  • 如果初始化元素总数非常大，则造成空间浪费；
集合的特点：
  • 根据需要动态增加元素个数，没有限制；

2）泛型集合

1. List泛型集合的特点：
  • 表示泛型，T是Type的简写，表示当前不确定具体类型；
  • 可以根据用户的实际需要，确定当前集合需要存放的数据类型；但是，一旦确定不可改变；
2. List泛型集合的存储结构：

在这里插入图片描述

3. 泛型集合的要求：
  • 使用泛型集合只能添加一种类型的数据，数据取出后 无需强制转换；
4. List使用之前的准备工作：
  • 引入命名空间：System.Collections.Generic;
  • 确定存储类型：
List<Student> students = new List<Student>();
5. 常用方法：
  • 添加元素：Add(<T>)
  • 删除元素：RemoveAt(索引)
6. 常用属性：

元素个数：Count

7. 遍历集合：
foreach (Student stu in students)
{
	Console.WriteLine(stu.StudentName);
}
举例：
namespace Demo
{
    /// <summary>
    /// 学生类
    /// </summary>
    class Student
    {
        public Student() { }
        public Student(int stuId, string stuName)
        {
            this.StudentId = stuId;
            this.StudentName = stuName;
        }
        public int StudentId { get; set; }
        public string StudentName { get; set; }

        public int Age { get; set; }
    }
}

using System;
using System.Collections.Generic;

namespace Demo
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建学员对象
            Student objStu1 = new Student(1001, "小王");
            Student objStu2 = new Student(1002, "小张");
            Student objStu3 = new Student(1003, "小李");
            Student objStu4 = new Student(1004, "小赵");

            //创建list集合
            List<Student> StuList = new List<Student>();
            StuList.Add(objStu1);
            StuList.Add(objStu2);
            StuList.Add(objStu3);
            StuList.Add(objStu4);
            StuList.Add(new Student()
            {
                StudentId = 1006,
                StudentName = "小黑"
            });

            //获取元素个数
            Console.WriteLine("元素总数：{0}", StuList.Count);

            //删除一个元素
            StuList.Remove(objStu1);        //删除一个对象
            StuList.RemoveAt(1);            //删除位置为1的元素

            //插入一个对象
            StuList.Insert(0, new Student(1005, "小白"));

            //遍历集合
            foreach (Student item in StuList)
            {
                Console.WriteLine(item.StudentName + "\t" + item.StudentId);
            }
            
        }
    }
}
8. 集合初始化器：

创建集合对象的时候直接初始化，非常类似于数组；
在这里插入图片描述

（二）泛型集合Dictionary<K, V>的使用

1）关于Dictionary<K, V>泛型集合

  • Dictionary<K,V> 通常称之为字典，<K, V>约束集合中元素类型；
  • 编译时，检查类型约束，无需装箱拆箱操作，与哈希表操作类似；
Dictionary<K, V>的存储结构

在这里插入图片描述

举例：
namespace Demo
{
    /// <summary>
    /// 学生类
    /// </summary>
    class Student
    {
        public Student() { }
        public Student(int stuId, string stuName)
        {
            this.StudentId = stuId;
            this.StudentName = stuName;
        }
        public int StudentId { get; set; }
        public string StudentName { get; set; }

        public int Age { get; set; }
    }
}

using System;
using System.Collections.Generic;

namespace Demo
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建学员对象
            Student objStu1 = new Student(1001, "小王");
            Student objStu2 = new Student(1002, "小张");
            Student objStu3 = new Student(1003, "小李");
            Student objStu4 = new Student(1004, "小赵");

            //创建Dictionary泛型集合
            Dictionary<string, Student> stus = new Dictionary<string, Student>();
            stus.Add("小王", objStu1);
            stus.Add("小张", objStu2);

            //注意这里使用的是中括号
            Console.WriteLine(stus["小王"].StudentId);

            //Dictionary泛型集合遍历（两种方式）
            //第一种
            foreach (string key in stus.Keys)
            {
                Console.WriteLine(key);
            }

            //第二种
            foreach (Student item in stus.Values)
            {
                Console.WriteLine(item.StudentName + "\t" + item.StudentId);
            }
        }
    }
}

（三）集合中对象的排序

1）基本数据类型的排序

基本数据类型可以直接进行排序；使用Sort()方法，对于字符串元素，默认按照字母、拼音升序排列；
在这里插入图片描述

注意：使用Reverse()方法实现反转；
List<string> list = new List<string>()
            {
                "小王","小张","小孙","小李","小赵"
            };
            foreach (string item in list)
            {
                Console.WriteLine(item);
            }


            Console.WriteLine("--------排序后--------");

            list.Sort();            //排序
            list.Reverse();         //排序后反转
            foreach(string item in list)
            {
                Console.WriteLine(item);
            }

2）对象的排序

集合不能简单的使用Sort()排序；
原因：找不到排序的属性；

注意：一个类前面加 “I” 表示这个类的接口；

将需要排序的对象实现泛型接口 IComparable< T> 按照学号排序
在这里插入图片描述

注意：return this.StuId.CompareTo(other.StuId)实现升序排序（按照学号）
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Text;

namespace Demo
{
    /// <summary>
    /// 学生类
    /// </summary>
    class Student:IComparable<Student>
    {
        public Student() {}
        public Student(int stuId, string stuName)
        {
            this.StudentId = stuId;
            this.StudentName = stuName;
        }
        public int StudentId { get; set; }
        public string StudentName { get; set; }

        public int Age { get; set; }
        
        /// <summary>
        /// 接口的实现方法
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public int CompareTo([AllowNull] Student other)
        {
            //下面代码实现升序排序；this和other交换位置实现降序
            return this.StudentId.CompareTo(other.StudentId);
        }
    }
}


using System;
using System.Collections.Generic;

namespace Demo
{
    class Program
    {
        static void Main(string[] args)
        {
            Student objStu1 = new Student(1001, "小王");
            Student objStu2 = new Student(1002, "小张");
            Student objStu3 = new Student(1003, "小赵");
            Student objStu4 = new Student(1004, "小孙 ");
            List<Student> Stus = new List<Student>() { objStu1, objStu2, objStu3, objStu4 };

            Stus.Sort();

            foreach (Student item in Stus)
            {
                Console.WriteLine(item.StudentName);
            }

        }
    }
}

3）对象排序------根据需要添加排序方法（动态）

默认排序只能有一种
接口本身也是一种数据类型；类也是数据类型；

注意：
  • 默认排序只能有一种；
  • 根据需要添加排序类,C#中允许一个类文件对应若干具体的类；
  • 需要几种排序就增加几个排序类；
  • 当需要多种排序的时候可以不使用默认排序；下面的类排序完全可以替代默认排序；
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Text;

namespace Demo
{
    /// <summary>
    /// 学生类
    /// </summary>
    class Student:IComparable<Student> //默认排序只能有一种
    {
        public Student() {}
        public Student(int stuId, string stuName)
        {
            this.StudentId = stuId;
            this.StudentName = stuName;
        }
        public int StudentId { get; set; }
        public string StudentName { get; set; }

        public int Age { get; set; }
        
        /// <summary>
        /// 接口的实现方法
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public int CompareTo([AllowNull] Student other)
        {
            //下面代码实现升序排序；this和other交换位置实现降序
            return this.StudentId.CompareTo(other.StudentId);
        }
    }

    //根据需要添加排序类,C#中允许一个类文件对应若干具体的类
    //需要几种排序就增加几个排序类
    //添加排序类并且分别实现排序接口
    class StuNameASC : IComparer<Student>       //实现这个接口
    {
        public int Compare([AllowNull] Student x, [AllowNull] Student y)
        {
            return x.StudentName.CompareTo(y.StudentName);
        }
    }
    class StuNameDESC : IComparer<Student>
    {
        public int Compare([AllowNull] Student x, [AllowNull] Student y)
        {
            return y.StudentName.CompareTo(x.StudentName);
        }
    }
    class AgeASC : IComparer<Student>
    {
        public int Compare([AllowNull] Student x, [AllowNull] Student y)
        {
            return x.Age.CompareTo(y.Age);
        }
    }

    class AgeDESC : IComparer<Student>
    {
        public int Compare([AllowNull] Student x, [AllowNull] Student y)
        {
            return y.Age.CompareTo(x.Age);
        }
    }
}


using System;
using System.Collections.Generic;

namespace Demo
{
    class Program
    {

        static void Main(string[] args)
        {
            Student objStu1 = new Student() { StudentId = 1001, StudentName = "小李", Age = 20 };
            Student objStu2 = new Student() { StudentId = 1002, StudentName = "张红", Age = 27 };
            Student objStu3 = new Student() { StudentId = 1003, StudentName = "汪洋", Age = 22 };
            Student objStu4 = new Student() { StudentId = 1004, StudentName = "郝鑫", Age = 17 };
            List<Student> Stus = new List<Student>() { objStu1, objStu2, objStu3, objStu4 };
            
            //默认排序
            Stus.Sort();
            Console.WriteLine("-------默认排序--------");
            foreach (Student item in Stus)
            {
                Console.WriteLine(item.StudentId + "\t" + item.StudentName + "\t"+ item.Age);
            }
            Console.WriteLine("-------按照姓名升序-------");
            Stus.Sort(new StuNameASC());        //里面必须是接口实现类的对象
            foreach (Student item in Stus)
            {
                Console.WriteLine(item.StudentId + "\t" + item.StudentName + "\t" + item.Age);
            }
            Console.WriteLine("-------按照姓名降序-------");
            Stus.Sort(new StuNameDESC());
            foreach (Student item in Stus)
            {
                Console.WriteLine(item.StudentId + "\t" + item.StudentName + "\t" + item.Age);
            }
            Console.WriteLine("-------按照年龄升序-------");
            Stus.Sort(new AgeASC());
            foreach (Student item in Stus)
            {
                Console.WriteLine(item.StudentId + "\t" + item.StudentName + "\t" + item.Age);
            }
            Console.WriteLine("-------按照年龄降序-------");
            Stus.Sort(new AgeDESC());
            foreach (Student item in Stus)
            {
                Console.WriteLine(item.StudentId + "\t" + item.StudentName + "\t" + item.Age);
            }

        }
    }
}
其实上面是多态的一种应用；多态有两种实现方式
  1. 基于继承；（1）将父类作为方法的参数，实际上传递的是父类的子类对象；（2）将父类类型作为方法的返回值；
  2. 基于接口；（1）将接口作为方法的参数，传入接口的实现类对象；（2）将接口作为返回值；

4）Sort方法总结

List集合的Sort方法总共有四种：
  1. Sort() ：使用默认比较器IComparable<> 排序对象；【无参数】
  2. Sort(ICompare<> compare) : 将实现比较器接口的对象作为参数；【典型多态形式】
    …
集合排序总结：
  • 如果是基本数据类型元素，可以直接进行排序；
  • 如果是对象类型元素：
    1. 当排序只有一种的时候，可以使用默认比较器IComparable<>，在类中实现接口即可；
    2. 当需要多种排序的时候，需要添加对应排序类，并给每一个排序类实现比较器接口ICompare<> 来完成不同排序方法；
【狂神说笔记——23种设计模式】
weixin_46055348的博客
06-28 1415
【狂神说笔记——23种设计模式】
C#读书笔记
源流
12-21 2881
此书为《C#入门经典（C#6.0&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;Visual Studio 2015）（第七版）》，购于2016年底 购买此书是因为工作需要接触部分C#代码，而那时我对面向对象编程的概念认识尚浅，工作接触的代码又比较庞大，于是寄希望于此书，希望能快速上手C#，了解基本的知识，避免闹笑话。 刚拿到这本书时，我急于求成，加上书前半部分的内容也很入门（读书时跳过了），约2、3周便利用闲暇时
C#OOP笔记大全
11-18
1.深入.NET框架 .NET Framework 框架包括两个组件 CLR : Common Language Runtime 公共语言运行时 1.CTS Common Type System 通用类型系统 2.CLS Common Language Specification 公共语言规范 FCL : Framework Class Libary 框架类库
C# 集合在OOP中的应用
Economic_shark的博客
05-22 548
元素自动变化的集合List<T> List<T>泛型集合的特点<T>表示泛型,T是TYPEd的简写，表示当前不确定类型。 可以根据用户实际需要，确定当前集合需要存放的数据类型，一旦确定不可改变。 使用Add方法可以随意添加元素，没有个数限制。 使用Remove方法可以删除指定元素，元素删除后索引自动调整。 通过索引访问元素。 List<T>泛型集合的存储结构索引 0 - 1-2-3-4……. Li
【C#】C#面向对象OOP编程
阿黄的博客
10-28 5020
文章转载：http://liuguozhu.blog.51cto.com/9142031/1831120 C#的OOP（面向对象）编程是C#编程语言中最为精华的部分，如果没有学习C#的OOP部分，则可以认为就没有学习过C#。 C#语言是2001年，微软推出".Net战略"时，专门订制的一门编程语言，其基本的思想就是仿照JAVA语言的虚拟机原理，开发出“受托管”的中间语言。（即：C#编译后不是
笔记：C#_OOP_基础入门：简明指南
HadesNyx
07-24 234
OOP：简明指南 Object Oriented Programming 目录 OOP三大：核心特征封装继承多态 OOP 面向对象程序设计（Object Oriented Programming，OOP） 是一种计算机编程架构。 核心技术封装、继承、多态。 必须掌握！ OOP 是C#编程语言中的 核心 如果没有学习C#的OOP部分，则可以认为就没有学习过C#。 To Map 三大：核心特征 封装 封装 就是把 客观事物 封装成 抽象的类， 并..
c#学习笔记-OOP技术
wdan4290的专栏
05-06 1086
在学习OOP技术时，主要讨论接口、继承、多态性、对象之间的关系、运算符重载、事件、和引用类型和值类型。接口：接口是把隐含的公共方法和属性组合起来，以封闭特定功能的一个集合。继承：任何类都可以从另一个类中继承，一个类拥有它继承类的所有成员，在OOP中，被继承的类称为父类（也称为基类，有时也被称为超类）。例如：                                              
C#学习笔记（六）——面向对象编程简介
KEVINZHAO124517的博客
10-05 161
一、面向对象编程的含义 * 是一种模块化编程方法，使代码的重用性大大的增加。 * oop技术使得项目的设计阶段需要的精力大大的增加，但是一旦对某种类型的数据表达方式达成一致，这种表达方式就可以沿用下去，直到这款应用的生命周期结束。 1、对象就是OOP应用程序的一个组成部分，这个组成部件封装了部分应用程序，这部分程序可以是一个过程、一些数据或一些更抽象的实体。对象的类型在OO...
CSharpAdvancedModule_OOP:SoftUni
03-13
本资源包，名为"CSharpAdvancedModule_OOP:SoftUni"，显然是针对SoftUni（软件大学）的C#高级模块——面向对象编程的学习资料。在这个模块中，你将深入理解并掌握C#中面向对象编程的核心概念和实践技巧。 面向对象...
Java基础笔记（无限整合更新）
白三叶的博客
07-16 396
’ 表示单引号字符，Java代码中单引号表示字符的开始和结来，如果直接写单引字符（'），程序会认为前两个是一对，会报错，因此需要使用转义符“\’”。\" 表示双引号字符，Java代码中双引号表示字符串的开始和结来，包含在字符串中的双引号需要转义，比如（hesays,\”thankyou\”.）。\ 标识反斜杠字符，由于在Java代码中的反斜杠（\）是转义字符，因此需要表示字面意义上的\，就需要使用双反斜杠（\）。Java以下的字符都有特殊意义，无法直接表示，所以用反斜杠加上另外一个字符来表示。
C# OOP上机练习与课后作业
02-08
使用C#实现面向对象编程上机练习与课后作业
Code in C# and build 3D games with Unity读书笔记
橙飒的博客
08-14 492
Code in C# and build 3D games with Unity读书笔记 变量 •从概念上讲，变量是编程的最基本单位，就好比原子，一切都基于变量，没有变量，程序就可能存在。 •从技术角度看，变量是用于存储指定值的一小部分计算机内存。变量会跟踪信息的存储位置（称为内存地址）以及值与类型（例如，数字、单词、列表）。 •实际上，变量就相当于容器。可以随意创建新变量，然后赋值，移动位置，并在需要的位置引用。即便空的变量也是有用的。 变量需要满足以下基本要求： •需要指定变量存储的数据类型 •变量必需
第4章 在C#中使用类和对象
ASP和PHP工作经验
08-28 1332
第4章 在C#中使用类和对象4.1 关于类所有的C#程序都由类组成。Windows窗体就是类，它派生于基本的Form类。我们即将要编写的其他所有程序都是完全由类组成的。C#没有全局数据或共享数据的概念，因为它们不是类的组成部分。简单的说，类就是将一系列公有和私有方法以及私有数据组合在一个命名的逻辑单元中。通常将一个类放在一个单独文件里，尽管这不是硬性的规定。一个类创建后，它就不仅仅
C#学习笔记05：面向对象编程OOP
路上的点滴
07-29 1138
1、什么是类与对象？ 类是用来描述现实世界事务，事务一般有特征（属性）、动作（行为）。如学生（学号、姓名、院系、专业、…；注册、缴费、选课等）；类是具有相同特征与行为的一类事务（对象）整体。类是抽象的。 对象是类中的一个实例，是具体的。如学生（2010002，张三、数学系、信息与计算专业等）。 类是解决一个应该是什么的问题。对象是解决具体是什么的问题。 2、C#类的定义    class
C#基础之面向对象(OOP)三大特征
Freedomswl的博客
07-16 303
我们说C#是一门完全面向对象的编程语言，它的核心就是面向对象，那我们今天就来说说面向对象的三大特征：封装、继承和多态。 封装 封装是最容易理解的，我们在之前也用到过类的封装 封装就是通过访问修饰符把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装可以隐藏实现细节，使得代码模块化。 继承 类可以从其他类中继承。这是通过以下方式实现的：在声明类时，在类名称后放置一个冒号，然后在冒号后指定要从中继承的类（即基类）。例如： public class A { public A() { } } p
C# 中的IComparable和IComparer
冯辉
01-01 463
前言 在开发过程中经常会遇到比较排序的问题，比如说对集合数组的排序等情况，基本类型都提供了默认的比较算法，如string提供了按字母进行排序，而int整数则是根据整数大小进行排序.但是在引用类型中(具有多个字段)，那么这个排序当然也是取决于我们特定的值。 IComparable接口 该接口由其值可以排序或排序的类型实现，并提供强类型的比较方法以对泛型集合对象的成员进行排序，例如数字可以大于...
C#进阶之LINQ（2）Linq查询语句与查询方法
forever_008的博客
02-03 8595
（一）Linq基础 1）Linq解决的问题 面向对象编程语言与数据访问方法长期分离，以嵌入式的方式开发，例如： 编程语言中的数据类型与数据库中的数据类型形成两套体系，如：C#中的字符串string 在SQL中使用NVarchar/ Varchar/ Char来表示； SQL和XML都有各自的查询语言，而对象没有自己的查询语言，如要从List<>集合或者数组中找到符合要求的元素，非常...
C#：System.NullReferenceException：未将对象引用设置到对象的实例
forever_008的博客
02-18 7735
问题原因： 对象在使用之前未进行初始化； 对象为null；【由于某种原因，对象为null，这时候调用会出现这个问题】 如果有补充，请留言
C#基础之SQL Server（2）创建数据库与数据表
forever_008的博客
02-01 6592
（一）数据库的创建 1）数据库分类 系统数据库和用户数据库；通过查看对象资源管理器来区分数据库类型； 注意：master数据库不要动，这个是数据库的数据库；我们主要学习用户数据库； 2）用户数据库文件组成 数据库物理文件的组成：数据库文件 + 日志文件； 注意：一个数据库有且只有一个mdf，但是可以有多个 ndf 和 ldf （但是至少一个） 3）创建数据库 创建一个主数据文件和一个日...
C#与面向对象基础教程：从入门到精通
"C#程序设计语言与面向对象基础精简教程" 这是一份关于C#程序设计语言和面向对象基础的教程，旨在为学习ASP.NET开发技术的学生提供必要的基础知识。教程由金旭亮著作的《.NET2.0面向对象编程揭秘》一书提炼而来，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值