《随笔三十一》——C#中的 “ 解析 泛型 “ List 类 ” 中的方法和属性”

目录

List Constructors

使用 List() 默认构造函数：

List(Int32)

List(IEnumerable)

Propertys

List.Capacity 

List.Count 

Methods

List.Add

List.AddRange(IEnumerable)

List.BinarySearch

List.Clear 

List.Contains(T)

List.CopyTo 

List.IndexOf 

List.Insert

List.InsertRange

List.LastIndexOf

List.Remove(T)

List.RemoveAt(Int32)

List.RemoveRange

List.Reverse

List.Sort 

List.ToArray

List.TrimExcess

---

点击这里进入官网了解更多信息

该类在 System.Collections.Generic 命名空间。

List 类 的特点：

• 是一个强类型的集合, 类型参数 T 指定列表中元素所允许的类型。
• 可以动态添加和删除元素,也可以在某个位置插入新元素。
• 支持通过索引访问元素,也支持对元素的查找操作。

---

List Constructors

---

使用 List() 默认构造函数：

public List ();

        static void Main(string[] args)
        {
            List dinosaurs = new List();  // 使用默认构造函数初始化，该实例为空并且具有默认初始容量。      
            Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Compsognathus");
            Console.WriteLine("输出dinosaurs 中所有的元素:");
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
            Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
            Console.WriteLine("Count: {0}", dinosaurs.Count);         
        }

Output:

Capacity: 0
输出dinosaurs 中所有的元素:
Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

Capacity: 8
Count: 5

• 使用默认的构造函数创建一个空列表。元素添加到列表中后, 列表的容量就会初始化扩大为可容纳4 ,个元素。
• 如果添加了第5个元素, 列表的大小就重新设置为包含8个元素。
• 如果8个元素还不够, 列表的大小就重新设置为包含16个元素。
• 每次都会将列表的容量重新设置为原来的2倍。
• 当列表的中的容量重新分配的时候，它会创建一个新的数组，使用Array.Copy()方法将旧数组中的元素复制到新数组中。

如果事先知道要存储的数据的个数，就可以利用列表的构造函数指定列表初始的容量大小

List(Int32)

public List (int capacity);

• capacity 是 该对象最初可以存储的元素数。
• 如果 capacity 小于 0。 抛出 ArgumentOutOfRangeException

        static void Main(string[] args)
        {
            List dinosaurs = new List(5);
            Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Deinonychus");
            Console.WriteLine();
            foreach (string s in dinosaurs)
            {
                Console.WriteLine(s);
            }
            Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

List(IEnumerable)

public List (System.Collections.Generic.IEnumerable collection);

• collection ： 表示一个集合，其元素被复制到List 对象中。
• 如果 collection 为 null。抛出  ArgumentNullException

        static void Main(string[] args)
        {        
            List dinosaurs1 = new List(5) { "adas","huang", "cheng","tao"};        
            List dinosaurs = new List(5) { 5, 6, 7, 8, 9, 112 };
            Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);          
            Console.WriteLine();
            foreach (var s in dinosaurs)
            {
                Console.WriteLine(s);
            }
            Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
        }

输出：
Capacity: 10

5
6
7
8
9
112

Capacity: 10

        static void Main(string[] args)
        {
            string[] input = { "Brachiosaurus", "Amargasaurus","Mamenchisaurus" };

            List dinosaurs = new List(input) { "huang","cheng","tao"}; // 注意这里初始化方法
            Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Compsognathus");
            dinosaurs.Add("Compsognathus");
            dinosaurs.Add("Compsognathus");

            Console.WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
            Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
        }

输出：

Capacity: 6

Brachiosaurus
Amargasaurus
Mamenchisaurus
huang
cheng
tao
Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus
Compsognathus
Compsognathus

Capacity: 24

---

Propertys

---

List.Capacity 

public int Capacity { get; set; }

