数组

数组是大部分编程语言中都支持的一种数据类型，无论C语言、C++还是C#以及Java都支持数组的概念。

在我的上一篇博文中我们知道结构体可以一次性声明多个不同类型的变量，而数组可以一次性声明多个相同类型的变量。

1、数组基础：

数组

1.具有同一类型的多个对象的集合，是一种数据结构，包含同一类型的多个元素。

2.一组具有相同类型的变量的集合，如一组整数、一组字符等。

3.组成数组的这些变量称为数组的元素

4.每个数组元素都有一个编号，这个编号叫做下标

5.下标是从0开始的，最大的下标等于数组元素个数减一

6.数组元素的个数有时也称为数组的长度。

声明方法

1、Int[] numbers=new int[] {2,3,4};此数组就能存3个值。

2、Int[]numbers=new int[35]; 长度35，索引是0-34，下标0-34

3、int[]nums3=new int[3]{1,2,3};

4、int[]nums={1,2,3,4,5};

数组的存值

Numbers[5]=23;

Numbers[7]=100;

数组的存值和取值都是通过小标或索引来进行赋值和取值的。

2、数组的应用：

1.冒泡排序：

static voidMain(string[] args)
        {
            //数组的排序
            //冒泡排序
            int[] nums = new int[] { 98, 58,342, 235, 2, 34 };//声明数组
            int temp = 0;//声明交换位置的变量
            for (int j = 0; j < nums.Length- 1; j++)//j为比较的轮数
            {
                for (int i = 0; i <nums.Length - 1 - j; i++)//i为比较的次数
                {
                    if (nums[i] > nums[i +1])//类似三个数比较大小
                    {
                        temp = nums[i];
                        nums[i] = nums[i + 1];
                        nums[i + 1] = temp;
                    }
                }
            }
            for (int i = 0; i < nums.Length;i++)
            {
                Console.Write(nums[i] +"\t");//将数组中的数显示出来
            }
            Console.ReadKey();
        }

2.排序与反转：

排序使用：Array.Sort();默认从大到小排序，那么反转就是从小到大排序吗？NO！

参考下列代码便会明白：

int[] nums = newint[] { 2, 34, 3, 4, 35 };
            Array.Sort(nums);//排序
            //Array.Reverse (nums); //反转


            for (int i = nums.Length - 1; i>= 0; i--)//forr从大到小排序
            {
                Console.Write(nums[i] +"\t");
            }

            //for (int i = 0; i <nums.Length; i++)//从小到大排序
            //{
            //    Console.Write(nums[i]+"\t");
            //}
            Console.ReadKey();

原来反转的结果是数字倒转，并不是从小到大排序比如数组中是 35 ，输出的是 53 ，如果希望输出的结果是将数组中的数字从小到大排序，则需要使用 forr+Tab快捷键。

3.数组求最大最小值、总和、平均值

static voidMain(string[] args)
        {           
           Program.ArraySort();//调用方法ArraySort
            Console.ReadKey();
        }
        public static void ArraySort()  //写一个方法
        {
            int[] nums = new int[] { -12, 23,36, -45, 0, 565 };//定义一个数组
            int max = int.MinValue;//求最大值的变量
            int min = int.MaxValue;//求最小值的变量

            int sum = 0;//求和
            for (int i = 0; i < nums.Length;i++)
            {
                if (nums[i] > max) //求最大值
                {
                    max = nums[i];
                }
                if (nums[i] < min)//求最小值
                {
                    min = nums[i];
                }
                sum += nums[i];
            }
           Console.WriteLine("和是{0},最大值是{1},最小值是{2},平均值为{3}",sum, max, min, sum / nums.Length);
            Console.ReadKey();
        }

数组在C#中最早出现的。在内存中是连续存储的，所以它的索引速度非常快，而且赋值与修改元素也很简单。

static voidMain(string[] args)
        {
            string[] str = new string[2];
            str[0] = "a";//赋值
            str[1] = "b";

            str[1] = "a1";//修改
        }

