c#中List<T>find使用示例（转）

最新推荐文章于 2023-10-22 13:58:21 发布
最新推荐文章于 2023-10-22 13:58:21 发布
阅读量5.4k 收藏
点赞数
分类专栏： Framework2.0

转自：http://blogs.msdn.com/b/kcwalina/archive/2004/06/22/162533.aspx

Generics and Anonymous Methods/Delegates

make up a powerful pair that can be used to create elegant query APIs. Here are some that we just added to the .NET Framework’s Collection libraries. I used List<T> to illustrate the APIs but most of those were also added to System.Array.

API Design

Delegates

namespace System {

   public delegate void Action<T>(T obj);

   public delegate bool Predicate<T>(T obj);

   public delegate U Converter<T,U>(T from);

   public delegate int Comparison<T>(T x, T y);

}

List<T>

public class List<T> : … {

   public int FindIndex(Predicate<T> match);

   public int FindIndex(int index, Predicate<T> match);

   public int FindIndex(int index, int count, Predicate<T> match);

   public int FindLastIndex(Predicate<T> match);

   public int FindLastIndex(int index, Predicate<T> match);

   public int FindLastIndex(int index, int count, Predicate<T> match);

 

   public List<T> FindAll(Predicate<T> match);

   public T Find(Predicate<T> match);

   public T FindLast(Predicate match);

   public bool Exists(Predicate<T> match);

   public bool TrueForAll(Predicate<T> match); 

   public int RemoveAll(Predicate<T> match);

   public void ForEach(Action<T> action);

   public void Sort(Comparison<T> comparison);

   public List<U> ConvertAll<U>(Converter<T,U> converter);

}

Finding Even Integers in List<T>

List<int> integers = new List<int>();

For(int i=1; i<=10; i++) integers.Add(i);

List<int> even = integers.FindAll(delegate(int i){

   return i%2==0;

});

Finding Complex Type in List<T>

public class Order {

   public Order(int number, string item) { … }

   public int Number { get { return number; } }

   public string Item { get { return item; } }

   …

}

List<Order> orders = new List<Order>();

int orderNumber = 10;

Order order = orders.Find(delegate(Order o){

   return o.Number==orderNumber;

});

Computing Sum of Integers in List<T>

List<int> integers = new List<int>();

for(int i=1; i<=10; i++) integers.Add(i);

int sum;

integers.ForEach(delegate(int i){ sum+=i; });

Sort Orders in List<T>

List<Order> orders = new List<Order>();

orders.Add(new Order(10,”Milk”));

orders.Add(new Order(5,”Cheese”));

 orders.Sort(delegate(Order x, Order y){

   return Comparer<int>.Default.Compare(x.Number,y.Number);

});

Convert Orders to Order Numbers

List<Order> orders = new List<Order>();

orders.Add(new Order(10,”Milk”));

orders.Add(new Order(5,”Cheese”));

List<int> numbers = orders.ConvertAll(delegate(Order x){

   return o.Number;

});

转自：http://www.dotblogs.com.tw/puma/archive/2009/05/28/asp.net-generic-list-sort-find-findall-exsit.aspx#12190

 

最近寫案子常常用到List<T>,這個東西還真好用

因為它有下列東西：

List<T>.Sort() → 排序T

List<T>.Find() → 找出一個T

List<T>.FindAll() →找出多個T

List<T>.Exist() →判斷T是否存在

小弟就寫個範例介紹這些東西吧..

GenericList.aspx

01<%@ Page Language="C#" AutoEventWireup="true" CodeFile="GenericList.aspx.cs" Inherits="GenericList" %>
02  
03<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
04  
05<html xmlns="http://www.w3.org/1999/xhtml">
06<head runat="server">
07    <title>GenericList</title>
08</head>
09<body>
10    <form id="form1" runat="server">
11    <div>
12        原始資料：
13        <asp:GridView ID="GridView1" runat="server">
14        </asp:GridView>
15    </div>
16    </form>
17</body>
18</html>

 

GenericList.aspx.cs