• 获取或设置内部数据结构在不重新分配内存的情况下可以容纳的元素总数。
• 如果 Capacity 已设置为一个小于 Count 的值。抛出  ArgumentOutOfRangeException
• 当系统上没有足够的可用内存。抛出 OutOfMemoryException

        static void Main(string[] args)
        {
            List dinosaurs = new List();

            Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Compsognathus");
            Console.WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }

            Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
            Console.WriteLine("Count: {0}", dinosaurs.Count);
        }

• Capacity 是的元素数的 List 在需要调整大小之前可以存储的最大元素数，而Count是当前  List 中实际存储的元素个数。
• Capacity 始终大于或等于Count。 如果 Count 在添加元素时超出 Capacity，则在复制旧元素和添加新元素之前，通过自动重新分配内部数组来增加容量。
• 如果Capacity 明显大于Count 并且希望减少 List 使用的内存，则可以通过调用 TrimExcess 方法或通过将 Capacity 属性显式设置为较低的值来减少容量。 当显式设置 Capacity 的值时，还会重新分配内部数组以容纳指定的容量，并复制所有元素。

List.Count 

获取 List 中包含的元素数。

public int Count { get; }

检索此属性的值的运算复杂度为 O(1)。

---

Methods

---

List.Add

public void Add (T item);

• 将对象添加到 List 的结尾处。 对于引用类型，该值可以为 null。
• 如果 Count 已经等于Capacity，则通过自动重新分配内部数组来增加List的容量，并在添加新元素之前将现有元素复制到新数组。
• 如果Count小于Capacity，则此方法为O（1）操作。 如果需要增加容量以容纳新元素，则此方法变为O（n）操作，其中n为Count。

List.AddRange(IEnumerable)

public void AddRange (System.Collections.Generic.IEnumerable collection);

• 将指定集合的元素添加到 List 的末尾。 集合本身不能为null，但如果类型 T 是引用类型，则它可以包含 null 的元素。
• 如果 collection 为 null。抛出 ArgumentNullException

        static void Main(string[] args)
        {
            string[] input = { "Brachiosaurus", "Amargasaurus","Mamenchisaurus" };
            List dinosaurs = new List() {"huang","cheng","tao"};
            Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);                  
            dinosaurs.AddRange(input); // 这里用一个集合为 dinosaurs 对象添加元素
            Console.WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
        }

List.BinarySearch

使用二分查找算法来查找在已排序的List 中的特定元素或其中的一部分。

BinarySearch(T)

public int BinarySearch (T item);

使用默认比较器在整个已排序的List 内查找元素，并返回该元素的从零开始的索引。否则为一个负数，该负数是大于 item 的下一个元素的索引的按位求补。如果没有更大的元素，则为 Count 的按位求补。

        static void Main(string[] args)
        {
            List dinosaurs = new List();

            dinosaurs.Add("Pachycephalosaurus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Deinonychus");
            Console.WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
            Console.WriteLine("\nSort");
           dinosaurs.Sort(); // dinosaurs 必须是已排序的，才能使用 BinarySearch

            Console.WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }  
            int index = dinosaurs.BinarySearch("Deinonychus");
            WriteLine(index);
        }

• 如果List多个元素具有相同的值，该方法将 返回其中的任何一个匹配元素，不一定是第一个匹配元素。
• 此方法为 O (log n) 操作，其中n是范围中的元素数。

List.Clear 

public void Clear ();

从 List 中移除所有元素。

此方法为 O (n) 操作，其中n是Count。

        static void Main(string[] args)
        {
            List dinosaurs = new List();
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Pachycephalosaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Deinonychus");
            Console.WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
            dinosaurs.Clear();
            WriteLine(dinosaurs.Count);
            WriteLine(dinosaurs.Capacity);
          }

List.Contains(T)

public bool Contains (T item);

