静态数组：int[]、float[]、double[] 、char[]、string[]

特点：数组一旦创建，其容量的大小是无法改变的

int[] arr = new int[20]
虽然我这边里可以提前设定好了容量，但是存储数据的一种，我们永远都想象不到会有多少数据会被进行存储，所以适当的使用动态数组，是最好的！

扩展知识（1）：

image.png

首先，图片中的 this 代表正在运行的当前实例，也就是这个类的一个构造器！ 最后，我们可以知道 public Array1（） : this(10) Array1（）：this(10) 表示的是调用自己类中的另一个构造器（Array1（int capacity））

扩展知识（2）：

image.png

stringBuilder** 用于字符串连接，并且效率远高于string 用“+”将整数类型进行拼接的效率要快。 StringBuilder.Append：将信息追加到当前 StringBuilder 的结尾！ string.Format **

image.png

对数组进行增加、添加、修改、查询、删除的例子：

Add 函数中的 For循环是让数组的 元素通通往后移** ，然后（date[index] = e;N++;）是在数组中添加元素。 而之所以要重写 Tostring（），首先在不重写的情况下，我们输出 a ，调用的是 base.object.Tostring(),只会输出 命名空间.类名 所以重写 Tostring（），让他变为我们想要输出的结果。 代码逻辑就是：在 For 循环中添加、修改元素，然后重写 Tostring（）**进行返回输出。

  1.    class Array1
  2.     {
  3.         private int[] date;
  4.         private int N;
  6.         /// <summary>
  7.         /// 这个构造器，让用户自己填写容量
  8.         /// </summary>
  9.         /// <param name="capacity">用户添加的数组容量</param>
  10.         public Array1(int capacity)
  11.         {
  12.             date = new int[capacity];
  13.             N = 0;
  14.         }
  16.         public Array1() : this(10) { }
  18.         public int Capacity
  19.         {
  20.             get
  21.             {
  22.                 return date.Length;
  23.             }
  24.         }
  26.         public int Count
  27.         {
  28.             get
  29.             {
  30.                 return N;
  31.             }
  32.         }
  34.         public bool IsEmpty
  35.         {
  36.             get
  37.             {
  38.                 return N == 0;
  39.             }
  40.         }
  42.         public void Add(int index, int e)
  43.         {
  44.             if (index < 0 || index > N)
  45.             {
  46.                 throw new ArgumentNullException("数组索引越界");
  47.             }
  48.             if (N == date.Length)
  49.             {
  50.                 throw new ArgumentNullException("数组已满");
  51.             }
  53.             for (int i = N - 1; i >= index; i--)
  54.                 date[i + 1] = date[i];
  56.             date[index] = e;
  57.             N++;
  58.         }
  60.         public void AddLast(int e)
  61.         {
  62.             Add(N, e);
  63.         }
  65.         public void AddFirst(int e)
  66.         {
  67.             Add(0, e);
  68.         }
  70.         /// <summary>
  71.         /// 通过索引，来获取数组的元素
  72.         /// </summary>
  73.         /// <param name="index">数组的长度-1</param>
  74.         /// <returns></returns>
  75.         public int Get(int index)
  76.         {
  77.             if (index < 0 || index >= N)
  78.             {
  79.                 throw new ArgumentException("数组超出索引");
  80.             }
  82.             return date[index];
  83.         }
  85.         /// <summary>
  86.         /// 获取数组的第一个元素
  87.         /// </summary>
  88.         /// <returns></returns>
  89.         public int GetFirst()
  90.         {
  91.             return Get(0);
  92.         }
  94.         /// <summary>
  95.         /// 获取数组的最后一个元素
  96.         /// </summary>
  97.         /// <returns></returns>
  98.         public int GetLast()
  99.         {
  100.             return Get(N - 1);
  101.         }
  102.         /// <summary>
  103.         /// 更改指定的数组元素
  104.         /// </summary>
  105.         /// <param name="index">索引</param>
  106.         /// <param name="newE">修改的数字</param>
  107.         /// <returns></returns>
  108.         public int Set(int index, int newE)
  109.         {
  110.             if (index < 0 || index >= N)
  111.             {
  112.                 throw new ArgumentException("数组超出索引");
  113.             }
  114.             return date[index] = newE; 
  115.         }
  117.         /// <summary>
  118.         /// 查看是否有传进来的值
  119.         /// </summary>
  120.         /// <param name="e"></param>
  121.         /// <returns></returns>
  122.         public bool GetNumber(int e)
  123.         {
  124.             for (int i = 0; i < N; i++)
  125.             {
  126.                 if (date[i] == e)
  127.                 {
  128.                     return true;
  129.                 }  
  130.             }
  131.             return false;
  132.         }
  134.         /// <summary>
  135.         /// 获取到传进来的值，当前的索引
  136.         /// </summary>
  137.         /// <param name="e"></param>
  138.         /// <returns></returns>
  139.         public int GetIndex(int e)
  140.         {
  141.             for (int i = 0; i < N; i++)
  142.             {
  143.                 if (date[i] == e)
  144.                 {
  145.                     return i;
  146.                 }
  147.             }
  148.             return -1;
  149.         }
  151.         /// <summary>
  152.         /// 删除指定的数组元素
  153.         /// </summary>
  154.         /// <param name="index"></param>
  155.         /// <returns></returns>
  156.         public int RemoveAt(int index)
  157.         {
  158.             if (index < 0 || index >= N)
  159.             {
  160.                 throw new ArgumentException("数组超出索引");
  161.             }
  162.             int del = date[index];
  164.             for (int i = index; i < N; i++)
  165.                 date[i] = date[i + 1];
  167.             N--;
  168.             date[N] = default(int);
  170.             return del;
  171.         }
  173.         public int RemoveFirst()
  174.         {
  175.             return RemoveAt(0);
  176.         }
  178.         public int RemoveLast()
  179.         {
  180.             return RemoveAt(N - 1);
  181.         }
  183.         /// <summary>
  184.         /// 删除指定元素的索引
  185.         /// </summary>
  186.         /// <param name="e"></param>
  187.         public void Remove(int e)
  188.         {
  189.             int index = date[e];
  190.             if (index != -1)
  191.             {
  192.                 RemoveAt(index);
  193.             }
  194.         }
  196.         public override string ToString()
  197.         {
  198.             StringBuilder res = new StringBuilder();
  199.             res.Append(string.Format("Array1：count = {0}     capacity = {1}\n", N, date.Length));
  200.             res.Append("[");
  201.             for (int i = 0; i < N; i++)
  202.             {
  203.                 res.Append(date[i]);
  204.                 if (i != N - 1)
  205.                     res.Append("，");
  206.             }
  207.             res.Append("]");
  208.             return res.ToString();
  209.         }
  210.     }  
  212.  class Program
  213.     {
  214.         private static void Main(string[] args)
  215.         {
  216.             Array1 a = new Array1(20);
  218.             for (int i = 0; i < 10; i++)
  219.             {
  220.                 a.AddLast(i);
  221.             }
  222.             Console.WriteLine(a);
  224.             a.AddFirst(66);
  225.             Console.WriteLine(a);
  227.             a.Add(2, 77);
  228.             Console.WriteLine(a);
  230.             Console.WriteLine("==========分隔符===========");
  232.             Console.WriteLine(a.Get(8));
  233.             Console.WriteLine(a.GetFirst());
  234.             Console.WriteLine(a.GetLast());
  235.             a.Set(1, 200);
  236.             Console.WriteLine(a);
  238.             Console.WriteLine("==========分隔符===========");
  240.             Console.WriteLine(a.GetNumber(5));
  241.             Console.WriteLine(a.RemoveAt(5));
  242.             Console.WriteLine(a.GetIndex(9));
  243.             Console.WriteLine(a);
  245.             Console.WriteLine("==========分隔符===========");
  247.             a.RemoveAt(2);
  248.             a.RemoveFirst();
  249.             a.RemoveLast();
  250.             a.Remove(4);
  251.             Console.WriteLine(a);
  253.             Console.ReadKey();
  254.         }
  255.     }