001using System;
002using System.Collections.Generic;
003using System.Web;
004using System.Web.UI;
005using System.Web.UI.WebControls;
006  
007public partial class GenericList : System.Web.UI.Page
008{
009  
010    protected void Page_Load(object sender, EventArgs e)
011    {
012        List<Person> lstPerson = new List<Person>();
013        lstPerson.Add(new Person(1, "puma", 10));
014        lstPerson.Add(new Person(2, "F6 Team", 20));
015        lstPerson.Add(new Person(3, "ASP.NET", 30));
016        lstPerson.Add(new Person(4, "Dotblogs", 40));
017  
018        //原始資料顯示在GridView上
019        this.GridView1.DataSource = lstPerson;
020        this.GridView1.DataBind();
021  
022  
023  
024        //List<T>.Find()
025        //找出Name='puma'的Person
026        Response.Write("找出Name='puma'的Person→ ");
027        Response.Write(lstPerson.Find(delegate(Person p) { return p.Name == "puma"; }).ToString() + "<p>");
028  
029  
030  
031        //List<T>.FindAll()
032        //找出Age>10的數目
033        Response.Write("找出Age>10的數目→ ");
034        Response.Write(lstPerson.FindAll(delegate(Person p) { return p.Age > 10; }).Count.ToString() + "<p>");
035  
036  
037  
038        //List<T>.Exists()
039        //檢查Name='F6'是否存在
040        Response.Write("檢查Name='F6'是否存在→ ");
041        Response.Write(lstPerson.Exists(delegate(Person p) { return p.Name == "F6"; }).ToString() + "<p>");
042  
043  
044  
045        //List<T>.Sort()
046        //依Name升冪排序
047        Response.Write("<p>依Name升冪排序↑<br/>");
048        lstPerson.Sort(delegate(Person p1, Person p2) { return Comparer<string>.Default.Compare(p1.Name, p2.Name); });
049        foreach (Person p in lstPerson)
050        {
051            Response.Write(p.ToString() + "<br/>");
052        }
053  
054  
055  
056        //List<T>.Sort()
057        //依Name降冪排序
058        Response.Write("<p>依Name降冪排序↓<br/>");
059        lstPerson.Sort(delegate(Person p1, Person p2) { return Comparer<string>.Default.Compare(p2.Name, p1.Name); });
060        foreach (Person p in lstPerson)
061        {
062            Response.Write(p.ToString() + "<br/>");
063        }
064    }
065}
066  
067public class Person
068{
069    private int _ID;
070    private string _Name;
071    private int _Age;
072  
073    public Person(int ID, string Name, int Age)
074    {
075        _ID = ID;
076        _Name = Name;
077        _Age = Age;
078    }
079  
080    public int ID
081    {
082        set { _ID = value; }
083        get { return _ID; }
084    }
085  
086    public string Name
087    {
088        set { _Name = value; }
089        get { return _Name; }
090    }
091  
092    public int Age
093    {
094        set { _Age = value; }
095        get { return _Age; }
096    }
097  
098    public override string ToString()
099    {
100        return string.Format("ID：{0}，Name：{1}，Age：{2}", _ID, _Name, _Age);
101    }
102}

 

