C# List用法 List介紹

1、# List泛型集合html

  集合是OOP中的一個重要概念,C#中對集合的全面支持更是該語言的精華之一。數組

    爲何要用泛型集合?函數

    在C# 2.0以前,主要能夠經過兩種方式實現集合:測試

    a.使用ArrayListthis

    直接將對象放入ArrayList,操做直觀,但因爲集合中的項是Object類型,所以每次使用都必須進行繁瑣的類型轉換。spa

    b.使用自定義集合類code

    比較常見的作法是從CollectionBase抽象類繼承一個自定義類,經過對IList對象進行封裝實現強類型集合。這種方式要求爲每種集合類型寫一個相應的自定義類,工做量較大。泛型集合的出現較好的解決了上述問題,只需一行代碼便能建立指定類型的集合。htm

    什麼是泛型?對象

    泛型是C# 2.0中的新增元素(C++中稱爲模板),主要用於解決一系列相似的問題。這種機制容許將類名做爲參數傳遞給泛型類型,並生成相應的對象。將泛型(包括類、接口、方法、委託等)看做模板可能更好理解,模板中的變體部分將被做爲參數傳進來的類名稱所代替,從而獲得一個新的類型定義。泛型是一個比較大的話題,在此不做詳細解析,有興趣者能夠查閱相關資料。blog

    怎樣建立泛型集合?

    主要利用System.Collections.Generic命名空間下面的List<T>泛型類建立集合,語法以下:

List<T> ListOfT = new List<T>();

  其中的"T"就是所要使用的類型,既能夠是簡單類型,如string、int,也能夠是用戶自定義類型。下面看一個具體例子。    

  定義Person類以下:

class Person
{
    private string _name; //姓名
    private int _age; //年齡
    //建立Person對象
    public Person(string Name, int Age)
    {
        this._name= Name;
        this._age = Age;
    }
    //姓名
    public string Name
    {
        get { return _name; }
    }
    //年齡
    public int Age
    {
        get { return _age; }
    }
}

//建立Person對象
Person p1 = new Person("張三", 30);
Person p2 = new Person("李四", 20);
Person p3 = new Person("王五", 50);
//建立類型爲Person的對象集合
List<Person> persons = new List<Person>();
//將Person對象放入集合
persons.Add(p1);
persons.Add(p2);
persons.Add(p3);
//輸出第2我的的姓名
Console.Write(persons[1].Name);

  能夠看到,泛型集合大大簡化了集合的實現代碼,經過它,能夠輕鬆建立指定類型的集合。非但如此,泛型集合還提供了更增強大的功能,下面看看其中的排序及搜索。

 

  泛型集合的排序

  排序基於比較,要排序,首先要比較。好比有兩個數一、2,要對他們排序,首先就要比較這兩個數,根據比較結果來排序。若是要比較的是對象,狀況就要複雜一點,好比對Person對象進行比較,則既能夠按姓名進行比較,也能夠按年齡進行比較,這就須要肯定比較規則。一個對象能夠有多個比較規則,但只能有一個默認規則,默認規則放在定義該對象的類中。默認比較規則在CompareTo方法中定義,該方法屬於IComparable<T>泛型接口。請看下面代碼:

class Person :IComparable<Person>
{
    //按年齡比較
    public int CompareTo(Person p)
    {
        return this.Age - p.Age;
    }
}

  CompareTo方法的參數爲要與之進行比較的另外一個同類型對象,返回值爲int類型,若是返回值大於0,表示第一個對象大於第二個對象,若是返回值小於0,表示第一個對象小於第二個對象,若是返回0,則兩個對象相等。

  定義好默認比較規則後,就能夠經過不帶參數的Sort方法對集合進行排序,以下所示:

//按照默認規則對集合進行排序
persons.Sort();
//輸出全部人姓名
foreach (Person p in persons)
{
    Console.WriteLine(p.Name); //輸出次序爲"李四"、"張三"、"王五"
}

  實際使用中,常常須要對集合按照多種不一樣規則進行排序,這就須要定義其餘比較規則,能夠在Compare方法中定義,該方法屬於IComparer<T>泛型接口,請看下面的代碼:

class NameComparer : IComparer<Person>
{
    //存放排序器實例
    public static NameComparer Default = new NameComparer();
    //按姓名比較
    public int Compare(Person p1, Person p2)
    {
        return System.Collections.Comparer.Default.Compare(p1.Name, p2.Name);
    }
}

   Compare方法的參數爲要進行比較的兩個同類型對象,返回值爲int類型,返回值處理規則與CompareTo方法相同。其中的Comparer.Default返回一個內置的Comparer對象,用於比較兩個同類型對象。

  下面用新定義的這個比較器對集合進行排序:

//按照姓名對集合進行排序 
persons.Sort(NameComparer.Default); 
//輸出全部人姓名 
foreach (Person p in persons) 
{ 
  Console.WriteLine(p.Name); //輸出次序爲"李四"、"王五"、"張三" 
} 

  還能夠經過委託來進行集合排序,首先要定義一個供委託調用的方法,用於存放比較規則,能夠用靜態方法。請看下面的代碼:

class PersonComparison 
{ 
  //按姓名比較 
  public static int Name(Person p1, Person p2) 
  { 
    return System.Collections.Comparer.Default.Compare(p1.Name, p2.Name); 
  } 
} 

 方法的參數爲要進行比較的兩個同類型對象,返回值爲int類型,返回值處理規則與CompareTo方法相同。而後經過內置的泛型委託System.Comparison<T>對集合進行排序:

System.Comparison<Person> NameComparison = new 
System.Comparison<Person>(PersonComparison.Name); 
persons.Sort(NameComparison); 
//輸出全部人姓名 
foreach (Person p in persons) 
{ 
  Console.WriteLine(p.Name); //輸出次序爲"李四"、"王五"、"張三" 
} 

能夠看到,後兩種方式均可以對集合按照指定規則進行排序,但筆者更偏向於使用委託方式,能夠考慮把各類比較規則放在一個類中,而後進行靈活調用。

 

  泛型集合的搜索

  搜索就是從集合中找出知足特定條件的項,能夠定義多個搜索條件,並根據須要進行調用。

  首先,定義搜索條件,以下所示:

class PersonPredicate
{
    //找出中年人(40歲以上)
    public static bool MidAge(Person p)
    {

        if (p.Age >= 40)
            return true;
        else
            return false;
    }
}

上面的搜索條件放在一個靜態方法中,方法的返回類型爲布爾型,集合中知足特定條件的項返回true,不然返回false。而後經過內置的泛型委託System.Predicate<T>對集合進行搜索:

System.Predicate<Person> MidAgePredicate = new System.Predicate<Person>(PersonPredicate.MidAge);
List<Person> MidAgePersons = persons.FindAll(MidAgePredicate);
//輸出全部的中年人姓名

foreach (Person p in MidAgePersons)
{
    Console.WriteLine(p.Name); //輸出"王五"
}

 

  泛型集合的擴展

  若是要獲得集合中全部人的姓名,中間以逗號隔開,那該怎麼處理?

  考慮到單個類能夠提供的功能是有限的,很天然會想到對List<T>類進行擴展,泛型類也是類,所以能夠經過繼承來進行擴展。請看下面的代碼:

//定義Persons集合類
class Persons : List<Person>
{
    //取得集合中全部人姓名
    public string GetAllNames()
    {
        if (this.Count == 0)
            return "";
        string val = "";
        foreach (Person p in this)
        {
            val += p.Name + ",";
        }
        return val.Substring(0, val.Length - 1);
    }
}
//建立並填充Persons集合
Persons PersonCol = new Persons();
PersonCol.Add(p1);
PersonCol.Add(p2);
PersonCol.Add(p3);
//輸出全部人姓名
Console.Write(PersonCol.GetAllNames()); //輸出「張三,李四,王五」

 