运行结果：

image.png

动态数组：

特点：可以根据元素的多少动态地调整数组容量的大小，就算先前设置好容量，我们再次进行添加数据，因为动态数组具有自动扩容的能力
缺点：我们总是未能充分使用到动态数组的空间。


动态数组的例子：

通过计算当前数组的元素是否为原来的四分之一，进行缩容 是否为超出原来的数组容量，进行扩容

  1. class Array1{
  2.         public void Add(int index, int e)
  3.         {
  4.             if (index < 0 || index > N)
  5.             {
  6.                 throw new ArgumentNullException("数组索引越界");
  7.             }
  8.             if (N == date.Length)
  9.             {
  10.                 ResetCapacity(2 * date.Length);
  11.             }
  13.             for (int i = N - 1; i >= index; i--)
  14.                 date[i + 1] = date[i];
  16.             date[index] = e;
  17.             N++;
  18.         }    
  20.          /// <summary>
  21.         /// 删除指定的数组元素
  22.         /// </summary>
  23.         /// <param name="index"></param>
  24.         /// <returns></returns>
  25.         public int RemoveAt(int index)
  26.         {
  27.             if (index < 0 || index >= N)
  28.             {
  29.                 throw new ArgumentException("数组超出索引");
  30.             }
  31.             int del = date[index];
  33.             for (int i = index; i < N; i++)
  34.                 date[i] = date[i + 1];
  36.             N--;
  37.             date[N] = default(int);
  39.             if (N == date.Length / 4)
  40.             {
  41.                 ResetCapacity(date.Length / 2);
  42.             }
  44.             return del;
  45.         }
  46. }
  48. class Program
  49.     {
  50.         private static void Main(string[] args)
  51.         {
  52.             Array1 a = new Array1(10);
  54.             for (int i = 0; i < 10; i++)
  55.             {
  56.                 a.AddLast(i);
  57.             }
  58.             Console.WriteLine(a);
  59.             a.AddLast(100);
  60.             Console.WriteLine(a) ;
  62.             for (int i = 0; i < 6; i++)
  63.             {
  64.                 a.RemoveLast();
  65.                 Console.WriteLine(a);
  66.             }
  68.             Console.ReadKey();
  69.         }
  70.     }

