关于C#泛型列表List的基本用法总结

示例代码如下：
namespace samplelistt
{
  class program
  {
      static void main(string[] args)
      {
//using system.collections.generic; 命名空间中的list<t>
//using system.collections;　命名空间中的arraylist 
//都实现了列表集合，一个是泛形集合，一个是非泛型的
//下面我们将person对象加到集合中

person p1 = new person( "aladdin" , 20 );
person p2 = new person("zhao", 10);
person p3 = new person("jacky", 40);

//如果不制定list的容器大小，默认是０,只要有元素加入是，会自动扩展到４,如果第５个元素加入时，就变成了８,第９个加入，就成１６
//可以看出，总是成倍的增长，扩展时要重新开辟内存，这样会影响效率，如果事先知道元素个数，或者可能个数，最好给个尽量大的权衡值
//我们加入３个元素，设容器大小为４.注：设为４不是指只能放４个元素，如果超出，一样也会成倍扩展，这样做只是为了尽量扩展带来的开销
list<person> list = new list<person>(4);

list.add(p1);
list.add(p2);
list.add(p3);

//本方法是清除多于的没有用的内存空间，例：如果开辟大小为１００,而我们只用了４个，其余的放着，是不是很浪费　
//本方法调用时会检查元素个数是不是占到了容器大小的９０％以上，如果是，则不进行回收．
list.trimexcess();

//arraylist方法与list<>用法一样，不同的是，它是对象集合，参数是object这样会有装箱拆箱的可能，尽量用list<>
//本处不再做演示

// 1 初始化集合器
// c#3.0开始，提供了初始化功能，但是并没有反应到ｉｌ代码中，在ｉｌ中，一样也是把个转化成add方法来调用
list<int> l2 = new list<int>() { 1 ,2 ,3 ,4 ,5 };

// 2 添加元素 addrange() 本方法可以一次性添加一批对象
list<person> lists = new list<person>(10);
//参数是一个必须可能跌代的对象,也可是数组 
list.addrange( new person[] { new person( "aladdin" ,20) , new person("zhao",6)});
 

//构造传入批量参数 ,与addrange效果一样
list<person> mylist = new list<person>(new person[] { new person( "aladdin" ,20) , new person("zhao",6)});

// 3 插入元素
// 使用insert()方法,可以在指定位置插入元素
// 例 我们在1位置插入 则最后变成了 aladdin jacky zhao..插入意思就是,这个位我占了,以前占这位的和他之后的,通通往后移一位
mylist.insert( 1 , new person( "jacky" , 88 ));

foreach (person p in mylist)
{
    console.writeline(p.name);
}

// 4 访问元素
// arraylist 与 list<t>都是提供了索引器来访问的
console.writeline( "----------------访问元素------------------------");

for (int i = 0; i < mylist.count; i++)
{
    console.writeline(mylist[i].name);
}
//还可以使用foreach跌代器来实现,些处不再举例

//使用foreach方法
//public delegate void action<t>(t obj);例用委托做为参数 
//些处我们用呀妈day表达式实现
console.writeline( "-----------------用foreach方法输出------------------------");

mylist.foreach( param => console.writeline(param.name) ) ;

// 5删除元素
//删除元素可以使用removeat()直接传入索引器值
//将第一个元素直接删除
mylist.removeat(0);
//也可以将要删除的元素传给remove方法

list<person> lists2 = new list<person>(10);

person per1 = new person( "aladdin" , 100 );
person per2 = new person("zhao", 100);
person per3 = new person("jacky", 100);

lists2.add(per1);
lists2.add(per2);
lists2.add(per3);

lists2.remove(per3);

console.writeline( "-------删除后的元素---------");

foreach (person per in lists2)
{
    console.writeline(per.name);
}
//从结果可以看出 名称为jacky的元素被删除了
//下面说一下remove方法的删除过程 
// 用indexof方法确定出对象的索引,然后按索引删除
// 在indexof方法内,首先检查元素是不是实现了iequatable接口,如果是,就调用这个接口中的equals方法
// 如果没有实现,则调用object中的equals方法比较元素(也就是址址比较)
// 以上我们删除per3,很显明显一个地址,所以被删除了 

// 下面我们改装了person ,实现了iequatable<person>,在比较方法中,始终返回false , 则per3会比较失败,不会被删除
// 结果3个都在
// 如果要删除对象,最好使用索引直接删除,因为remove方法经历了一系列过程后,最后才按索引删除!

// removerange()删除一个范围
// 第一个参数 开始位置 第二个 个数
//lists2.removerange( 1 , 2 );
//console.writeline( "批量删除后----------------");

//foreach (person per in lists2)
//{
//    console.writeline(per.name);
//}

// 6 搜索
// 搜索有很多种方式,可以使用indexof lastindexof findindex findlasindex find findlas ,如果只是查看元素存不,可以使用exists()方法
// indexof() 方法 需要将一个对象做参数, 如果打到,就返回本元素在集合中的索引,如果找不到就返回-1,indexof还可以使用iequatable接口来比较元素

list<person> ls3 = new list<person>(10);

person person1 = new person("aladdin", 100);
person person2 = new person("zhao", 100);
person person3 = new person("jacky", 100);

ls3.add(person1);
ls3.add(person2);
ls3.add(person3);

// 为了使用默认的地址比较,我们把person的接口暂时去掉
int index = ls3.indexof(person3);
console.writeline( "per3 的索引:" + index); //2
// 还可以指定搜索范围 从第3个开始,范围长度是1
int index2 = ls3.indexof(person3,2,1);
console.writeline(index2);
//iequatable比较方法前面已经写过,不再举例

// findindex()方法是用来搜索带有一定特性的元素
// 例用委托做参数  public delegate bool predicate<t>(t obj);

int index3 = ls3.findindex(param => param.name.equals("jacky"));
console.writeline( index3 );// 2
// findlastindex是从后面查第一个出现的元素,因为我们这里没有重复元素,所以体现不出他只查找一个,就停下来的效果
int index4 = ls3.findlastindex(p => p.name.equals("aladdin"));
console.writeline(index4);
// find方法与findindex方法用法一样,不同的是,它返回的是元素本身
person ppp = ls3.find( p => p.name.equals("jacky")) ;
console.writeline(ppp);

// 如果要查找所有的匹配元素,而不是找到第一个就停下来,就使用findall方法
// 我们查找所有年纪等于100的对象,3个都符合
list<person> newlist = ls3.findall(p => p.age == 100);

console.writeline( "----------查找所有---------");

foreach (person p in newlist)
{
    console.writeline(p.name);
}

// 7 排序
// list可以例用sort方法排序,实现算法是快速排序
// 本方法有好几个重载

//public void sort(); //只对元素实现了icomparable才能使用这个方法 ,如果实现了则,可以直接调用一次sort之后,就排好序了
//public void sort(comparison<t> comparison); //我们的person并没有实现那个接口,所以要用泛型委托当参数的方法
//public void sort(icomparer<t> comparer); //泛型接口当参数 public delegate int comparison<t>(t x, t y);
//public void sort(int index, int count, icomparer<t> comparer); //可以指定范围

list<person> ls4 = new list<person>(10);

person person4 = new person("aladdin", 100);
person person5 = new person("zhao", 33);
person person6 = new person("jacky", 44);

ls4.add(person4);
ls4.add(person5);
ls4.add(person6);

ls4.sort(mycomparfunc);
console.writeline( "-------------排序后的-------------");

foreach (person p in ls4)
{
    console.writeline(p.name+ p.age );
}

console.writeline( "--------颠倒循序------------------");
ls4.reverse();

foreach (person p in ls4)
{
    console.writeline(p.name+ p.age);
}

// 8 类型转换
//可以将集合中的元素转换成任意类型的元素,比如,我们要将集合中的person转换成为racer对象racer只包含名字,没有年纪
// public list<toutput> convertall<toutput>(converter<t, toutput> converter);
// public delegate toutput converter<tinput, toutput>(tinput input);  委托参数
list<racer> ls5 = ls4.convertall<racer>((input) => new racer(input.name)) ;

console.writeline( "-----------转换后的玩意--------");
foreach (racer r in ls5)
{
    console.writeline(r.name);
}

// 9 只读集合
// 在创建完集合以后,肯定是可读写的,如果不是,他就不能再添加新元素了,但是,如果是认为填充完毕,不要再做修改.
// 可以使用只读集合,使用asreadonly方法() 返回readonlycollection<t>类型,它与list<>操作是一样的,但是一但有修改集合的操作,就会刨出异常
// 他屏蔽了通常的add等方法

readonlycollection<racer> persss =  ls5.asreadonly();

console.writeline("输出只读集合");

foreach (racer r in persss)
{
    console.writeline(r.name);
}

console.readline();

      }

//为了比较写的委托实现方法
public static  int mycomparfunc(person p1, person p2)
      {
if (p1.age == p2.age)
{
    return 0;
}
else if (p1.age > p2.age)
{
    return 1;
}
else
{
    return -1;
}
      }
  }

//two helper classes
 class person//:iequatable<person>
  {
      public string name;
      public int age;

      public person( string name , int age )
      {
         this.name= name;
this.age = age;
      }

      ////始终给一个false值
      //public bool equals(person other)
      //{
      //    return false;
      //}

  }

  class racer
  {
      public string name;

      public racer(string name)
      {
         this.name= name;
      }
  }
}