執行結果：

 转自微软官方：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace Find
{
    class Program
    {
        private static string IDtoFind = "bk109";

        private static List<Book> Books = new List<Book>();
        public static void Main(string[] args)
        {
            FillList();

            // Find a book by its ID.
            Book result = Books.Find(
            delegate(Book bk)
            {
                return bk.ID == IDtoFind;
            }
            );
            if (result != null)
            {
                DisplayResult(result, "Find by ID: " + IDtoFind);
            }
            else
            {
                Console.WriteLine("\nNot found: {0}", IDtoFind);
            }


            // Find last book in collection published before 2001.
            result = Books.FindLast(
            delegate(Book bk)
            {
                DateTime year2001 = new DateTime(2001, 01, 01);
                return bk.Publish_date < year2001;
            });
            if (result != null)
            {
                DisplayResult(result, "Last book in collection published before 2001:");
            }
            else
            {
                Console.WriteLine("\nNot found: {0}", IDtoFind);
            }


            // Find all computer books.
            List<Book> results = Books.FindAll(FindComputer);
            if (results != null)
            {
                DisplayResults(results, "All computer:");
            }
            else
            {
                Console.WriteLine("\nNo books found.");
            }

            // Find all books under $10.00.
            results = Books.FindAll(
            delegate(Book bk)
            {
                return bk.Price < 10.00;
            }
            );
            if (results != null)
            {
                DisplayResults(results, "Books under $10:");
            }
            else
            {
                Console.WriteLine("\nNo books found.");
            }


            // Find index values.
            Console.WriteLine();
            int ndx = Books.FindIndex(FindComputer);
            Console.WriteLine("Index of first computer book: {0}", ndx);
            ndx = Books.FindLastIndex(FindComputer);
            Console.WriteLine("Index of last computer book: {0}", ndx);

            int mid = Books.Count / 2;
            ndx = Books.FindIndex(mid, mid, FindComputer);
            Console.WriteLine("Index of first computer book in the second half of the collection: {0}", ndx);

            ndx = Books.FindLastIndex(Books.Count - 1, mid, FindComputer);
            Console.WriteLine("Index of last computer book in the second half of the collection: {0}", ndx);

        }

 

 

        // Populates the list with sample data.
        private static void FillList()
        {

            // Create XML elements from a source file.
            XElement xTree = XElement.Load(@"c:\temp\books.xml");

            // Create an enumerable collection of the elements.
            IEnumerable<XElement> elements = xTree.Elements();

            // Evaluate each element and set set values in the book object.
            foreach (XElement el in elements)
            {
                Book book = new Book();
                book.ID = el.Attribute("id").Value;
                IEnumerable<XElement> props = el.Elements();
                foreach (XElement p in props)
                {


                    if (p.Name.ToString().ToLower() == "author")
                    {
                        book.Author = p.Value;
                    }
                    else if (p.Name.ToString().ToLower() == "title")
                    {
                        book.Title = p.Value;
                    }
                    else if (p.Name.ToString().ToLower() == "genre")
                    {
                        book.Genre = p.Value;
                    }
                    else if (p.Name.ToString().ToLower() == "price")
                    {
                        book.Price = Convert.ToDouble(p.Value);
                    }
                    else if (p.Name.ToString().ToLower() == "publish_date")
                    {
                        book.Publish_date = Convert.ToDateTime(p.Value);
                    }
                    else if (p.Name.ToString().ToLower() == "description")
                    {
                        book.Description = p.Value;
                    }
                }

                Books.Add(book);

            }

            DisplayResults(Books, "All books:");

        }

        // Explicit predicate delegate.
        private static bool FindComputer(Book bk)
        {

            if (bk.Genre == "Computer")
            {
                return true;
            }
            {
                return false;
            }

        }

        private static void DisplayResult(Book result, string title)
        {
            Console.WriteLine();
            Console.WriteLine(title);
            Console.WriteLine("\n{0}\t{1}\t{2}\t{3}\t{4}\t{5}", result.ID,
                result.Author, result.Title, result.Genre, result.Price,
                result.Publish_date.ToShortDateString());
            Console.WriteLine();


        }

        private static void DisplayResults(List<Book> results, string title)
        {
            Console.WriteLine();
            Console.WriteLine(title);
            foreach (Book b in results)
            {

                Console.Write("\n{0}\t{1}\t{2}\t{3}\t{4}\t{5}", b.ID,
                    b.Author, b.Title, b.Genre, b.Price,
                    b.Publish_date.ToShortDateString());
            }
            Console.WriteLine();

        }

    }

    public class Book
    {
        public string ID { get; set; }
        public string Author { get; set; }
        public string Title { get; set; }
        public string Genre { get; set; }
        public double Price { get; set; }
        public DateTime Publish_date { get; set; }
        public string Description { get; set; }
    }
}
一直学习
关注
专栏目录
C#中List＜T＞.FindAll vs LINQ Where：两大筛选利器，你会选哪个？
java专栏
10-04 611
是一个集合本身提供的方法，它接受一个委托作为参数，根据委托的条件来筛选集合中的元素。LINQWhere是一个更现代、更强大的查询表达式或方法链的一部分，它也接受一个函数来决定哪些元素应该被保留。和LINQWhere各有千秋。FindAll适用于小规模数据集且需要直接操作List时；而LINQWhere则因其灵活性和强大的查询能力，在处理复杂查询及非List集合时表现更佳。选择哪个取决于具体的应用场景和个人偏好。希望本文能帮助你更好地理解这两个方法的区别，从而在实际开发中做出合适的选择。
java8中常用函数式接口Supplier＜T＞、Consumer＜T＞、Function＜T,R＞、Predicate＜T＞使用示例
BADAO_LIUMANG_QIZHI的博客
01-03 1991
函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。而java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。下面介绍四个常用的函数式接口的使用示例。这四个接口基本满足大部分的使用需求，当然还要其他函数式接口，可根据自己需要查询相关文档。
C#中List的Find方法的使用
zhangziyangup
07-21 2140
查找List中的某个值，可以使用循环遍历对比，查找出结果。C#中提供了Find方法，可以直接使用，只要查找条件传入就可。如下： class Program { public static void Main(string[] args) { List&lt;User&gt; userCollection = new ...
C# List<T>中Find的用法
热门推荐
knqiufan的博客
09-05 4万+
(在决定使用List还是使用ArrayList类时，记住List在大多数情况下执行的更好并且是类型安全的。) List.Find方法： 搜索与制定谓词所定义的条件相匹配的元素，并返回整个List中的第一个匹配元素。 public T Find(Predicate match) Predicate是对方法的委托，如果传递给它的对象与委托中定义的条件匹配，则返回该方法返
C# List Find
weixin_33858249的博客
01-08 1602
A List can be searched imperatively. This often involves a foreach-loop. It can be searched instead with the Find method: this often uses a lambda expression. Find makes code clearer in some program c...
C#泛型列表List＜T＞的基本用法分享
xiaoweids的博客
07-13 449
/ 可以使用只读集合,使用AsReadOnly方法() 返回ReadOnlyCollection类型,它与List操作是一样的,但是一但有修改集合的操作,就会刨出异常。Console.WriteLine( "-----------------用ForEach方法输出------------------------");Console.WriteLine( "----------------访问元素------------------------");
C#List<T>泛型列表
weixin_40786497的博客
02-03 580
List<T> 一、引言 这个类实现了IList、ICollection、IEnumerable、IList、ICollection、IEnumerable接口。 前面的章节我们也简单的提到过List泛型集合类。现在我们复习一下。 首先，数组存储的数据类型是固定的，且长度也固定不变。很显然，这种特性对不同长度的存储需求来说无法满足。固引出集合的概念，其中List为泛型集合，可以面向任何...
C# List＜T＞Find的用法
weixin_42288222的博客
07-27 1225
C# List 中Find的用法
List.Find()用法
03-09
List.Find()用法
C#List＜T＞泛型，Find方法
GG_nizaigansm的博客
07-26 882
C#，Find()方法，Find()返回值
C# LIST .find 用法
最新发布
lvmingzhou的专栏
10-22 537
【代码】C# LIST .find 用法。
C# List用法；用Exists判断是否存在符合条件的元素；判断是否存在
Dxg团队
11-26 6746
VS-C++ 系列：所有相关C++文章链接. VS-C# 系列：所有相关C#文章链接. bat 系列：所有相关bat文章链接. Keil 系列：所有相关文章链接 所有内容均以最小系统调试成功；逐步提供低分源码工程下载！ 保证每行代码都经过验证！ 如有疑惑，欢迎留言，看见即回；祝好__by Dxg_LC 序言： 1、以上链接为方便整理查看资料用；伴随博文发布更新，如果有不正确处，感谢指正 2、因本人能力有限若有不正确之处或者相关超链接失效，请于相关文章内提醒@博主；灰常感谢 3、友情提醒1，勿要《一支烟
【C#】List.Find
阿黄的博客
10-17 1521
首先看一下 MSDN 搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的第一个匹配元素。 命名空间:   System.Collections.Generic public T Find( Predicate match ) 参数 matchType: System.PredicateT> Predicate 委托，用于定义要搜索的
C# List Find方法
03-29 202
　　https://blog.csdn.net/knqiufan/article/details/77847143 　　 转载于:https://www.cnblogs.com/kanite/p/8667857.html
C#中List.Find 方法详解
Peter的博客
02-20 1万+
类似于C++ 中的STL C#中也有List这样的数据结构方便开发者存储数据，我们常常会使用到sort，find等算法。 以find为例，在msdn给出的原型如下 public T Find ( Predicate<T> match ) 其中泛型T为list定义的时候用户决定的存储类型，Predicate match 是一个委托，可理解为函数指针，实质上被定义为 public delegate bool Predicate (T obj) 则开发者可以使用自己...
List<T>.Find用法学习
weixin_30240349的博客
09-15 953
泛型集合List<T>中的Find函数用于查找集合中符合指定条件的元素..相比foreach遍历元素，用Find函数查找，代码更简洁. 函数原型如下： public T Find(Predicate<T> match); 其中Predicate为C#定义好的委托，原型如下： public delegate bool Predicate<in T>(T o...
C#入门教程：List<T>的使用与泛型集合解析
在描述中提到的“演示：MySchool”可能是一个实际的编程示例，展示了如何使用 `List<T>` 来管理学生数据，但具体的实现细节并未在此给出。`List<T>` 的其他方法，如 `Remove`、`Find`、`Sort` 等，也都是 C# 开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值