运行结果：

image.png

ArrayList、List（泛型）

泛型和非泛型的例子：

泛型和非泛型 泛型数组List有两个优势： 第一个是对于存储值类型数据，性能更优 第二个是使代码更清晰和保证类型安全 List l = newList(); ArrayList a = nwe ArrayList();

  1.     class Program
  2.     {
  3.         private static void Main(string[] args)
  4.         {
  5.             int n = 10000000;
  7.             Stopwatch t1 = new Stopwatch();
  8.             Stopwatch t2 = new Stopwatch();
  9.             Stopwatch t3 = new Stopwatch();
  10.             Stopwatch t4 = new Stopwatch();
  12.             Console.WriteLine("测试值类型对象int");
  13.             t1.Start();
  14.             List<int> l = new List<int>();
  15.             for (int i = 0; i < n; i++)
  16.             {
  17.                 l.Add(i); //不发生装箱
  18.                 int x = l[i]; //不发生拆箱
  19.             }
  20.             t1.Stop();
  21.             Console.WriteLine("List'Time：" + t1.ElapsedMilliseconds+"ms");
  23.             t2.Start();
  24.             ArrayList a = new ArrayList();
  25.             for (int i = 0; i < n; i++)
  26.             {
  27.                 a.Add(i); //发生装箱
  28.                 int x = (int)a[i]; //发生拆箱
  29.             }
  30.             t2.Stop();
  31.             Console.WriteLine("List'Time：" + t2.ElapsedMilliseconds + "ms");
  33.             Console.WriteLine("测试引用类型对象string");
  34.             t3.Start();
  35.             List<string> l2 = new List<string>();
  36.             for (int i = 0; i < n; i++)
  37.             {
  38.                 l2.Add("X"); //不发生装箱
  39.                 string x = l2[i]; //不发生拆箱
  40.             }
  41.             t3.Stop();
  42.             Console.WriteLine("List'Time：" + t3.ElapsedMilliseconds + "ms");
  44.             t4.Start();
  45.             ArrayList a2 = new ArrayList();
  46.             for (int i = 0; i < n; i++)
  47.             {
  48.                 a2.Add("x"); //不发生装箱
  49.                 string x = (string)a2[i]; //不发生拆箱
  50.             }
  51.             t4.Stop();
  52.             Console.WriteLine("List'Time：" + t4.ElapsedMilliseconds + "ms");
  54.             Console.ReadKey();
  55.         }
  56.     }