但是数组存在一些不足的地方。在数组的两个数据间插入数据是很麻烦的，而且在声明数组的时候必须指定数组的长度，数组的长度过长，会造成内存浪费，过短会造成数据溢出的错误。如果在声明数组时我们不清楚数组的长度，就会变得很麻烦。

针对数组的这些缺点，C#中最先提供了ArrayList对象来克服这些缺点。而ArrayList是集合中的一种，那我们先来看看什么是集合？

集合

1、集合概念：

集合是引自数学的一种概念，其本意是表示一组具有共同性质的数学元素的组合，典型的数学集合例如有理数集合等。在面向对象的程序设计中，集合是对各种集合包中的类进行实例化的结果，其表示由若干对象组成的组合。

从广义概念上讲，之前介绍的数组、枚举和结构等组合都是集合的一种表现，其内部的元素组织方式也都与集合的定义非常相似。但在C#中，集合这一专有名词特指System.Collections命名空间下的各种子类，数组、枚举和机构等类都不是System.Collections命名空间的成员。

2、集合基础：

集合

1.可以看做数组

2.创建一个长度为10，要插入新的数据，就得重新创建数组，排序

3.长度固定，不太灵活

4.使用集合即可方便解决这些问题

5.可以将集合看做长度可变的，具有很多方法的数组

添加数据方式

1.通过构造函数可以添加数组

2.通过Add()方法可以添加数组，但是算成一个元素

3.通过AddRange()也可以添加数组

下面是四种集合的比较：

C#之数组与集合

3、小例子：

集合随机产生数字求和：

static void Main(string[] args)
        {
            //随机往集合中添加数据，添加10个，不能重复，再求和，求平均值
            ArrayList ar = new ArrayList();
            Random r = new Random();//初始化随机数类

            while (ar.Count !=10)//共添加10个数，来个循环
            {
                int num = r.Next(1,100);
                if (!ar.Contains(num))//是否有num这个数
                {
                    ar.Add(num);//如果不包含，则添加进去
                }                
            }
            int sum = 0;//声明一个变量
            for (int i = 0; i < ar.Count; i++)
            {
                if (ar[i] is int)//如果能转换
                {
                    sum += (int)ar[i];
                }
                Console.WriteLine(ar[i]);
            }
            Console.WriteLine(sum);
            Console.WriteLine(sum / ar.Count );
            Console.ReadKey();
        }

比一比：

在表现形式上，数组对元素的限制最为严格。C#中，数组只能存储数据类型相同且数量固定的元素。枚举虽然允许开发者添加或删除元素，但是其本身只能存储整数型等数字元素，且其缘故的值必须遵循递增的规律。结构这一种类集合的组合更加类似对象，其中可以存储各种字段，但是其所有的字段必须是预先定义好的内容。

相比之前的3中数据组合，集合在使用方面更加灵活，其分为多种子类，可以存储各种复杂的数据，且可以由开发者随意的添加元素或删除元素。使用集合，可以方便的存储各种自定义的结构化内容，并随时对结构体本身进行修改。

既然ArrayList解决了添加删除等等问题，为何还会有List这个泛型集合呢？

注释：泛型集合不需要导入命名空间，在实例化的时候就已经限定了数据类型。

上网查，结果是因为我们在使用ArrayList的时候很可能会报类型不匹配的错误，所以其类型不安全。另外，在存储或检索值类型时通常发生装箱和取消装箱操作，带来很大的性能耗损。而泛型集合就是解决这个问题的。关于这方面还不是很理解，但希望这篇博文能够让混淆这几种关系的朋友得到帮助！

总结：

学习是循序渐进的，一点点深入，才能领悟到精髓，但又不能过于钻牛角尖，知道他们的由来，为了解决什么问题，囫囵吞枣，对我来说已经足够了，希望小编这篇博文能给朋友们带来不一样的收获，祝您天天有个好心情！

秒客网