C# 集合排序



一个集合可否排序，要看系统知不知道排序的规则，像内建的系统类型，int ,string,short,decimal这些，系统知道怎么排序，而如果一个集合里面放置的是自定义类型，比如自己定义了一个Product类型，要把它排序，系统是不知道怎么办的。

那么，如何告知系统排序的规则呢？有以下几种方法：

1：对类实现IComparable接口，示例如下：

代码1

 1 using System;
 2  using System.Collections.Generic;
 3  using System.Linq;
 4  using System.Text;
 5
 6  namespace SortTeset
 7 {
 8     class Product :IComparable
 9     {
10         public string Name { get; private set; }
11         public decimal Price { get; private set; }
12
13         public Product(string name, decimal price)
14         {
15             Name = name;
16             Price = price;
17         }
18
19         public Product() { }
20
21         public static List<Product> GetSampleProduct()
22         {
23             return new List<Product>
24             {
25                 new Product{Name="Watch",Price=12345.56m},
26                 new Product{Name="Knife",Price=224.50m},
27                 new Product{Name="Rope",Price=12.50m},
28                 new Product{Name="ETorch",Price=58.5m}
29             };
30         }
31
32         public override string ToString()
33         {
34             return string.Format("{0} : {1}", Name, Price);
35         }
36
37         int IComparable.CompareTo(object obj)
38         {
39             Product temp = (Product)obj;
40             return this.Name.CompareTo(temp.Name);
41         }
42
43     }
44
45     class Program
46     {
47         static void Main(string[] args)
48         {
49             List<Product> ProductSample = Product.GetSampleProduct();
50             foreach (Product tmp in ProductSample)
51             {
52                 Console.WriteLine(tmp);
53             }
54
55             Console.WriteLine();
56
57             ProductSample.Sort();
58
59             foreach (Product tmp in ProductSample)
60             {
61                 Console.WriteLine(tmp);
62             }
63         }
64     }
65 }

其中最主要的是这句：

　　class Product :IComparable

跟这句：

　　  int IComparable.CompareTo(object obj)

{

Product temp = (Product)obj;

return this.Name.CompareTo(temp.Name);

}

就是实现了IComparable.CompareTo()这个方法。然后就可以直接调用 SomeProductList.Sort();方法来进行排序。

2：指定IComparer  类的对象。

代码3

 1 using System;
 2  using System.Collections.Generic;
 3  using System.Linq;
 4  using System.Text;
 5
 6  namespace SortTeset2
 7 {
 8     class Product
 9     {
10         public string Name { get; private set; }
11         public decimal Price { get; private set; }
12
13         public Product(string name, decimal price)
14         {
15             Name = name;
16             Price = price;
17         }
18
19         public Product() { }
20
21         public static List<Product> GetSampleProduct()
22         {
23             return new List<Product>
24             {
25                 new Product{Name="Watch",Price=12345.56m},
26                 new Product{Name="Knife",Price=224.50m},
27                 new Product{Name="Rope",Price=12.50m},
28                 new Product{Name="ETorch",Price=58.5m}
29             };
30         }
31
32         public override string ToString()
33         {
34             return string.Format("{0} : {1}", Name, Price);
35         }
36     }
37
38
39     class ProductNameComparer : IComparer<Product>
40     {
41         public int Compare(Product first, Product second)
42         {
43             return first.Name.CompareTo(second.Name);
44         }
45     }
46
47     class Program
48     {
49         static void Main(string[] args)
50         {
51             List<Product> ProductSample = Product.GetSampleProduct();
52             foreach (Product tmp in ProductSample)
53             {
54                 Console.WriteLine(tmp);
55             }
56
57             Console.WriteLine();
58
59             ProductSample.Sort(new ProductNameComparer());
60
61             foreach (Product tmp in ProductSample)
62             {
63                 Console.WriteLine(tmp);
64             }
65         }
66     }
67 }
68  

这儿我们新定义了一个类：ProductNameComparer，这个类实现了泛型接口：IComparer<Product>，然后在

ProductSample.Sort(new ProductNameComparer());

语句中我们提供了一个比较器对象。

这种方法看上去不如直接实现ICompareable接口来得简洁。

这种方法可以用匿名方法进行改进：