运行结果：

image.png

运用泛型对动态数组添加元素的例子：

  1.   class Array1<T>
  2.     {
  3.         private T[] date;
  4.         private int N;
  6.         /// <summary>
  7.         /// 这个构造器，让用户自己填写容量
  8.         /// </summary>
  9.         /// <param name="capacity">用户添加的数组容量</param>
  10.         public Array1(int capacity)
  11.         {
  12.             date = new T[capacity];
  13.             N = 0;
  14.         }
  16.         public Array1() : this(10) { }
  18.         public int Capacity
  19.         {
  20.             get
  21.             {
  22.                 return date.Length;
  23.             }
  24.         }
  26.         public int Count
  27.         {
  28.             get
  29.             {
  30.                 return N;
  31.             }
  32.         }
  34.         public bool IsEmpty
  35.         {
  36.             get
  37.             {
  38.                 return N == 0;
  39.             }
  40.         }
  42.         public void Add(int index, T e)
  43.         {
  44.             if (index < 0 || index > N)
  45.             {
  46.                 throw new ArgumentNullException("数组索引越界");
  47.             }
  48.             if (N == date.Length)
  49.             {
  50.                 ResetCapacity(2 * date.Length);
  51.             }
  53.             for (int i = N - 1; i >= index; i--)
  54.                 date[i + 1] = date[i];
  56.             date[index] = e;
  57.             N++;
  58.         }
  60.         public void AddLast(T e)
  61.         {
  62.             Add(N, e);
  63.         }
  65.         public void AddFirst(T e)
  66.         {
  67.             Add(0, e);
  68.         }
  70.         /// <summary>
  71.         /// 通过索引，来获取数组的元素
  72.         /// </summary>
  73.         /// <param name="index">数组的长度-1</param>
  74.         /// <returns></returns>
  75.         public T Get(int index)
  76.         {
  77.             if (index < 0 || index >= N)
  78.             {
  79.                 throw new ArgumentException("数组超出索引");
  80.             }
  82.             return date[index];
  83.         }
  85.         /// <summary>
  86.         /// 获取数组的第一个元素
  87.         /// </summary>
  88.         /// <returns></returns>
  89.         public T GetFirst()
  90.         {
  91.             return Get(0);
  92.         }
  94.         /// <summary>
  95.         /// 获取数组的最后一个元素
  96.         /// </summary>
  97.         /// <returns></returns>
  98.         public T GetLast()
  99.         {
  100.             return Get(N - 1);
  101.         }
  102.         /// <summary>
  103.         /// 更改指定的数组元素
  104.         /// </summary>
  105.         /// <param name="index">索引</param>
  106.         /// <param name="newE">修改的数字</param>
  107.         /// <returns></returns>
  108.         public void Set(int index, T newE)
  109.         {
  110.             if (index < 0 || index >= N)
  111.             {
  112.                 throw new ArgumentException("数组超出索引");
  113.             }
  114.              date[index] = newE; 
  115.         }
  117.         /// <summary>
  118.         /// 查看是否有传进来的值
  119.         /// </summary>
  120.         /// <param name="e"></param>
  121.         /// <returns></returns>
  122.         public bool GetNumber(int e)
  123.         {
  124.             for (int i = 0; i < N; i++)
  125.             {
  126.                 if (date[i].Equals(e))
  127.                 {
  128.                     return true;
  129.                 }  
  130.             }
  131.             return false;
  132.         }
  134.         /// <summary>
  135.         /// 获取到传进来的值，当前的索引
  136.         /// </summary>
  137.         /// <param name="e"></param>
  138.         /// <returns></returns>
  139.         public int GetIndex(int e)
  140.         {
  141.             for (int i = 0; i < N; i++)
  142.             {
  143.                 if (date[i].Equals(e))
  144.                 {
  145.                     return i;
  146.                 }
  147.             }
  148.             return -1;
  149.         }
  151.         /// <summary>
  152.         /// 删除指定的数组元素
  153.         /// </summary>
  154.         /// <param name="index"></param>
  155.         /// <returns></returns>
  156.         public T RemoveAt(int index)
  157.         {
  158.             if (index < 0 || index >= N)
  159.             {
  160.                 throw new ArgumentException("数组超出索引");
  161.             }
  162.             T del = date[index];
  164.             for (int i = index; i < N; i++)
  165.                 date[i] = date[i + 1];
  167.             N--;
  168.             date[N] = default(T);
  170.             if (N == date.Length / 4)
  171.             {
  172.                 ResetCapacity(date.Length / 2);
  173.             }
  175.             return del;
  176.         }
  178.         public T RemoveFirst()
  179.         {
  180.             return RemoveAt(0);
  181.         }
  183.         public T RemoveLast()
  184.         {
  185.             return RemoveAt(N - 1);
  186.         }
  188.         /// <summary>
  189.         /// 删除指定元素的索引
  190.         /// </summary>
  191.         /// <param name="e"></param>
  192.         public void Remove(int e)
  193.         {
  194.             int index = e;
  195.             if (index != -1)
  196.             {
  197.                 RemoveAt(index);
  198.             }
  199.         }
  201.         private void ResetCapacity(int newCapcaity)
  202.         {
  203.             T[] newDate = new T[newCapcaity];
  205.             for (int i = 0; i < N; i++)
  206.                 newDate[i] = date[i];
  208.             date = newDate;
  209.         }
  211.         public override string ToString()
  212.         {
  213.             StringBuilder res = new StringBuilder();
  214.             res.Append(string.Format("Array1：count = {0}     capacity = {1}\n", N, date.Length));
  215.             res.Append("[");
  216.             for (int i = 0; i < N; i++)
  217.             {
  218.                 res.Append(date[i]);
  219.                 if (i != N - 1)
  220.                     res.Append("，");
  221.             }
  222.             res.Append("]");
  223.             return res.ToString();
  224.         }
  225.     } 
  227. class Program
  228.     {
  229.         private static void Main(string[] args)
  230.         {
  231.             int[] n = { 1, 2, 3, 4, 5, 6, 7 };
  232.             Array1<int> a = new Array1<int>();
  233.             for (int i = 0; i < n.Length; i++)
  234.                 a.AddLast(n[i]);
  235.             Console.WriteLine(a);
  237.             string[] s = { "1","2","3","4","5" };
  238.             Array1<string> a1 = new Array1<string>();
  239.             for (int i = 0; i < s.Length; i++)
  240.                 a1.AddLast(s[i]);
  241.             Console.WriteLine(a1);
  243.             Console.ReadKey();
  244.         }
  245.     }

运行结果：

image.png