3

我有一个包含对象的数组，这些对象有一个字符串、一个整数和一个字符属性。

Person[] people = new Person[1]; //Declare the array of objects

[...] This code is irrelevant

Person person = new Person(name, age, gender); //This creates instance a new object
people.SetValue(person, i); //is just a variable which increase in a c
Array.Resize(ref people, people.Length + 1);  //Change array  size 
i++; // Autoincrement

[...] 更多代码来填充有效的值

从存储在人员数组中的所有对象人员中，我想获取人员的年龄最大值（年龄属性是整数值）

4

7 回答 7

8

最简单的方法是使用 LINQ：

using System.Linq;

var maxVal = people.Max(x => x.Age); // get highest age
var person = people.First(x => x.Age == maxVal); // get someone with such an age
于 2013-04-18T22:42:19.520 回答
1

我假设您的 Person 类看起来像这样：-

class Person
{
  public int Age { get; private set; }
  public string Name { get; private set; }
  public string Gender { get; private set; }

  // constructor etc
}

改进

如果你有一个 Enumerable Person，即“people”，我建议你使用带有 IList 等接口的容器，即：-

IList<Person> people = new List<Person>();

因为这将使您不必手动调整阵列大小。

解决方案

要获得最大的年龄，您可以执行以下操作：-

var max = people.Max(p => p.Age);

进一步阅读

这是一个 Linq 查询；更多信息可以在这里找到： -

http://msdn.microsoft.com/en-gb/library/vstudio/bb397926.aspx

你可以用 linq 做很多“很酷”的事情，比如选择一个可枚举的年龄，即

var ages = people.Select(p => p.Age);

这将返回一个包含列表中每个人的年龄的可枚举。如果您想要所有超过一定年龄的人，您可以使用Where，即：-

var above = people.Where(p => p.Age > 65);
于 2013-04-18T22:46:57.020 回答
1

如果您每次添加新项目时都要调整数组大小，那么您真的不应该使用数组。这就是泛型List类的用途。你可以写：

List<Person> People = new List<Person>();
Person person = new Person(name, age, gender);
People.Add(person);

List需要时负责调整后备数组的大小。它比每次添加项目时调整数组大小更容易和更有效。

要获得最大年龄，您可以使用其他答案中显示的 LINQ 表达式之一。如果您想要具有最大值的记录，则必须遍历列表：

Person maxItem = People[0];
foreach (Person person in People)
{
    if (person.Age > maxItem.Age)
    {
        maxItem = person;
    }
}
于 2013-04-18T22:47:24.577 回答
0

这样的事情会对你有用：

Person[] persons = {};
Person oldest = persons.Aggregate( (x,y) => x.Age > y.Age ? x : y ) ;

或滚动您拥有：

static T FindMax<T>( this IEnumerable<T> items , Func<T,T,int> comparer  ) where T:class
{
  T max = null ;
  foreach ( T item in items )
  {
    if ( item == null ) { continue ; }
    if ( max == null ) { max = item ; continue ; }

    // check current item against max.
    // if current item is "greater than" the current max
    // replace it.
    int cc = comparer(item,max) ;
    if ( cc > 0 )
    {
      max = item ;
    }
  }
  return max ;
}

用法：

Person[] persons = LoadPersons() ;
Person oldest = persons.FindMax<Person>( (x,y) => x.Age < y.Age ? -1 : x.Age > y.Age ? +1 : 0 ) ;
于 2013-04-18T23:02:42.640 回答
0

如果列表相对较小（少于 1000 个对象），上述建议将起作用。这是因为上述所有方法都使用顺序搜索。出于性能目的（速度），应用 qsort 方法效率更高。例如：

class PersonAgeComparer : IComparer<Person>
{
    public Int32 Compare(Person x, Person y)
    {                
        if (x.Age > y.Age) return 1;
        if (x.Age < y.Age) return -1;

        return 0; // must be equal
    }
}

class Person
{
    public Int32 Age { get; set; }
}

static void Run1()
{
    Random rnd = new Random((Int32)DateTime.Now.Ticks);

    List<Person> persons = new List<Person>();
    for (Int32 i = 0; i < 100000; i++)
    {
        persons.Add(new Person() { Age = rnd.Next(100) });
    }

    persons.Sort(new PersonAgeComparer());

    // The oldest but you may have dups (same age)
    Person oldest = persons[persons.Count - 1];

}
于 2013-04-19T02:24:23.507 回答
0

我完全同意@dlev 留下的评论，因为您不应该使用传统的Arrays，而是使用List<T>自动处理集合大小的调整。

此外，因为两者Array都List<T>实现了 IEnumerable，所以您可以使用LINQ来操作您的元素，事实上，请查看您可用的方法的完整列表。

针对您的场景的具体示例：

var maxVal = people.Max(x => x.Age);
var person = people.First(x => x.Age == maxVal);
于 2013-04-18T22:50:24.620 回答
0

在 .NET 6.0 中，我们现在有一个新方法：

using System.Linq;

Person olderPerson = people.MaxBy(x => x.Age);

如果需要，还有 MinBy。

于 2021-11-28T16:53:33.970 回答