代码4

 1 using System;
 2  using System.Collections.Generic;
 3  using System.Linq;
 4  using System.Text;
 5
 6  namespace SortTeset3
 7 {
 8     class Product
 9     {
10         public string Name { get; private set; }
11         public decimal Price { get; private set; }
12
13         public Product(string name, decimal price)
14         {
15             Name = name;
16             Price = price;
17         }
18
19         public Product() { }
20
21         public static List<Product> GetSampleProduct()
22         {
23             return new List<Product>
24             {
25                 new Product{Name="Watch",Price=12345.56m},
26                 new Product{Name="Knife",Price=224.50m},
27                 new Product{Name="Rope",Price=12.50m},
28                 new Product{Name="ETorch",Price=58.5m}
29             };
30         }
31
32         public override string ToString()
33         {
34             return string.Format("{0} : {1}", Name, Price);
35         }
36     }
37
38     class Program
39     {
40         static void Main(string[] args)
41         {
42             List<Product> ProductSample = Product.GetSampleProduct();
43             foreach (Product tmp in ProductSample)
44             {
45                 Console.WriteLine(tmp);
46             }
47
48             Console.WriteLine();
49
50             ProductSample.Sort(delegate(Product first, Product second)
51             {
52                 return first.Name.CompareTo(second.Name);
53             });
54
55             foreach (Product tmp in ProductSample)
56             {
57                 Console.WriteLine(tmp);
58             }
59         }
60     }
61 }
62  

这一次，不用定义那个类，然后使用它的方法了，而是直接填充delegate接口。

这种方法还可以进一步用Lambda表达式改进，如下：

代码5

 1 using System;
 2  using System.Collections.Generic;
 3  using System.Linq;
 4  using System.Text;
 5
 6  namespace SortTeset4
 7 {
 8     class Product
 9     {
10         public string Name { get; private set; }
11         public decimal Price { get; private set; }
12
13         public Product(string name, decimal price)
14         {
15             Name = name;
16             Price = price;
17         }
18
19         public Product() { }
20
21         public static List<Product> GetSampleProduct()
22         {
23             return new List<Product>
24             {
25                 new Product{Name="Watch",Price=12345.56m},
26                 new Product{Name="Knife",Price=224.50m},
27                 new Product{Name="Rope",Price=12.50m},
28                 new Product{Name="ETorch",Price=58.5m}
29             };
30         }
31
32         public override string ToString()
33         {
34             return string.Format("{0} : {1}", Name, Price);
35         }
36     }
37
38     class Program
39     {
40         static void Main(string[] args)
41         {
42             List<Product> ProductSample = Product.GetSampleProduct();
43             foreach (Product tmp in ProductSample)
44             {
45                 Console.WriteLine(tmp);
46             }
47
48             Console.WriteLine();
49
50             ProductSample.Sort((first,second)=>first.Name.CompareTo(second.Name));
51
52             foreach (Product tmp in ProductSample)
53             {
54                 Console.WriteLine(tmp);
55             }
56         }
57     }
58 }
59  

变态的是，还可以进一步改进，使用扩展方法，如下：

代码6

 1 using System;
 2  using System.Collections.Generic;
 3  using System.Linq;
 4  using System.Text;
 5
 6  namespace SortTeset5
 7 {
 8     class Product
 9     {
10         public string Name { get; private set; }
11         public decimal Price { get; private set; }
12
13         public Product(string name, decimal price)
14         {
15             Name = name;
16             Price = price;
17         }
18
19         public Product() { }
20
21         public static List<Product> GetSampleProduct()
22         {
23             return new List<Product>
24             {
25                 new Product{Name="Watch",Price=12345.56m},
26                 new Product{Name="Knife",Price=224.50m},
27                 new Product{Name="Rope",Price=12.50m},
28                 new Product{Name="ETorch",Price=58.5m}
29             };
30         }
31
32         public override string ToString()
33         {
34             return string.Format("{0} : {1}", Name, Price);
35         }
36     }
37
38     class Program
39     {
40         static void Main(string[] args)
41         {
42             List<Product> ProductSample = Product.GetSampleProduct();
43             foreach (Product tmp in ProductSample)
44             {
45                 Console.WriteLine(tmp);
46             }
47
48             Console.WriteLine();
49
50             foreach (Product tmp in ProductSample.OrderBy(p=>p.Name))
51             {
52                 Console.WriteLine(tmp);
53             }
54         }
55     }
56 }