2、List的方法和屬性 方法或屬性 做用

  Capacity 用於獲取或設置List可容納元素的數量。當數量超過容量時,這個值會自動增加。您能夠設置這個值以減小容量,也能夠調用trin()方法來減小容量以適合實際的元素數目。

  Count 屬性,用於獲取數組中當前元素數量

  Item( ) 經過指定索引獲取或設置元素。對於List類來講,它是一個索引器。

  Add( ) 在List中添加一個對象的公有方法

  AddRange( ) 公有方法,在List尾部添加實現了ICollection接口的多個元素

  BinarySearch( ) 重載的公有方法,用於在排序的List內使用二分查找來定位指定元素.

  Clear( ) 在List內移除全部元素

  Contains( ) 測試一個元素是否在List內

  CopyTo( ) 重載的公有方法,把一個List拷貝到一維數組內

  Exists( ) 測試一個元素是否在List內

  Find( ) 查找並返回List內的出現的第一個匹配元素

  FindAll( ) 查找並返回List內的全部匹配元素

  GetEnumerator( ) 重載的公有方法,返回一個用於迭代List的枚舉器

  Getrange( ) 拷貝指定範圍的元素到新的List內

  IndexOf( ) 重載的公有方法,查找並返回每個匹配元素的索引

  Insert( ) 在List內插入一個元素

  InsertRange( ) 在List內插入一組元素

  LastIndexOf( ) 重載的公有方法,,查找並返回最後一個匹配元素的索引

  Remove( ) 移除與指定元素匹配的第一個元素

  RemoveAt( ) 移除指定索引的元素

  RemoveRange( ) 移除指定範圍的元素

  Reverse( ) 反轉List內元素的順序

  Sort( ) 對List內的元素進行排序

  ToArray( ) 把List內的元素拷貝到一個新的數組內

  trimToSize( ) 將容量設置爲List中元素的實際數目

 

3、List的用法

一、List的基礎、經常使用方法:

(1)、聲明: 
①、List<T> mList = new List<T>();  
T爲列表中元素類型,如今以string類型做爲例子

List<string> mList = new List<string>();

②、List<T> testList =new List<T> (IEnumerable<T> collection);

以一個集合做爲參數建立List:

string[] temArr = { "Ha", "Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", "Locu" };
List<string> testList = new List<string>(temArr);

(2)、添加元素:

①、 添加一個元素

  語法: List. Add(T item)  

List<string> mList = new List<string>();
mList.Add("John");

②、 添加一組元素

  語法: List. AddRange(IEnumerable<T> collection)   

List<string> mList = new List<string>();
string[] temArr = { "Ha","Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku",  "Locu" };
mList.AddRange(temArr);

③、在index位置添加一個元素

  語法: Insert(int index, T item); 

List<string> mList = new List<string>();
mList.Insert(1, "Hei");

④、遍歷List中元素

語法:

foreach (T element in mList)  //T的類型與mList聲明時同樣
{
    Console.WriteLine(element);
}

例:

List<string> mList = new List<string>();
...//省略部分代碼
foreach (string s in mList)
{
    Console.WriteLine(s);
}

(3)、刪除元素:

①、刪除一個值

  語法:List. Remove(T item)

mList.Remove("Hunter");

②、 刪除下標爲index的元素

  語法:List. RemoveAt(int index);   

mList.RemoveAt(0);

③、 從下標index開始,刪除count個元素

  語法:List. RemoveRange(int index, int count);

mList.RemoveRange(3, 2);

(4)、判斷某個元素是否在該List中:

語法:List. Contains(T item)   返回值爲:true/false

if (mList.Contains("Hunter"))
{
    Console.WriteLine("There is Hunter in the list");
}
else
{
    mList.Add("Hunter");
    Console.WriteLine("Add Hunter successfully.");
}

(5)、給List裏面元素排序:

  語法: List. Sort ()   默認是元素第一個字母按升序

mList.Sort();

(6)、給List裏面元素順序反轉:

  語法: List. Reverse ()   能夠與List. Sort ()配合使用,達到想要的效果

mList. Reverse();

(7)、List清空:

  語法:List. Clear () 

mList.Clear();

