C# List<T>自定义排序方法

最新推荐文章于 2024-06-02 22:29:24 发布
最新推荐文章于 2024-06-02 22:29:24 发布
阅读量757 收藏
点赞数
原文地址：http://happyboy200032.blog.163.com/blog/static/469031132011111654345686/
（以下内容均为转载）
//C#范型List类的Sort方法有四种形式，分别是
//1，不带有任何参数的Sort方法----Sort()；
//2，带有比较器参数的Sort方法 ----Sort(IComparer<T>)
//3，带有比较代理方法参数的Sort方法----Sort(Comparison<(Of <(T>)>))
//4，带有比较起参数，可以指定排序范围的Sort方法----Sort(Int32, Int32 IComparer(T))

//首先介绍第一种方法，使用这种方法不是对List中的任何元素对象都可以进行排序，List中的元素对象必须继承IComparable接口，并且要实现IComparable接口中的CompareTo()方法，在CompareTo()方法中要自己实现对象的比较规则。详细可以参照如下代码：

using System;
using System.Collections.Generic;
using System.Text;

namespace Comparer.SortObject
{
    /// <summary>
    /// List<>.Sort()的测试对象，类自己实现IComparable接口，
    /// 当需要对List中的SortTestObj1对象进行排序时，直接调用
    /// Sort()方法就可以了。
    /// </summary>
    public class SortTestObj1:IComparable
    {
        #region 类字段定义
        private int code;
        private string name;
        #endregion

        public SortTestObj1()
        {
        }

        #region 属性定义
        public int Code
        {
            set { this.code = value; }
            get { return this.code; }
        }
        public string Name
        {
            set { this.name = value; }
            get { return this.name; }
        }
        #endregion

        #region 实现比较接口的CompareTo方法
        public int CompareTo(object obj)
        {
            int res = 0;
            try
            {
                SortTestObj1 sObj = (SortTestObj1)obj;
                if (this.code > sObj.code)
                {
                    res = 1;
                }
                else if (this.code < sObj.code)
                {
                    res = -1;
                }
            }
            catch (Exception ex)
            {
                throw new Exception("比较异常", ex.InnerException);
            }
            return res;
        }
        #endregion
    }
}

//第二种带有比较器参数的Sort方法，List中的元素对象不需要继承IComparable接口，但需要额外创建一个对象的比较器，下面的代码中的SortTestObj2类是准备要保存到范型List中的对象，SortTestObj2Camparer 类则是SortTestObj2类的比较器，这个比较起必须继承IComparer<T>接口，并且实现接口中的Compare()方法。详细做法可参照下面的代码。
//SortTestObj2类

using System;
using System.Collections.Generic;
using System.Text;

namespace Comparer.SortObject
{
    /// <summary>
    /// List<>.Sort(IComparer<(Of <(T>)>))的测试对象，类自己没有实现IComparable接口，
    /// 当需要对List中的SortTestObj2对象进行排序时，需要实例化一个SortTestObj2Camparer
    /// 类型的比较器,在比较器中指明排序类型(按Code排序还是按Name排序)，然后调用
    /// xxxLst.Sort(SortTestObj2Camparer)方法就可以了。
    /// </summary>
    public class SortTestObj2
    {
        #region 类字段定义
        private int code;
        private string name;
        #endregion
        public SortTestObj2()
        {
        }

        #region 属性定义
        public int Code
        {
            set { this.code = value; }
            get { return this.code; }
        }
        public string Name
        {
            set { this.name = value; }
            get { return this.name; }
        }
        #endregion
    }
}

//SortTestObj2Camparer类

using System;
using System.Collections.Generic;
using System.Text;
using Comparer.SortObject;

namespace Comparer.Camparer
{
    [Flags]
    //排序类型定义
    public enum Obj2SortKind { Code, Name }
    /// <summary>
    /// SortTestObj2类排序用的比较器，继承IComparer<>接口，
    /// 实现接口中的Compare()方法。
    /// </summary>
    public class SortTestObj2Camparer : IComparer<SortTestObj2>
    {
        #region 类字段定义
        private Obj2SortKind sortKind;
        #endregion

        #region 构造器
        public SortTestObj2Camparer(Obj2SortKind sk)
        {
            this.sortKind = sk;
        }
        #endregion

