System.Array.Sort 有很多对集合的操作,比如排序,查找,克隆等等,你可以利用这个类加深对 IComparer、IComparable 以及泛型委托、匿名方法、Lambda 表达式的理解。
自定义两个类:Person 和 PersonComparer 。后面会用到这两个类。
Person 类有两个属性:FirstName 和 LastName,重构了 ToString 方法。该类还继承 IComparable 接口,实现了 CompareTo 方法,会在后面 Array.Sort 方法中用到。如下所示:
monospace; direction: ltr; border-top-style: none; color: black; font-size: 8pt; border-left-style: none; overflow: visible; padding-top: 0px">public class Person : IComparable
{
public Person()
{
}
public Person(string firstname, string lastname)
{
this.FirstName = firstname;
this.LastName = lastname;
}
public string FirstName { get; set; }
public string LastName { get; set; }
public override string ToString()
{
return string.Format("{0} {1}", FirstName, LastName);
}
public int CompareTo(object obj)
{
Person other = obj as Person;
return this.LastName.CompareTo(other.LastName);
}
}
说明:CompareTo 方法,它提供了默认比较,按 LastName 升序排序。
该类内部定义了一个比较类型,可以按 FirstName 或 LastName 比较,并且都是升序排序。PersonComparer 类同时继承 IComparer 接口的非泛型形式和泛型形式,实现了它们相应的 Compare 方法,该方法会在 Array.Sort 中用到。如下所示:
public class PersonComparer : IComparer, IComparer<Person>
{
public enum PersonCompareType
{
FirstName,
LastName
}
private PersonCompareType compareType;
public PersonComparer(PersonCompareType compareType)
{
this.compareType = compareType;
}
public int Compare(object x, object y)
{
Person p1 = x as Person;
Person p2 = y as Person;
switch (compareType)
{
case PersonCompareType.FirstName:
return p1.FirstName.CompareTo(p2.FirstName);
case PersonCompareType.LastName:
return p1.LastName.CompareTo(p2.LastName);
default:
throw new ArgumentException("unexpected compare type");
}
}
public int Compare(Person x, Person y)
{
Person p1 = x;
Person p2 = y;
switch (compareType)
{
case PersonCompareType.FirstName:
return p1.FirstName.CompareTo(p2.FirstName);
case PersonCompareType.LastName:
return p1.LastName.CompareTo(p2.LastName);
default:
throw new ArgumentException("unexpected compare type");
}
}
}
Array.Sort 有 17 个“重载”,如下所示:
Sort(Array)
Sort(Array, Array)
Sort(Array, IComparer)
Sort(Array, Array, IComparer)
Sort(Array, Int32, Int32)
Sort(Array, Array, Int32, Int32)
Sort(Array, Int32, Int32, IComparer)
Sort(Array, Array, Int32, Int32, IComparer)
Sort<T>(T[])
Sort<T>(T[], IComparer<T>)
Sort<T>(T[], Comparison<T>)
Sort<T>(T[], Int32, Int32)
Sort<T>(T[], Int32, Int32, IComparer<T>)
Sort<TKey, TValue>(TKey[], TValue[])
Sort<TKey, TValue>(TKey[], TValue[], IComparer<TKey>)
Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32)
Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)
从它们的参数,你可以先想象一下:
- 这些方法可以分成非泛型形式和泛型形式,也就是每个非泛型形式基本都会对应一个泛型形式;
- 如果我们要对一个集合排序,肯定是要比较的,并且默认排序,一般是升序,当然也可以是降序;
- 如果集合是字符串,那很好办,几乎不需要做什么;
- 可如果集合是对象,那我们就必须指定两个对象之间如何比较;
- 如果有两个集合,一个集合是当键,另一个集合是当值,用键为值排序,这当然也是可以的,比如 Sort<TKey, TValue>;
- 针对不同的场景,可以指定不同的比较方式,比如,参数中带 ICompare 的。可以指定按 LastName 升序或降序,或 FirstName 升序或降序 。
如果集合仅仅是字符串数组,那很好办,如下代码所示,按升序排序:
string[] names = { "Emerson Fittipaldi", "Niki Lauda", "Ayrton Senna", "Michael Schumacher" };
Array.Sort(names);
但外国人的姓在后面,要按我们的习惯如何按姓排序?字符串数组肯定不行,这就需要自定义的 Person 类了,假设有如下 Person 数组:
Person[] persons = {
new Person("Emerson", "Fittipaldi"),
new Person("Niki", "Lauda"),
new Person("Ayrton", "Senna"),
new Person("Michael", "Schumacher")
};
采用 Sort(Array) 这个方法,按姓的升序排序,如下代码所示:
Array.Sort(persons);
因为定义 Person 类时,继承了 IComparer 接口,并实现了 CompareTo 方法,里面规定了按姓 LastName 比较,并且是升序,所以 Array.Sort 方法就知道如何排序了。
如果有时需要按 FirstName 排序,有时用 LastName,怎么办?这就需要自定义的类 PersonComparer。采用 Sort(Array, IComparer) 这个方法,代码如下所示:
Array.Sort(persons, new PersonComparer(PersonComparer.PersonCompareType.FirstName));
Console.WriteLine("Sort By First Name:");
foreach (Person p in persons)
{
Console.WriteLine(" " + p);
}
Array.Sort(persons, new PersonComparer(PersonComparer.PersonCompareType.LastName));
Console.WriteLine("Sort By Last Name:");
foreach (Person p in persons)
{
Console.WriteLine(" " + p);
}
结果:
Sort By First Name:
Ayrton Senna
Emerson Fittipaldi
Michael Schumacher
Niki Lauda
Sort By Last Name:
Emerson Fittipaldi
Niki Lauda
Michael Schumacher
Ayrton Senna
如果我们事先未定义 PersonComparer 类,也没问题,可以采用 Sort<T>(T[], Comparison<T>) 这个方法,参数 Comparison<T> 是 .Net 提供的泛型委托,这意味着我们可以用匿名方法或 Lambda 表达式来规定 Person 如何比较,采用匿名方法如下所示:
Array.Sort(persons,
delegate(Person p1, Person p2)
{
return p1.FirstName.CompareTo(p2.FirstName);
});
Array.Sort(persons,
delegate(Person p1, Person p2)
{
return p1.LastName.CompareTo(p2.LastName);
});
或采用 Lambda 表达式形式:
Array.Sort(persons, (p1, p2) => p1.FirstName.CompareTo(p2.FirstName));
Array.Sort(persons, (p1, p2) => p1.LastName.CompareTo(p2.LastName));
如果有两个集合,让其中一个集合为另一个集合排序呢?若有两个 Person 集合,一模一样,只是一个当键,另一个当值,用键为值排序,如下代码所示:
Person[] personKeys = {
new Person("Emerson", "Fittipaldi"),
new Person("Niki", "Lauda"),
new Person("Ayrton", "Senna"),
new Person("Michael", "Schumacher")
};
Person[] personValues = {
new Person("Emerson", "Fittipaldi"),
new Person("Niki", "Lauda"),
new Person("Ayrton", "Senna"),
new Person("Michael", "Schumacher")
};
Array.Sort<Person, Person>(personKeys, personValues);
Array.Sort<Person, Person>(personKeys, personValues, new PersonComparer(PersonComparer.PersonCompareType.FirstName));
其中,
Array 中的其他方法,像 BinarySearch、Find 相关和 indexOf 相关,跟 Sort 用法类似,因为它们的参数大都是 IComparer、IComparable 以及泛型委托。
下载 Demo