C#常用方法——List<T>泛型列表解析

//示例代码如下：
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>
            //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;
        }
    }
}

1、简介

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

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

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

性能注意事项： List[T]两点优势

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

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

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

 

2、声明

//T为列表中元素类型
List<T> List = new List<T>();

//当T为string时,举例：
string[] nameArr = { "Ha", "Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", "Locu" };

List<string> list = new List<string>(nameArr);

3、添加

//添加一个元素
list. Add("lucy");
//添加一组元素
string[] temArr = { "Ha","Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku",  "Locu" };
list.AddRange(temArr);
//插入元素
list.Insert(1, "Hei");

4、遍历元素(foreach)

foreach (string name in list)
{
    Console.WriteLine(name);
}

5、删除、清空元素

//删除一个值
list.Remove("Hunter");
//删除下标为index的元素
list.RemoveAt(0);
//从下标3开始，删除2个元素
list.RemoveRange(3, 2);
//清空元素
list.Clear();

 

6、Contains(是否包含某个元素)

bool blog = list.Contains("Hunter");

 

7、排序Sort,倒序Reverse

//默认是元素第一个字母按升序
list.Sort();
//将List里面元素顺序反转
list.Reverse();
//从第二个元素开始，反转4个元素
//结果list里最后的顺序变成"Ha", "Jay", "Lily", "Tom", "Hunter", "Jim", "Kuku",  "Locu"
list.Reverse(1,4);