C#泛型列表List<T>基本用法总结

转自:http://space.itpub.net/14466241/viewspace-624132

 

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的容器大小,默认是0,只要有元素加入是,会自动扩展到4,如果第5个元素加入时,就变成了8,第9个加入,就成16
          //可以看出,总是成倍的增长,扩展时要重新开辟内存,这样会影响效率,如果事先知道元素个数,或者可能个数,最好给个尽量大的权衡值
          //我们加入3个元素,设容器大小为4.注:设为4不是指只能放4个元素,如果超出,一样也会成倍扩展,这样做只是为了尽量扩展带来的开销
          List<Person> list = new List<Person>(4);
         
          list.Add(p1);
          list.Add(p2);
          list.Add(p3);

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

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

          // 1 初始化集合器

          // C#3.0开始,提供了初始化功能,但是并没有反应到IL代码中,在IL中,一样也是把个转化成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);例用委托做为参数  
          //我们Lamada表达式实现
          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();
      }

10. 排序:

            List<string> lstTmp = new List<string>();
            lstTmp.AddRange(PMTCommon.GetITList());
            lstTmp.AddRange(PMTCommon.GetDesignerList());          
            lstTmp.Sort();

11. 去掉重复元素:

            List<string> lstTmp = new List<string>();
            lstTmp.AddRange(PMTCommon.GetITList());
            lstTmp.AddRange(PMTCommon.GetDesignerList());
            lstTmp = lstTmp.Distinct().ToList<string>();
            lstTmp.Sort();

12. 拼接

static void Main(string[] args)
{
 List<string> strList = new List<string>()
{
 "Jake", "Brian", "Raj", "Finnie", "Carol"
 };
 
 string str = string.Join(";", strList.ToArray());
 
 Console.WriteLine(str);
 Console.ReadLine();
}
 

OUTPUT

image


13.Convert string array to List<string>

string[] arrStr = {"Jake", "Brian", "Raj", "Finnie", "Carol" };
 List<string> strList = new List<string>(arrStr.Length);
strList.AddRange(arrStr);

      //为了比较写的委托实现方法
      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;
      }
  }
}

12.List<object> to List<string>

第一种方法:
List<object> objects = new List<object>();
var strings = (from o in objects select o.ToString()).ToList(); 

 第二种方法:

List<object> objects = new List<object>();
List<string> strList = objects.ConvertAll(obj => obj.ToString()); 
13.IList<T> 与List<T> 之间的相互转换
   13.1 将List<T>转化为IList<T>
    private IList<T> ConvertToIList(System.Collections.Generic.List<T> listObjects)
    {
        IList<T> convertedList = new List<T>();
        foreach (T listObject in listObjects)
        {
            convertedList.Add(listObject);
        }
        return convertedList;
    }
譬如:
    private IList<adminListInfo> ConvertToIList(System.Collections.Generic.List<adminListInfo> listObjects)
        {
            IList<adminListInfo> convertedList=new List<adminListInfo>();
            foreach (adminListInfo listObject in listObjects)
            {
                convertedList.Add(listObject);
            }
            return convertedList;
        }
      13.2 将IList<T> 转化为List<T>
private List<T> Convert(System.Collections.IList listObjects)
{
    List<T> convertedList = new List<T>();
    foreach (object listObject in listObjects)
    {
        convertedList.Add((T)listObject);
    }
    return convertedList;
}
 
 /// <summary>
    /// 转换IList<T>为List<T>
    /// </summary>
    /// <typeparam name="T">指定的集合中泛型的类型</typeparam>
    /// <param name="gbList">需要转换的IList</param>
    /// <returns></returns>
    public static List<T> ConvertIListToList<T>(IList gbList) where class
    {
        if (gbList != null && gbList.Count > 1)
        {
            List<T> list = new List<T>();
            for (int = 0< gbList.Count; i++)
            {
                temp = gbList[i] as T;
                if (temp != null)
                    list.Add(temp);
            }
            return list;
        }
        return null;
    }
 
 
 
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值