• 确定 item 元素 是否在 List 中。 对于引用类型，该值可以为 null。如果在List 中找到item，则返回true; 否则，false。
• 该方法执行线性搜索;因此，这个方法是一个O(n)操作，其中n是Count。

        static void Main(string[] args)
        {
            List dinosaurs = new List();
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Pachycephalosaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Deinonychus");
            Console.WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
            dinosaurs.Sort();
           if(dinosaurs.Contains("Deinonychus"))
            {
                WriteLine("dinosaurs 对象中包含此元素！");
                WriteLine($"查看此元素在 dinosaurs 中的下标位置：{dinosaurs.BinarySearch("Deinonychus")}");
            }

List.CopyTo 

该操作有重载形式 

public void CopyTo (T[] array);

• 把List 对象中的元素复制到 目标数组 array 中。  记住 List 的元素类型 要和 目标数组中的 元素类型要一致。
• 如果 参数 array 为 null。抛出 ArgumentNullException
• 如果 源 List 中的元素个数大于目标 array 可以包含的元素个数。抛出 ArgumentException
• 此方法使用 Array.Copy 把 List 中的元素 拷贝到 目标数组中。
• 此方法为 O (n) 操作，其中n是Count。

      static void Main(string[] args)
        {
            List dinosaurs = new List();

            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Brachiosaurus");
            dinosaurs.Add("Compsognathus");

            Console.WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
        
            string[] array = new string[5];

            dinosaurs.CopyTo(array);         

            Console.WriteLine("\nContents of the array:");
            foreach (string dinosaur in array)
            {
                Console.WriteLine(dinosaur);
            }
        }

List.IndexOf 

public int IndexOf (T item);

• 看 item（ 对于引用类型，该值可以为 null ）是否在 List对象中，如果存在， 返回 item 在 List 对象中第一个字符的索引。若没找到，返回 -1.
• List 的搜索是从第一个元素开始，搜索到最后一个元素结束。
• 此方法执行线性搜索;因此，此方法为 O (n) 操作，其中n是Count。

        static void Main(string[] args)
        {
            List dinosaurs = new List();

            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Brachiosaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Compsognathus");

            Console.WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
            Console.WriteLine(dinosaurs.IndexOf("Compsognathus")); // 输出 索引6         
        }

---

public int IndexOf (T item, int index);

•  返回 List 中 从 index 索引开始直到  List 的末尾， 看是否 有跟 item （ 对于引用类型，该值可以为 null）匹配的元素。 若有，返回 item  在  List 中的索引； 否则， 返回 -1。
• 如果 参数 index 超出了 List 的有效索引范围。抛出  ArgumentOutOfRangeException

        static void Main(string[] args)
        {
            List dinosaurs = new List();

            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Brachiosaurus");
            dinosaurs.Add("Deinonychus");
          
            dinosaurs.Add("Compsognathus");

            Console.WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
            // 返回索引3
            Console.WriteLine("\nIndexOf(\"Tyrannosaurus\", 3): {0}",dinosaurs.IndexOf("Tyrannosaurus", 3)); 
        }

---

public int IndexOf (T item, int index, int count);

• 返回从 index 下标开始 到 item + count -1 这个下标范围内查找是否在  List 中 有跟 item 匹配的元素， 若有， 返回 item 在  List 中的下标位置。  否则， 返回 -1。
• item的 值如果是引用类型，该值可以为 null。

• 如果参数 index 超出了 List 的有效索引范围。或 - count 小于 0。或 - index 和 count 未在 List 中指定有效部分。都会抛出 ArgumentOutOfRangeException 

       static void Main(string[] args)
        {
            List dinosaurs = new List();
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");          
            dinosaurs.Add("Brachiosaurus");          
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Compsognathus");

            Console.WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
            // 返回 -1
            Console.WriteLine("\nIndexOf(\"Tyrannosaurus\", 2, 2): {0}", dinosaurs.IndexOf("Tyrannosaurus", 2, 3));
        }

• 如果 参数 count 大于0，则从下标 index 开始向前搜索List ，并在 index + count - 1 的范围 结束。
• 此方法执行线性搜索;因此，此方法为 O (n) 操作，其中n是count。

List.Insert

public void Insert (int index, T item);

• 将元素 item （ 对于引用类型，该值可以为 null ） 插入 List 的 index 下标位置。
• 如果参数 index 小于 0。 或  index 大于 Count。都将 抛出  ArgumentOutOfRangeException
• 如果 Count 已等于Capacity，则通过自动重新分配内部数组来增加List 的容量，并在添加新元素之前将现有元素复制到新数组。
• 如果 index 等于 Count ，则将 item 添加到List 的末尾。
• 此方法为 O (n) 操作，其中n是Count。

       static void Main(string[] args)
        {
            List dinosaurs = new List();
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Compsognathus");
  
            dinosaurs.Insert(2, "huangchengtao");       
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }       
        }