        #region IComparer接口比较方法的实现
        public int Compare(SortTestObj2 obj1, SortTestObj2 obj2)
        {
            int res = 0;
            if ((obj1 == null) && (obj2 == null))
            {
                return 0;
            }
            else if((obj1 != null) && (obj2 == null))
            {
                return 1;
            }
            else if ((obj1 == null) && (obj2 != null))
            {
                return -1;
            }
 
            if (sortKind == Obj2SortKind.Code)
            {
                if (obj1.Code > obj2.Code)
                {
                    res = 1;
                }
                else if (obj1.Code < obj2.Code)
                {
                    res = -1;
                }
            }
            else if(sortKind == Obj2SortKind.Name)
            {
                res = obj1.Name.CompareTo(obj2.Name);
            }
            return res;
        }
        #endregion
    }
}

//第三种方法需要编写一个对象排序比较的方法，对List中的元素对象没有特殊的要求，但在比较方法中需要实现对象比较规则，这个方法实现后，就可以把这方名字作为参数委托给List的Sort方法，Sort方法在排序时会执行这个方法对List中的对象进行比较，详细可参照下面的代码。对List中元素我们还使用上面的SortTestObj2类对象。
static void Main(string[] args)
{
    //利用代理方法进行排序
    DelegateSort();
}
 
//Sort(Comparison<(Of <(T>)>))方法排序,这中方法需要先编写一个对象比较的方法,然后
//把这个比较方法委托给List的Sort方法。
//对象比较的方法
private static int SortTestObj2Compare(SortTestObj2 obj1, SortTestObj2 obj2)
{
     int res = 0;
     if ((obj1 == null) && (obj2 == null))
     {
         return 0;
     }
     else if ((obj1 != null) && (obj2 == null))
     {
         return 1;
     }
     else if ((obj1 == null) && (obj2 != null))
     {
         return -1;
     }
     if (obj1.Code > obj2.Code)
     {
         res = 1;
     }
     else if (obj1.Code < obj2.Code)
     {
         res = -1;
     }
     return res;
 }

 //List的委托排序
 private static void DelegateSort()
 {
     List<SortTestObj2> objLst = new List<SortTestObj2>();
     SortTestObj2 obj1 = new SortTestObj2();
     obj1.Code = 3;
     obj1.Name = "TestObj1";
     objLst.Add(obj1);
     SortTestObj2 obj2 = new SortTestObj2();
     obj2.Code = 2;
     obj2.Name = "TestObj2";
     objLst.Add(obj2);
     SortTestObj2 obj3 = new SortTestObj2();
     obj3.Code = 4;
     obj3.Name = "TestObj4";
     objLst.Add(obj3);
     SortTestObj2 obj4 = new SortTestObj2();
     obj4.Code = 1;
     obj4.Name = "TestObj3";
     objLst.Add(obj4);
     SortTestObj2 obj5 = new SortTestObj2();
     obj5.Code = 6;
     obj5.Name = "TestObj6";
     objLst.Add(obj5);
     objLst.Sort(SortTestObj2Compare);
     Console.WriteLine("委托方法排序的结果");
     foreach (SortTestObj2 item in objLst)
     {
         Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
     }
 }
