list<>_如何用循环写法输出列表中长度大于三的元素-CSDN博客

http://msdn.microsoft.com/zh-cn/library/6sh2ey19/

命名空间：
using System.Collections;

class Program
    {
//做个比较
        static void Main(string[] args)
        {
            //new对象
            Cls a1 = new Cls();
            Cls a2 = new Cls();

            //存放对象
            List<Cls> testfanxing = new List<Cls>();
            testfanxing.Add(a1);

            ArrayList testarray = new ArrayList();
            testarray.Add(a2);

            //取对象
            Cls b1 = testfanxing[0];
            Cls b2 = testarray[0];//这句报错！ 改为：Cls b2 = (Cls)testarray[0];就可正常通过，但是用了类型强制转换

            //泛型啥好处？
            //1。避免了强制类型转换而造成代码可读性差。
            //2。既然有了类型强制转换，问题来了：类型强制转换可能会用到装箱和拆箱过程，耗时。
            //3。再由于有强制类型转换，在编译的时候可能不会包错，但是运行代码的时候有可能会因为转换失败而出现错误。这就是我们说的非安全代码。
        }
    }

    class Cls
    { }

简单来说，泛型就是限制了操作类型。

用微软的话讲：
“添加到 ArrayList 中的任何引用或值类型都将隐式地向上强制转换为 Object。如果项是值类型，则必须在将其添加到列表中时进行装箱操作，在检索时进行取消装箱操作。强制转换以及装箱和取消装箱操作都会降低性能；在必须对大型集合进行循环访问的情况下，装箱和取消装箱的影响非常明显。”

一般的如果要返回一个集合数组会用到他。他增加了代码的可读性，通过他，前台编码的人就可以不费很大力气了解到这个字段什么意思。比如声明了一个Users实体类
public Calss Users
{
   public string Name;
   public int Age;

}这个只是代表一个用户的对象信息，如果你获取的是个用户列表的化，就可以用List<Users> usersList = new List<Users>;然后向列表里添加每个用户信息
Users users = new Users();
users.Name = "ssss";users.Age = "12";
users.add(users);
这样循环的向列表里添加信息，然后返回这个列表，在前台页面就可以用循环读出这些信息。

你可以把他看作一个对象数组
也可看作是另一种哈希表来使用
其实没什么用
就行for（；；）和foreach
写法不同而已

这个是2.0的新特征泛型，用泛型可以解决装箱拆箱问题，List<int>test =new List<int>()这样定义，test这个集合就只能放进了int数据，因此取出的时候不用（int）test[i]显式转换了。

出处：http://www.cnblogs.com/mycolour/archive/2011/06/24/2088977.html

C# List<T>用法

所属命名空间：System.Collections.Generic

public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable

List<T>类是ArrayList 类的泛型等效类。该类使用大小可按需动态增加的数组实现IList<T> 泛型接口。

泛型的好处：它为使用c#语言编写面向对象程序增加了极大的效力和灵活性。不会强行对值类型进行装箱和拆箱，或对引用类型进行向下强制类型转换，所以性能得到提高。

性能注意事项：

在决定使用IList<T> 还是使用ArrayList类（两者具有类似的功能）时，记住IList<T> 类在大多数情况下执行得更好并且是类型安全的。

如果对IList<T> 类的类型 T 使用引用类型，则两个类的行为是完全相同的。但是，如果对类型 T 使用值类型，则需要考虑实现和装箱问题。

“添加到 ArrayList 中的任何引用或值类型都将隐式地向上强制转换为 Object。如果项是值类型，则必须在将其添加到列表中时进行装箱操作，在检索时进行取消装箱操作。强制转换以及装箱和取消装箱操作都会降低性能；在必须对大型集合进行循环访问的情况下，装箱和取消装箱的影响非常明显。”

1、 List的基础、常用方法：

声明：

1、List<T> mList = new List<T>();

T为列表中元素类型，现在以string类型作为例子

E.g.： List<string> mList = new List<string>();

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

以一个集合作为参数创建List

E.g.：

string[] temArr = { "Ha", "Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", "Locu" };

List<string> testList = new List<string>(temArr);

添加元素:

1、 List. Add(T item) 添加一个元素

