C#---第十四课:数组（Array）& 列表（List）之间的相同与不同

1. 数组 & 列表的区别

数组和列表使用的时候，有很多不同点，主要可关注如下两点即可：

1. 数组初始化的时候就需要确定数组的大小，后续如果增加、删除数组的元素会比较麻烦。而列表则可以很便捷。
2. 数组创建的时候是使用的连续内存区域，调用的效率要比列表高很多。而列表的数据结构是链表。

2. 数组与列表的对比：增加元素、删除元素

（1）添加元素

namespace AlienDemo
{
    internal class AlienDemoClass
    {
        public static void Main()
        {
            string[] Array1 = { "alien", "ping", "an" };
            var arrayList = Array1.ToList();
            arrayList.Add("helloworld");
            Array1 = arrayList.ToArray();
            Console.WriteLine(string.Join('_', Array1));

            List<string> MyList = new List<string> { "alien", "ping", "an" };
            MyList.Add("helloworld");
            Console.WriteLine(string.Join('_', MyList));


            _ = Console.ReadKey();
        }
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// alien_ping_an_helloworld
// alien_ping_an_helloworld


1
2
3
4
5

（2）删除元素

namespace AlienDemo
{
    internal class AlienDemoClass
    {
        public static void Main()
        {
            string[] Array1 = { "alien", "ping", "an" , "helloworld" };
            var myList = Array1.ToList();
            myList.Remove("helloworld");
            Array1 = myList.ToArray();
            Console.WriteLine(string.Join('_', Array1));


            List<string> MyList = new List<string> { "alien", "ping", "an" , "helloworld" };
            MyList.RemoveAt(3);
            Console.WriteLine(string.Join('_', MyList));

            _ = Console.ReadKey();
        }
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// alien_ping_an
// alien_ping_an


1
2
3
4
5

通过以上代码可以看出，数组中对元素的删除、添加还是挺麻烦的。如果创建的可迭代对象可能删除、添加元素，还是使用列表吧。除非你的数据后续都不变了才使用数组比较合适。

3. 数组与列表都可以用的Sort：安字母顺序排序

namespace AlienDemo
{
    internal class AlienDemoClass
    {
        public static void Main()
        {
            string[] Array1 = { "alien", "ping", "an" };
            Array.Sort(Array1);
            Console.WriteLine(string.Join('_', Array1));


            List<string> MyList = new List<string> { "alien", "ping", "an"};
            MyList.Sort();
            Console.WriteLine(string.Join('_', MyList));

            _ = Console.ReadKey();
        }
    }
}


// alien_an_ping
// alien_an_ping

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

4. 数组与列表都可以用的orderby: 排序、逆序

namespace DemoApplication
{
    class Demo
    {
        //static string[] myArray = { "5", "1", "33", "abc" };
        static List<string> myList = new List<string> { "5", "1", "33", "abc" };

        static void Main(string[] args)
        {
            var result = myList.OrderBy(t => t).ToList();
            var result_re = myList.OrderBy(t => t).Reverse().ToList();
            result.ForEach(Console.WriteLine);
            Console.WriteLine("\n");
            result_re.ForEach(Console.WriteLine);
        }
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1
33
5
abc


abc
5
33
1


1
2
3
4
5
6
7
8
9
10
11
12
13

5. 数组与列表都可以用的join：拼接字符串

namespace AlienDemo
{
    internal class AlienDemoClass
    {
        public static void Main()
        {
            List<string> MyList = new List<string> { "alien", "ping", "an"};
            string[] MyArray = { "alien", "ping", "an"};

            Console.WriteLine(string.Join("\t", MyList));
            Console.WriteLine(string.Join("\t", MyArray));


            _ = Console.ReadKey();
        }
    }
}


// alien   ping    an
// alien   ping    an

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

6. 数组与列表都可以用的Distinct：去重

namespace AlienDemo
{
    internal class AlienDemoClass
    {
        public static void Main()
        {
            string[] Array1 = { "alien", "ping", "an", "alien", "ping"};
            List<string> MyList = new List<string> { "alien", "ping", "an", "alien", "ping" };
            var reList = MyList.Distinct().ToList();
            _ = Console.ReadKey();
        }
    }
}

// alien
// ping
// an

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

7. 列表特有的一些方法

namespace AlienDemo
{
    internal class AlienDemoClass
    {
        public static void Main()
        {
            List<string> MyList = new List<string> { "alien", "ping", "an"};

            MyList.ForEach(Console.Write);          // 打印列表中的所有元素，在同一行
            Console.WriteLine('\n');
            MyList.ForEach(Console.WriteLine);      // 打印列表中的所有元素，分行
            Console.WriteLine('\n');

            MyList.Reverse();											   // 根据目前元素顺序倒叙列表
            Console.WriteLine(string.Join('_', MyList));

            Console.WriteLine(string.Join('_', MyList.GetRange(1, 2)));   // 获取索引区间的元素

            MyList.RemoveRange(1, 2);							// 删除索引区间的元素
            Console.WriteLine(string.Join('_', MyList));

            MyList.Clear();										// 清空所有元素
            Console.WriteLine("------->{0}", MyList.Count);
        }
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

alienpingan

alien
ping
an


an_ping_alien
ping_alien
an
------->0




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16