Monalie
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C# List 排序
04-15
NULL 博文链接：https://overloving.iteye.com/blog/1751131
C#使用IComparer自定义List类实现排序的方法
09-03
当需要对List<T>中的元素进行自定义排序时，可以利用IComparer接口。IComparer是一个抽象接口，提供了比较两个对象的方式，使得我们可以根据特定的规则进行排序。本篇将详细介绍如何在C#中使用IComparer自定义List类...
c# 自定义List排序
刘培玉-大王
01-29 1450
自定义List排序sort返回排序的几种实现方式List.Sort(Comparison comparison)List.Sort(IComparer Comparer) 刚使用sort排序又又又又又忘了，返回1（大于0即可），-1（小于0即可）是怎么排序了，果然是年纪大了。 sort返回 void Start() { List<int> tempList = new List<int>() {2,3,9,3,4 }; tempList.So
【C#】自定义List排序规则的两种方式
最新发布
qq_63231615的博客
06-02 681
1.系统排序原理 2.方式一：调用接口并重写 3.方式二：传排序规则函数做参数
C#list自定义排序
KIIOU的博客
08-07 1170
C# List自定义排序 List类型数据可以借助Lambda表达式来进行自定义排序。 如List<double[]>类型数据，需要按照double数组的第i个数据进行排序，代码如下： List<double[]> listData = new List<double[]>(); listData = listData.OrderBy(t => t[i]).ToList();//升序 listData = listData.OrderByDescending(t =
C＃List自定义排序
09-17 1232
List word_info_pre_line = new List(); class words_info //自字义类型 { public string word = null; public double rank = 0.0; public int TF = 0; } word_info_pre_line
C# 使用IComparer自定义List类的排序方案
起个名字好难啊
08-26 2206
List类中不带参数的Sort函数可以用来为List类中的元素排序，但如果List类中的元素类型本身不能直接进行比较（如自定义的struct和很多class），或是希望采用更加灵活的自定义比较方式，可以通过继承了IComparer接口的函数来解决。 代码示例如下： 1）声明一个类 /// /// 人物类 /// public class Person { public strin
C# List OrderBy 动态多字段排序
07-01
在C#编程中，`List<T>` 是一个常用的集合类，用于存储同类型的元素序列。在处理这些数据时，我们经常需要对它们进行排序。`OrderBy` 方法是 LINQ（Language Integrated Query） 提供的一个非常方便的排序工具，它...
C#通过IComparable实现ListT.sort()排序
09-04
下面我们将详细介绍如何使用 `IComparable<T>` 实现 `List<T>.Sort()` 的自定义排序。 首先，我们创建一个自定义类，比如 `Person`，并让它继承 `IComparable<Person>` 接口。在这个例子中，`Person` 类包含两个...
C#基础教程之IComparable用法，实现List<T>.sort()排序
09-03
在C#编程语言中，`List<T>.Sort()` 方法是用于对列表中的元素进行排序的一个非常重要的功能。这个方法依赖于元素类型是否实现了 `IComparable<T>` 接口或者提供了自定义的比较器。在本教程中，我们将深入探讨如何...
C#List的排序和自定义类的排序
乌托托的博客
06-02 700
List排序自定义类的排序使用接口使用委托lambda表达式 完整代码
c# List类排序方法
09-14
List类几种排序方法比较灵活 可以根据自己的需要 选用合适的方法
C# IList多字段排序
11-12
对实现IList接口的类进行排序，支持多字段排序。
C#List集合实现对对象自定义排序
Boting的博客
04-07 1295
List排序 List集合对数字或者字母排序可能并不难，不够要是对象排序，就要考虑用对象的哪个字段进行排序。list提供了一个Sort（）方法，List已经可以对内置类型（比如：int、double、string）排序，通过对接口的实现也可以定制自己的类排序。可以通过IComparable<T>接口或者IComparer<T>接口实现。 通过IComparer&lt...
c# list 自定义排序
papaya的博客
06-05 3164
using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace l结构体的list排序{ class Program { class Node { public int nID; public int nVal...
C# 自定义List sort函数 排序
瞬Future
09-02 504
namespace TestCode1 { class IntSort : IComparer<int> { public int Compare(int x, int y) { if (x == y) return 0; else if (x < y) return -1; else return 1; } } class Progr.
c# 自定义排序
ScutKevinYzy的博客
09-18 976
class Program { static void Main(string[] args) { Random random = new Random(); ClassA[] arr = new ClassA[10];//数组还有IEnumerator是没有实现Sort的，List实现了 ...
C# 集合自定义排序 list.Sort ~~(￣▽￣)"~~！
Roadlun的博客
02-29 514
这个语法很恶心，经常忘记，网上找半天才能找到。一怒之下写道博客里，随时翻阅。 moveCells.Sort((a, b) => { if (Mathf.Abs(selfCell.x-a.x)<Mathf.Abs(selfCell.x-b.x)) { ...
List怎么自定义排序
kxj19980524的博客
03-13 2234
方式一,集合里面的元素实现Comparable接口 sort方法要求集合元素必须实现Comparable接口，该接口用于规定实现类是可以比较的。其有一个抽象方法是用来定义比较大小的规则。我们想使用sort方法排序集合，但是该方法要求我们的集合元素必须实现Comparable接口并且定义比较规则，这种我们想使用某个功能，而它要求我们修改程序的现象称为“侵入性”。修改的代码越多，侵入性越强，越不...
写个 c# list<int> 的排序
07-12
在 C# 中，可以使用 `List<int>` 类型的 `Sort()` 方法对整数列表进行排序。下面是一个示例代码： ```csharp using System; using System.Collections.Generic; class Program { static void Main(string[] args)...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值