E.g.： mList.Add("John");

2、 List. AddRange(IEnumerable<T> collection) 添加一组元素

E.g.：

string[] temArr = { "Ha","Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", "Locu" };

mList.AddRange(temArr);

3、Insert(int index, T item); 在index位置添加一个元素

E.g.： mList.Insert(1, "Hei");

遍历List中元素:

foreach (T element in mList) T的类型与mList声明时一样

{

Console.WriteLine(element);

}

E.g.：

foreach (string s in mList)

{

Console.WriteLine(s);

}

删除元素:

1、 List. Remove(T item) 删除一个值

E.g.： mList.Remove("Hunter");

2、 List. RemoveAt(int index); 删除下标为index的元素

E.g.： mList.RemoveAt(0);

3、 List. RemoveRange(int index, int count);

从下标index开始，删除count个元素

E.g.： mList.RemoveRange(3, 2);

判断某个元素是否在该List中：

List. Contains(T item) 返回true或false，很实用

E.g.：

if (mList.Contains("Hunter"))

{

Console.WriteLine("There is Hunter in the list");

}

else

{

mList.Add("Hunter");

Console.WriteLine("Add Hunter successfully.");

}

给List里面元素排序：

List. Sort () 默认是元素第一个字母按升序

E.g.： mList.Sort();

给List里面元素顺序反转：

List. Reverse () 可以与List. Sort ()配合使用，达到想要的效果

E.g.： mList.Sort();

List清空：List. Clear ()

E.g.： mList.Clear();

获得List中元素数目：

List. Count () 返回int值

E.g.：

int count = mList.Count();

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

2、 List的进阶、强大方法：

举例用的List：

string[] temArr = { Ha","Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", " "Locu" };

mList.AddRange(temArr);

List.Find 方法：搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的第一个匹配元素。

public T Find(Predicate<T> match);

Predicate是对方法的委托，如果传递给它的对象与委托中定义的条件匹配，则该方法返回 true。当前 List 的元素被逐个传递给Predicate委托，并在 List 中向前移动，从第一个元素开始，到最后一个元素结束。当找到匹配项时处理即停止。

Predicate 可以委托给一个函数或者一个拉姆达表达式:

委托给拉姆达表达式：

E.g.：

string listFind = mList.Find(name => //name是变量，代表的是mList

{ //中元素，自己设定

if (name.Length > 3)

{

return true;

}

return false;

});

Console.WriteLine(listFind); //输出是Hunter

委托给一个函数：

E.g.：

string listFind1 = mList.Find(ListFind); //委托给ListFind函数

Console.WriteLine(listFind); //输出是Hunter

ListFind函数：

public bool ListFind(string name)

{

if (name.Length > 3)

{

return true;

}

return false;

}

这两种方法的结果是一样的。

List.FindLast 方法：搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的最后一个匹配元素。

public T FindLast(Predicate<T> match);

用法与List.Find相同。

List.TrueForAll方法： 确定是否 List 中的每个元素都与指定的谓词所定义的条件相匹配。

public bool TrueForAll(Predicate<T> match);

委托给拉姆达表达式：

E.g.：