(8)、得到List中元素數目:

  語法: List. Count ()    返回int值

int count = mList.Count();
Console.WriteLine("The num of elements in the list: " +count);

 

二、List的進階、強大方法:

本段舉例用的List:

string[] temArr = { "Ha","Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", " "Locu" };
mList.AddRange(temArr);

(1)、List.FindAll方法:檢索與指定謂詞所定義的條件相匹配的全部元素 

  語法:public List<T> FindAll(Predicate<T> match);

List<string> subList = mList.FindAll(ListFind); //委託給ListFind函數
foreach (string s in subList)
{
    Console.WriteLine("element in subList: "+s);
}

這時subList存儲的就是全部長度大於3的元素。

(2)、List.Find 方法:搜索與指定謂詞所定義的條件相匹配的元素,並返回整個 List 中的第一個匹配元素。 

  語法:public T Find(Predicate<T> match);

Predicate是對方法的委託,若是傳遞給它的對象與委託中定義的條件匹配,則該方法返回 true。當前 List 的元素被逐個傳遞給Predicate委託,並在 List 中向前移動,從第一個元素開始,到最後一個元素結束。當找到匹配項時處理即中止。

Predicate 能夠委託給一個函數或者一個拉姆達表達式:

委託給拉姆達表達式:

string listFind = mList.Find(name =>  //name是變量,表明的是mList中元素,本身設定
{     
   if (name.Length > 3)
   {
      return true;
   }
  return false;
});
Console.WriteLine(listFind);     //輸出是Hunter

委託給一個函數: 

string listFind1 = mList.Find(ListFind);  //委託給ListFind函數
Console.WriteLine(listFind);    //輸出是Hunter

//ListFind函數
public bool ListFind(string name)
{
    if (name.Length > 3)
    {
        return true;
    }
    return false;
}

 這兩種方法的結果是同樣的。

 

(3)、List.FindLast 方法:搜索與指定謂詞所定義的條件相匹配的元素,並返回整個 List 中的最後一個匹配元素。 
  語法:public T FindLast(Predicate<T> match);

用法與List.Find相同。

 

(4)、List.TrueForAll方法:  肯定是否 List 中的每一個元素都與指定的謂詞所定義的條件相匹配。

  語法:public bool TrueForAll(Predicate<T> match);

委託給拉姆達表達式:

bool flag = mList.TrueForAll(name =>
{
    if (name.Length > 3)
    {
     return true;
    }
    else
    {
     return false;
    }
});
Console.WriteLine("True for all:  "+flag);  //flag值爲

 委託給一個函數,這裏用到上面的ListFind函數:

bool flag = mList.TrueForAll(ListFind);    //委託給ListFind函數
Console.WriteLine("True for all:  "+flag);  //flag值爲false

這兩種方法的結果是同樣的。

 

(5)List.Take(n)方法:  得到前n行 返回值爲IEnumetable<T>,T的類型與List<T>的類型同樣

IEnumerable<string> takeList=  mList.Take(5);
foreach (string s in takeList)
{
      Console.WriteLine("element in takeList: " + s);
}

這時takeList存放的元素就是mList中的前5個。

(6)、List.Where方法:檢索與指定謂詞所定義的條件相匹配的全部元素。跟List.FindAll方法相似。

IEnumerable<string> whereList = mList.Where(name =>
{
   if (name.Length > 3)
   {
      return true;
   }
   else
  {
     return false;
  }
 });

foreach (string s in subList)
{
   Console.WriteLine("element in subLis

這時subList存儲的就是全部長度大於3的元素。

 

(7)、List.RemoveAll方法:移除與指定的謂詞所定義的條件相匹配的全部元素。

  語法: public int RemoveAll(Predicate<T> match);

mList.RemoveAll(name =>
{
     if (name.Length > 3)
    {
        return true;
    }
    else
    {
        return false;
    }
});

foreach (string s in mList)
{
    Console.WriteLine("element in mList:     " + s);
}  

這時mList存儲的就是移除長度大於3以後的元素。

相關文章
相關標籤/搜索