“这里似乎调用了一个OrderBy方法，但查阅一下MSDN，就会发现这个方法在List<Product>中根本不存在。之所以能调用它，是由于存在一个扩展方法。这里实际不再是"原地"对列表进行排序，而只是按特定的顺序获取列表的内容。有的时候，你需要更改实际的列表；但有的时候，没有任何副作用的排序显得更"善解人意"。重点在于，现在的写法更简洁，可读性更好（当然是在你理解了语法之后）。我们的想法是"列表按名称排序"，现在的代码正是这样做的。并不是"列表通过将一个产品的名称与另一个产品的名称进行比较来排序"，就像C#
2代码所做的那样。也不是使用知道如何将一个产品与另一个产品进行比较的另一个类型的实例来按名称排序。这种简化的表达方式是C# 3的核心优势之一。既然单独的数据查询和操作是如此的简单，那么在执行更大规模的数据处理时，仍然可以保持代码的简洁性和可读性，这进而鼓励开发者以一种"以数据为中心"的方式来观察世界。”

最后这两步的语法，绝对是一个会用其它语言比如C/C++,VB的人所无法明白的，C#进化速度真是快。。。。。。。

时间： 2024-10-12 15:54:50

C# 集合排序的相关文章

Java-集合--Java集合排序

Java集合排序 前几天在工作的当中遇到对List<Map<String,String>>这样的数据结构按照Map<String,String>中的某个字段排序, 具体的实现为: <span style="font-size:18px;">public void sortList(List<Map<String, String>> list, final String field) { Collections.so

Java集合排序

java集合排序 如何给Java中List集合排序呢?前端时间在工作中遇到类似于给这样的结构排序List<Map<String,String>>>按照其中Map中的某个key值排序呢? 集合产生如下: <span style="font-size:18px;">public void sortList(){ List<List<Map<String,String>>> list = new ArrayList

Java集合排序及java集合类详解--(Collection, List, Set, Map)

1         集合框架 1.1         集合框架概述 1.1.1         容器简介 到目前为止,我们已经学习了如何创建多个不同的对象,定义了这些对象以后,我们就可以利用它们来做一些有意义的事情. 举例来说,假设要存储许多雇员,不同的雇员的区别仅在于雇员的身份证号.我们可以通过身份证号来顺序存储每个雇员,但是在内存中实现呢?是不是要准备足够的内存来存储1000个雇员,然后再将这些雇员逐一插入?如果已经插入了500条记录,这时需要插入一个身份证号较低的新雇员,该怎么办呢?是在内

java集合排序方法sort的使用

转自  http://blog.csdn.net/a1165117473/article/details/6965652 /** To change this template, choose Tools | Templates* and open the template in the editor.*/ package com.city.test; import java.util.Arrays;import java.util.Comparator;/**** @author LiuB*/

对集合排序的三种方式

对集合排序,可能最先想到的是使用OrderBy方法. class Program { static void Main(string[] args) { IEnumerable<Student> result = GetStudents().OrderBy(r => r.Score); foreach (var item in result) { Console.WriteLine(item.Name + "--" + item.Score); } Console.R

最简单的List集合排序方法

将数组按照一定的规则排序最简单的方法就是借助Arrays类的sort方法,那么要实现List集合排序的排序最简单的方式又是什么呢?当然是借助Collections类的sort方法,下面以一个例子来说明如何使用该方法实现List集合的排序: 代码一: package com.ghj.packageofvo; public class User { private String name; //姓名 private String birthday;//出生日期 public User(String

java 集合排序

http://www.cnblogs.com/standcloud/articles/2601914.html java 集合排序 Java API针对集合类型排序提供了两种支持:java.util.Collections.sort(java.util.List)java.util.Collections.sort(java.util.List, java.util.Comparator) 第一个方法要求所排序的元素类必须实现java.lang.Comparable接口.第二个方法要求实现一个j

Java 实现Map集合排序功能

第一步:Map中新增sort临时键 // 初始化Map集合 List<Map<String, String>> columns = new ArrayList<Map<String, String>>(); Map<String, String> c1 = new HashMap<String,String>(); c1.put("sort", "8"); c1.put("title&

ArrayList集合排序

using System;using System.Collections;using System.Collections.Generic;using System.Text; namespace ArrayList集合排序{    class Program    {        struct Player        {            public string name;            public int mark;                   }     

java中重写Comparator对两个list集合排序

public class test{ public static void main(String[] args) { List<LeaveRequest>  LvRequestList=new List<LeaveRequest>(); List<OtRequest> otRequestList=new List<OtRequest>(); List   allList=new List(); allList.addAll( LvRequestList);