bool flag = mList.TrueForAll(name =>

{

if (name.Length > 3)

{

return true;

}

else

{

return false;

}

);

Console.WriteLine("True for all: "+flag); //flag值为false

委托给一个函数，这里用到上面的ListFind函数：

E.g.：

bool flag = mList.TrueForAll(ListFind); //委托给ListFind函数

Console.WriteLine("True for all: "+flag); //flag值为false

这两种方法的结果是一样的。

List.FindAll方法：检索与指定谓词所定义的条件相匹配的所有元素。

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

E.g.：

List<string> subList = mList.FindAll(ListFind); //委托给ListFind函数

foreach (string s in subList)

{

Console.WriteLine("element in subList: "+s);

}

这时subList存储的就是所有长度大于3的元素

List.Take(n)： 获得前n行返回值为IEnumetable<T>，T的类型与List<T>的类型一样

E.g.：

IEnumerable<string> takeList= mList.Take(5);

foreach (string s in takeList)

{

Console.WriteLine("element in takeList: " + s);

}

这时takeList存放的元素就是mList中的前5个

List.Where方法：检索与指定谓词所定义的条件相匹配的所有元素。跟List.FindAll方法类似。

E.g.：

IEnumerable<string> whereList = mList.Where(name =>

{

if (name.Length > 3)

{

return true;

}

else

{

return false;

}

});

foreach (string s in subList)

{

Console.WriteLine("element in subList: "+s);

}

这时subList存储的就是所有长度大于3的元素

List.RemoveAll方法：移除与指定的谓词所定义的条件相匹配的所有元素。

public int RemoveAll(Predicate<T> match);

E.g.：

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之后的元素。

List<T> 是一个泛型链表...T表示节点元素类型
比如
List<int> intList;表示一个元素为int的链表
intList.Add(34); //添加
intList.Remove(34);//删除
intList.RemoveAt(0); //删除位于某处的元素
intList.Count; //链表长度
还有Insert,Find,FindAll,Contains等方法,也有索引方法 intList[0] = 23;
1.减少了装箱拆箱
2.便于编译时检查数据类型

List<Object> 就相当于 System.Collections命名空间里面的List

C#中IList与List区别

我知道IList是一个接口，而List可以实例化IList。请问，我不可以不定义接口IList么？或者在IDAL(接口中)定义List吗？必须是Ilist么？？
请大家谈谈他们之间的区别和作用？

首先IList 泛型接口是 ICollection 泛型接口的子代，并且是所有泛型列表的基接口。

  它仅仅是所有泛型类型的接口，并没有太多方法可以方便实用，如果仅仅是作为集合数据的承载体，确实，IList<T>可以胜任。

  不过，更多的时候，我们要对集合数据进行处理，从中筛选数据或者排序。这个时候IList<T>就爱莫能助了。

  1、当你只想使用接口的方法时,ILis<>这种方式比较好.他不获取实现这个接口的类的其他方法和字段，有效的节省空间．

  2、IList <>是个接口,定义了一些操作方法这些方法要你自己去实现

  List <>是泛型类,它已经实现了IList <>定义的那些方法

  IList <Class1> IList11 =new List <Class1>();

  List <Class1> List11 =new List <Class1>();

  这两行代码，从操作上来看，实际上都是创建了一个List<Class1>对象的实例，也就是说，他们的操作没有区别。

  只是用于保存这个操作的返回值变量类型不一样而已。

  那么，我们可以这么理解，这两行代码的目的不一样。

  List <Class1> List11 =new List <Class1>();

  是想创建一个List<Class1>，而且需要使用到List<T>的功能，进行相关操作。

  而

  IList <Class1> IList11 =new List <Class1>();

  只是想创建一个基于接口IList<Class1>的对象的实例，只是这个接口是由List<T>实现的。所以它只是希望使用到IList<T>接口规定的功能而已

IList是接口,定义了一个类的系列规则。
List是类，定义的实际的类代码。

List的定义语法是这样的。
[SerializableAttribute] 
public class List<T> : IList<T>, ICollection<T>, 
 IEnumerable<T>, IList, ICollection, IEnumerable

所以，List可以作到以下实例化方式：
List<string> list = new List<string>();
IList<string> list = new List<string>();
ICollection<string> list = new List<string>();
IEnumerable<string> list = new List<string>();
IList list = new List<string>();
ICollection list = new List<string>();
IEnumerable list = new List<string>();

但是呢。List没实现IDAL接口，所以没办法作到“IDAL dal = new List<string>();”这样的实例声明。

以上是List的声明方式，而IList呢，只要实现了IList接口的所有类都可以实例化成IList，包括你自定义的实现了IList接口的类。

不是必须的，你可以使用List，也可以IEnumerable。这不是必须的，关键是看你怎么设计接口。

探讨Ilist<>与List<>

首先要了解一点的是关于接口的基础知识：

接口不能直接实例化
但是接口派生出来的抽象类可以实例化
所有派生出来的抽象类都可以强制转换成接口的实例

第三条我解释一下：比如，IList <Class> IList11 =new List <Class>(); 也就是接口派生出来的抽象类可以转换为接口的实例，这也是常说的里氏替换原则（子类对象可以代替父类对象,但其父类对象不能代替子类对象）

首先，List<T>是一个类，IList<T>是一个接口。接口和类的区别是本质的，类是负责功能的实现,而接口则是负责功能的定义。所以它们的区别本质上也就是类和接口的区别。

具体来说，IList 泛型接口是 ICollection 泛型接口的子代，并且是所有泛型列表的基接口。它仅仅是所有泛型类型的接口，并没有太多方法可以方便实用，如果仅仅是作为集合数据的承载体，那么使用IList<T>完全可以胜任。但是更多的时候，我们要对集合数据进行处理，从中筛选数据或者排序。这个时候IList<T>就爱莫能助了。

1、当你只想使用接口的方法时,ILis<>这种方式比较好.他不获取实现这个接口的类的其他方法和字段，有效的节省空间．

2、IList <>是个接口,定义了一些操作方法这些方法要你自己去实现

List <>是泛型类,它已经实现了IList <>定义的那些方法

IList <Class1> IList11 =new List <Class1>(); //这里是第三条规则的体现，实现低耦合，毕竟接口属最底层吧。IList1对象可以指向任意一个IList接口的实现

List <Class1> List11 =new List <Class1>();

这两行代码，从操作上来看，实际上都是创建了一个List<Class1>对象的实例，也就是说，他们的操作没有区别。

只是用于保存这个操作的返回值变量类型不一样而已。

那么，我们可以这么理解，这两行代码的目的不一样。

List <Class1> List11 =new List <Class1>();

是想创建一个List<Class1>，而且需要使用到List<T>的功能，进行相关操作。

而

IList <Class1> IList11 =new List <Class1>();

只是想创建一个基于接口IList<Class1>的对象的实例，只是这个接口是由List<T>实现的。所以它只是希望使用到IList<T>接口规定的功能而已。

再举一个例子，比如你要实现一个集合类，但是你认为添加的时候要做一下判断，不能重复，你可以这样做：

//方法1:

public class MyCollection1 : List<MyItem>

{

public new void Add(MyItem item)

{

if (this.Contains(item)) return;

base.Add(item);

}

}

//方法2:

public class MyCollection2 : IList<MyItem>

{

private List<MyItem> innerList = new List<MyItem>();

public void Add(MyItem item)

{

if (this.Contains(item)) return;

base.Add(item);

}

//实现n多的方法后，附带的，有个Add方法，实现即可，实现方法略

}

如果是从List继承而来，那我如果这样写，就能跳过检查了。但是不会调用你写的Add方法，而是调用List的Add方法。

MyCollection1 mc1 = new MyCollection1();

.....

System.Collection.IList listData = mc1;

listData.Add(listData[0]);

这样就不会执行你写的检查代码。但如果用下面方法，则会执行你写的Add方法：

MyCollection2 mc2 = new MyCollection2();

.....

System.Collection.IList listData = mc2;

listData.Add(listData[0]);

总之，正如那些高手说的：

接口实现低耦合...有利于系统的维护与重构...优化系统流程...

鼓励使用接口

这样可以实现功能和具体实现的分离

实现接口分离的原则

不是看实际需要用的

另外在提供一个datatable转list<>的代码：

public IList<T> GetList<T>(DataTable table)
{
IList<T> list = new List<T>(); //里氏替换原则
T t = default(T);
PropertyInfo[] propertypes = null;
string tempName = string.Empty;
foreach (DataRow row in table.Rows)
{
t = Activator.CreateInstance<T>(); 创建指定类型的实例

propertypes = t.GetType().GetProperties(); //得到类的属性
foreach (PropertyInfo pro in propertypes)
{
tempName = pro.Name;
if (table.Columns.Contains(tempName.ToUpper()))
{
object value = row[tempName];
if (value is System.DBNull)
{
value = "";
}
pro.SetValue(t, value, null);
}
}
list.Add(t);
}
return list;
}

其中 T t = default(T); //就是返回T的默认值。比如说T的类型是int类型的，那么这个default(T)的值就是0的；如果是string类型的话，这个返回值就是“”空字符串的。

List<T>的使用

定义：List<T>类表示可通过索引访问的对象的强类型列表，提供用于对列表进行搜索、排序和操作的方法。

作用：
泛型最常见的用途是泛型集合
我们在创建列表类时，列表项的数据类型可能是int,string或其它类型，如果对列表类的处理方法相同，
就没有必要事先指定数据类型，留待列表类实例化时再指定。相当于把数据类型当成参数，这样可以最
大限度地重用代码，保护类型的安全以及提高性能。

List的一般用法
所属命名空间: System.Collections.Generic
public class List<T>:IList<T>,Icollection<T>,IEnumerable<T>,IList,Icollection,Ienumerable
List<T>是ArrayList类的泛型等效类，该类使用大小可按需动态增加的数组实现IList<T>泛型接口

(1)声明 List<T>mlist = new List<T>();
eg: string[] Arr = {"a","b","c"};
List<string> mlist = new List<string>(Arr);

(2)添加一个元素 List.Add(T item)　
eg: mlist.Add("d");

(3)添加集合元素
eg: string[] Arr2 ={"f","g"."h"};
mlist.AddRange(Arr2);

(4)在index位置添加一个元素 Insert(int index,T item)
eg: mlist.Insert(1,"p");

(5)遍历List中元素

　　foreach(T element in mlist) T的类型与mlist声明时一样
　　　　　{
　　　　　　 Console.WriteLine(element);
}

    eg:
    foreach(string s in mlist)
          {
             Console.WriteLine(s);
           }

(6)删除元素

List.Remove(T item) 删除一个值
eg: mlist.Remove("a");

    List.RemoveAt(int index);删除下标为index的元素
    eg: mlist.RemoveAt(0);

    List.RemoveRange(int index,int count);　下标index开始，删除count个元素
    eg：mlist.RemoveRange(3,2);

(7)判断某个元素是否在该List中

    List.Contains(T item)　返回true或false
    eg:
    if(mlist.Contains"("g"))
       Console.WriteLine("g存在列表中");
    else
       mlist.Add("g");

(8)给List里面元素排序 List.Sort()　默认是元素每一个字母按升序
eg: mlist.Sort();

(9)给List里面元素顺序反转 List.Reverse() 可以与List.Sort()配合使用

(10)List清空 List.Clear()
eg: mlist.Clear();

(11)获得List中元素数目 List.Count()　返回int值
eg: mlist.count();

List进阶，强大方法

(1)List.FindAll方法：检索与指定谓词所定义的条件相匹配的所有元素

    class program
    {
       static void Main(stirng[] args)
       {
         student stu = new student();
         stu.Name="arron";
         List<student> students= new List<student>();
         students.Add(stu);
         students.Add(new student("candy"));
         FindName myname = new FindName("arron");
         foreach(student s in students.FindAll(new Predicate<student>(myname.IsName)))
         { Console.WriteLine(s);}
       }

    public class student
    {
       public string Name{get;set;}
       public student(){}
       public override string ToString()
        {
            return string.Format("姓名:{0}",Name);
         }
     }

    public class FindName
    {
      private string _name;
      public FindName(string Name)
      { this._name=Name;}
      public bool IsName(student s)
       { return (s.Name==_name)?true:false;}
    }

(2)List.Find方法　搜索与指定谓词所定义的条件相匹配的元素，并返回整个List中的第一个匹配元素

　 eg:

//Predicate是对方法的委托，如果传递给它的对象与委托定义的条件匹配，则该方法返回true,当前List的元素
　　被逐个传递给Predicate委托，并在List中间前移动，从第一个元素开始，到最后一个元素结束，当找到匹配项
　　时处理停止

　　第一种方法委托给拉姆达表达式：
　　eg:　　
     string listFind = mlist.Find(name=>
       {
          if(name.length>3)
             return true;
          return false;
       });

    第二种方法　委托给一个函数
    eg:
     public bool ListFind(string name)

{

if (name.Length > 3)

{

return true;

}

return false;

}

这两种方法的结果是一样的

(3) List.FindLast方法 public T FindLast(Predicate<T> match);确定是否 List 中的每个元素都与指定的谓词所定义的条件相匹配。用法与List.Find相同。

(4) List.TrueForAll方法：确定是否 List 中的每个元素都与指定的谓词所定义的条件相匹配。

public bool TrueForAll(Predicate<T> match);