List.InsertRange

public void InsertRange (int index, System.Collections.Generic.IEnumerable collection);

• 在 List 的 index 索引位置 插入集合 collection 元素，
• collection 本身不能为null，但如果类型 T 是引用类型，则它可以包含 null 的元素。
• 如果 参数 collection 为 null。抛出 ArgumentNullException
• 如果 index 小于 0。或 - index 大于 Count。 抛出 ArgumentOutOfRangeException
• 记住： collection 中的元素类型要和  List 中的元素类型一致。
• 如果index等于 Count ，则元素将添加到List 的末尾。 
• 该方法是O（n * m）运算，其中n是要添加的元素数，m 是 Count  

        static void Main(string[] args)
        {
            string[] input = { "Brachiosaurus","Amargasaurus","Mamenchisaurus" };
            List dinosaurs = new List() { "huang" ,"cheng","tao"};         
            dinosaurs.InsertRange(0, input);
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
        }

List.LastIndexOf

public int LastIndexOf (T item);

返回 从 List 的尾部向前搜索第一个 与 item（ 对于引用类型，该值可以为 null） 匹配的元素索引，如没找到，返回 -1.

此方法执行线性搜索;因此，此方法为 O (n) 操作，其中n是Count。

       static void Main(string[] args)
        {
            List dinosaurs = new List();
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Brachiosaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Compsognathus");       
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
            Console.WriteLine(dinosaurs.LastIndexOf("Tyrannosaurus")); // 输出下标 6        
        }

 

---

public int LastIndexOf (T item, int index);

•  从 List 索引 0 开始 到 index 结束范围内，从后往前搜索 是否有跟 item (  对于引用类型，该值可以为 null ) 匹配的元素。 若有，返回 item 在 List 中下标位置， 否则 返回 -1.
• 如果 参数 index 超出了 List 的有效索引范围。 抛出 ArgumentOutOfRangeException 
• 该方法执行线性搜索; 因此，此方法是O（n）操作，其中 n 是从List 开始到索引的元素数量。

       static void Main(string[] args)
        {
            List dinosaurs = new List();
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("huangchengtao");
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Brachiosaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Compsognathus");       
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
            // 返回 3
            Console.WriteLine(dinosaurs.LastIndexOf("Tyrannosaurus", 3));
        }

List.Remove(T)

public bool Remove (T item);

• 在 List 删除 第一个 与 item （对于引用类型，该值可以为 null ）匹配的元素。
• 如果成功移除 item，则为 true；否则为 false。 如果在 List 中没有找到 item，该方法也会返回 false。
• 此方法执行线性搜索;因此，此方法为 O (n) 操作，其中 n 是Count。

       static void Main(string[] args)
        {
            List dinosaurs = new List();
            dinosaurs.Add("huang");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Brachiosaurus");
            dinosaurs.Add("Deinonychus");

            dinosaurs.Add("Tyrannosaurus");
            dinosaurs.Add("Compsognathus");          
            Console.WriteLine(dinosaurs.Remove("huang")); // 返回true
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
        }

List.RemoveAt(Int32)

public void RemoveAt (int index);

• 从 List 中 删除 index 索引处的元素。
• 如果参数 index 小于 0。或 - index 等于或大于 Count。 都会 抛出 ArgumentOutOfRangeException
• 当使用 RemoveAt 删除一个元素的时候， 该元素之后的元素会移到被删除元素的位置，然后元素个数减一
• 此方法为 O (n) 操作，其中n是 (Count - index)。

       static void Main(string[] args)
        {
            List dinosaurs = new List();
            dinosaurs.Add("huang");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Brachiosaurus");
            dinosaurs.Add("Deinonychus");           
            dinosaurs.RemoveAt(4);       
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
        }

