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

C#泛型列表List<T>基本用法总结,布布扣,bubuko.com

时间： 2024-08-08 09:34:07

C#泛型列表List<T>基本用法总结的相关文章

列表迭代器ListIterator的用法

ListIterator的父接口是Iterator,是List接口中特有的迭代器. ListIterator在Iterator的基础上,又新添了很多方法: Iterator中的方法: 1.判断是否有下一个元素:hasNext(); 2.获取下一个元素:            next(); 3.删除迭代器指向的元素:remove(); ListIterator新添的方法: 4.判断是否有前一个元素:hasPrevious(); 5.获取前一个元素:            previous();

关于C#泛型列表List&lt;T&gt;的基本用法总结

//示例代码如下:using System;using System.Collections.Generic;using System.Collections.ObjectModel;namespace linqs{    class Program    {        static void Main(string[] args)        {            //using System.Collections.Generic; 命名空间中的List<T>          

C#中泛型容器Stack&lt;T&gt;的用法，以及借此实现&rdquo;撤销/重做&rdquo;功能

.Net为我们提供了众多的泛型集合.比如,Stack<T>先进后出,Queue<T>先进先出,List<T>集合元素可排序,支持索引,LinkedList<T>,双向链表的泛型实现,不支持索引;ISet<T>不允许被复制,他有2个实现,一个是HashSet<T>,不维持集合元素的排序,另一个是SortedSet<T>,支持集合元素的排序;IDictionary<TKey, TValue>是一个字典集合的泛型接口

python列表与元组的用法

目录: 列表的用法: 1.增   append   +    extend 2.删  del    remove 3.改   insert 4.查  index 5.反向  reverse 6.排序   sort 元组的用法: count:计算某个元素出现的个数 index:查 1.列表的用法 成绩管理系统 方法一: #列表 成绩管理系统 n=int(input("请输入学生人数:")) list1=[] for i in range(n): #循环把输入的数加入到列表 name=in

JAVA 泛型通配符 ? EXTENDS SUPER 的用法

1. <? extends Hero> ArrayList heroList<? extends Hero> 表示这是一个Hero泛型或者其子类泛型heroList 的泛型可能是HeroheroList 的泛型可能是APHeroheroList 的泛型可能是ADHero所以 可以确凿的是,从heroList取出来的对象,一定是可以转型成Hero的 但是,不能往里面放东西,因为放APHero就不满足<ADHero>放ADHero又不满足<APHero> 2.

Python数据结构之列表元组字典的用法

数据结构的含义 在学习数据结构之前,我们先来了解下数据结构的含义.数据结构是通过某种方式(例如对元素进行编号)组织在一起的数据元素的集合,这些数据元素可以是数字或者字符,甚至可以是其他数据结构.在Python语言中,最基本的数据结构是序列(sequence).序列中的每个元素被分配一个序号----即元素的位置,称为索引或下标,索引从0开始递增. 典型的序列包括列表.元组和字符串.其中,列表是可变的(可修改),而元组和字符串是不可变的(一旦创建了就是固定的).列表.元组和字符串也是较常用的数据结构

比较两个泛型列表，取得不同项

1 public static List<T> GetModiflyList<T>(List<T> newList, List<T> oldList, string keyField) 2 { 3 List<T> list = new List<T>(); 4 foreach (T newModel in newList) 5 { 6 object nob = newModel.GetType().GetProperty(keyFie

C# List泛型集合中的GroupBy&lt;&gt;用法

[csharp] view plain copy print? //根据子项目id得到flowjump实体类 flowJumps = this.FlowJumps; //按工序groupby flowjumps IEnumerable<IGrouping<int, FlowJump>> query = flowJumps.GroupBy(pet => pet.processID, pet => pet); foreach (IGrouping<int, FlowJ

Swift泛型协议的N种用法

1.https://www.cnblogs.com/manupstairs/p/5960992.html 2.https://www.jianshu.com/p/a6bcdebd83f5 原文地址:https://www.cnblogs.com/sundaysme/p/11477456.html