List.RemoveRange

public void RemoveRange (int index, int count);

• 删除从 List 索引 index开始 到 index+ count -1 范围内结束的元素。
• 如果参数 index 小于 0。或 - count 小于 0。抛出 ArgumentOutOfRangeException
• 如果参数 index 和 count 不表示 List 中元素的有效范围。 抛出 ArgumentException
• 此方法为 O (n) 操作，其中n是Count。

        static void Main(string[] args)
        {
            List dinosaurs = new List();
            dinosaurs.Add("huang");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Brachiosaurus");
            dinosaurs.Add("Deinonychus");
            dinosaurs.RemoveRange(2, 2);  // 下标2 和 下标3的元素被删除
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }          
        }

List.Reverse

public void Reverse ();

• 逆转整 个List 中元素的顺序。
• 此方法使用 Array.Reverse 来反转元素的顺序。
• 此方法为 O (n) 操作，其中n是Count。

       static void Main(string[] args)
        {
            List dinosaurs = new List();
            dinosaurs.Add("huang");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Brachiosaurus");
            dinosaurs.Add("Deinonychus");         
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
            dinosaurs.Reverse();
            WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
        }

---

public void Reverse (int index, int count);

•  把 List 下标 index 的位置 到  index + count -1 下标位置的结束范围内的元素逆转。
• 如果 参数 index 小于 0。 或 - count 小于 0。抛出 ArgumentOutOfRangeException
• 如果参数 index 和 count 不表示 List 中元素的有效范围。抛出 ArgumentException
• 此方法使用 Array.Reverse 来反转元素的顺序。
• 此方法为 O (n) 操作，其中n是Count。

       static void Main(string[] args)
        {
            List dinosaurs = new List();
            dinosaurs.Add("huang");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Brachiosaurus");
            dinosaurs.Add("Deinonychus");         
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
            dinosaurs.Reverse(1, 4); // 把下标1开始到下标4 的元素逆转了
            WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
        }

List.Sort 

该操作有很多重载形式

public void Sort ();

使用默认比较器对整个List 中的元素进行排序。

       static void Main(string[] args)
        {
            List dinosaurs = new List();
            dinosaurs.Add("euang");
            dinosaurs.Add("Amargasaurus");
            dinosaurs.Add("Mamenchisaurus");
            dinosaurs.Add("Brachiosaurus");
            dinosaurs.Add("Deinonychus");                   
            dinosaurs.Sort(); 
            WriteLine();
            foreach (string dinosaur in dinosaurs)
            {
                Console.WriteLine(dinosaur);
            }
        }

List.ToArray

public T[] ToArray ();

• 将 List 中的元素 拷贝到 一个 T 类型的数组中去。
• 该操作是使用 Array.Copy  复制元素，这是一个O（n）操作，其中 n 是 Count 
• 此方法为 O (n) 操作，其中n是Count。

        static void Main(string[] args)
        {
            string[] input = { "Brachiosaurus","Amargasaurus", "Mamenchisaurus" };

            List dinosaurs = new List(input);

            string[] temp = dinosaurs.ToArray();
           foreach(var tt in temp)
            {
                WriteLine(tt);
            }          
        }

List.TrimExcess

public void TrimExcess ();

• 如果不准备向 List 中添加元素，那么可以使用TrimExcess() 退回 List 中不需要的容量。这样可以表示退回给系统不需要的容量。 但是, 因为重新定位需要时间,所以如果元素个数超过了容量的90%, TrimExcesso() 方法就什么也不做。
• 该方法的功能是 将容量设置为 List 中的实际元素数目
• 此方法为 O (n) 操作，其中n是Count。
• 如果要将List 重置为其初始状态，请在调用 TrimExcess 方法之前调用 Clear 方法。

       static void Main(string[] args)
        {         
            List dinosaurs = new List(20) { "huang","cheng","tao"};
            WriteLine(dinosaurs.Capacity); //输出 20
            dinosaurs.TrimExcess();
            WriteLine(dinosaurs.Capacity); // 输出 3
        }

---

End....