第八章C# 基础

一·空类型

1.Null

特点：

1.表示不引用任何对象的空引用,没有创建内存空间,存放的是空引用指针；

2.Null类型是System.Nullable<T>这个struct的类型

3.对于值类型 赋值不能直接为null    引用类型可以

4.null引用类型变量的默认值

2.值类型如何赋值为null？

 //对于值类型 赋值不能直接为null   
            // int a = null;
            // Console.WriteLine(a);
            // 引用类型可以
            string b=null;
            Console.WriteLine(b);
            b = "456";
            Console.WriteLine(b);

            //Null类型是System.Nullable<T>这个struct的类型

            //1.如果想要值类型可以赋值null
            //int a = null;
            Nullable<int> a = null;
            Console.WriteLine(a);
            //float floatA = null;
            Nullable<float> floatA = null;
            Console.WriteLine(floatA);
            //  double doubleA = null;
            Nullable<double> doubleA = null;
            Console.WriteLine(doubleA);
            // bool boolA = null;
            Nullable<bool> boolA = null;
            Console.WriteLine(boolA);
            // byte byteA = null;
            Nullable<byte> byteA = null;
            Console.WriteLine(byteA);
            //long longA = null;
            Nullable<long> longA = null;
            Console.WriteLine(longA);
            //char charA = null;
            Nullable<char> charA = null;
            Console.WriteLine(charA);
            //decimal decimalA = null;
            Nullable<decimal> decimalA = null;
            Console.WriteLine(decimalA);



            //方式2

            int? intNumber = null; //  Nullable<int> a = null;
            byte? byteNumber = null;
            short? shortNumber = null;
            long? longNumber = null;
            float? floatNumber = null;
            double? doubleNumber = null;
            char? charNumber = null;
            bool? boolNumber = null;
            //string? stringNumber = null;
            decimal? decimalNumber = null;

3.使用的场景

当我们想要对于一个值类型变量进行 判断 是否 存在 时，为了节约内存 可以赋值为null

4.null和字符串空值和字符串空格的区别

 //1.null是没有创建内存空间,
            string string1 = null;
            //字符串空值  为"" 或者string.Empty  实际上都会分配空间；
            string string2 = "";
            string stringE = string.Empty;

            //带有空格符合的字符串 空格本身也是字符       所以不是空字符串 空格也是ACSII  对应的符号
            string string3 = " ";

5.双问号 ??（合并运算符）

作用：

用于判断一个变量在为 null 的时候返回一个

指定的值

使用场景

Null 合并运算符为类型转换定义了一个预设值，以防可空类型的值为 Null

 double? num1 = null;
            double? num2 = 3.14157;
            double num3;
            num3 = num1 ?? 111.11;      // num1 如果为空值则返回 5.34
            Console.WriteLine("num3 的值： {0}", num3);
            num3 = num2 ?? 5.34;
            Console.WriteLine("num3 的值： {0}", num3);

二.不可变数组

含义:

不可变数组是一个存储相同类型元素的固定大小的顺序集合

特点:

数组属于引用类型

数组只能包含类型相同的元素

数组通过下标（索引值）标记元素

格式：

声明数组：

datatype[] arrayName;

• datatype 用于指定被存储在数组中的元素的类型。
• 指定数组的秩（维度）。秩指定数组的大小。
• arrayName 指定数组的名称。

1.初始化数组中的元素的方式

//整数类型（int）数值
            //定义数组
             int[] intArray;
            // 初始化数组中的元素的方式
            // 数据类型[] 数组名 = new 数据类型[长度];
             intArray = new int[1];//创建长度为1的int类型数组
            int[] intArray1 = new int[1];//创建长度为1的int类型数组
            // 数据类型[] 数组名 = { 值 1, 值 2, …}
            //创建一个int类型的数组 长度为6  {数组的元素}
            int[] intArray2 = {1,2,4,5,6,7,9,10};//创建长度为8的int类型数组
            //数据类型[] 数组名 = new 数据类型[长度] { 值 1，值 2,…}
            int[] intArray3 = new int[5] {1,10,100,100,1000};//创建长度为5的int类型数组
            //数据类型[] 数组名 = new 数据类型[长度可忽略] { 值 1，值 2,…}
            // int[] intArray4 = new int[] {};  //无长度的数组  后续不能添加任何元素
            int[] intArray5 = new int[] { 1, 100, 1000, };  //创建长度为3的int类型数组

2.数组访问元素：

//通过数组的下标（索引值） 从0开始 从左到右 依次递增 1
           //                        0   1    2   3    4      5
            string[] stringArray6 = {"1","a" ,"w","d","张三","王五"};
            string element1 =  stringArray6[0];
            Console.WriteLine(element1);
            string element5 = stringArray6[5];
            Console.WriteLine(element5);

3.修改数组元素：

  stringArray6[2] = "z";
            Console.WriteLine(stringArray6[2]);

4.遍历数组方式：

1.for

//查看数组所有元素
            //                    0    1     2     3     4     5     6
             bool[] boolArray = {true,false,true ,false,false,true};
             for (int i = 0; i < 6; i++)
             {
                Console.WriteLine(boolArray[i]); 

             }
            // 数组的长度
           // boolArray.Length
            for (int i = 0; i < boolArray.Length; i++) {

                Console.WriteLine(boolArray[i]);

            }

2.foreach

 //var 代表任意类型
            //item 代表的数组的元素  
            // stringArray6 遍历哪个数组
            foreach (var item in stringArray6)
            { 
                Console.WriteLine(item);
            }
            foreach (string item in stringArray6)
            {
                Console.WriteLine(item);
            }

5.数组越界

//数组越界 是c#中 数组异常 超出数组的最大长度
            int[] intArray6 = { 10, 204, 30, 50 };
            //Console.WriteLine(intArray6[4]);
            //intArray6[5] = 200;
            Console.ReadKey();

6.多维数组   intArray2.GetLength（0） 获取对应维度下标

//多维数组
            //含义：数组嵌套数组形式 一般常用二维数组

            //二位数组格式：string [,] strArray =new string[数组个数,每个数组中元素个数]

            //定义二维数组
            string[,] strArray2;
            //初始化二维数组  
             strArray2 = new string[2,2];
            //一个带有 5 行 2 列的int类型二维数组 */
            int[,] intArray2 = new int[5, 2] { {1,2},{ 2,2 },{ 3,3},{ 4,5},{ 5,7} };
            int[,] intArray3 =  { { 1, 2 }, { 2, 2 }, { 3, 3 }, { 4, 5 }, { 5, 7 } };

            //二维数组访问元素：第一个0 代表一维数组中元素的下标
            //第二个0 代表二维数组中怨怒的下标
            int intNumber = intArray2[0,0];
            int intNumber1  = intArray2[3,1];
            int intNumber2 = intArray2[2,0];
            Console.WriteLine(intNumber2);

            //修改元素
            intArray2[1, 0] = 10;
            Console.WriteLine(intArray2[1, 0]);
            //遍历二维数组元素
            for (int i = 0; i < 5; i++)
            {
                for (int j = 0; j <2; j++)
                {
                    Console.WriteLine(intArray2[i,j]);
                }
            }
            //intArray2.GetLength（0） 获取对应维度下标   5 
            //intArray2.GetLength（1） 获取对应维度下标   2
            Console.WriteLine(intArray2.GetLength(0));
            Console.WriteLine(intArray2.GetLength(1));
            for (int i = 0; i < intArray2.GetLength(0); i++)
            {
                for (int j = 0; j < intArray2.GetLength(1); j++)
                {
                    Console.WriteLine(intArray2[i, j]);
                }

            }

7.其他多维数组格式： 例如三维数组

//  string[,,] strArray = new string[数组个数, 数组元素个数]

            int[,,] intArray4 = new int[2, 2, 2] { { {1,2},{4,5} },{ {6,7},{8,9} } };


           

            Console.WriteLine(intArray4[1, 0, 1]);

            for (int i = 0; i < intArray4.GetLength(0); i++)
            {

                for (int j = 0; j < intArray4.GetLength(1); j++)
                {
                    for (int k = 0; k < intArray4.GetLength(2); k++)
                    {

                        Console.WriteLine(intArray4[i, j, k]);
                    }
                }
            }

8.交错数组 了解

交错数组  又叫数组类型的数组

含义

交错数组是数组的数组，交错数组是一维数组。

//  定义交错数组格式：
            // int[] 数组类型
            //int[][] 数组类型的数组
            int[][] scores;
            scores = new int[3][] {new int[2] {1,2},new int[3] {2,3,4},new int[4] { 2,2,1,1} };

            //方式1
            int[]intArray = scores[0];
            Console.WriteLine(intArray[0]);

            //方式2
            Console.WriteLine(scores[0][0]);

            //交错修改数组元素：
            scores[0][1] = 10;

            //交错数组的遍历自己补


            int[][] jaggedArray = new int[3][];
            jaggedArray[0] = new int[] { 1, 2, 3 };
            jaggedArray[1] = new int[] { 4, 5 };
            jaggedArray[2] = new int[] { 6, 7, 8, 9 };

            // 输出交错数组的元素
            for (int i = 0; i < jaggedArray.Length; i++)
            {
                for (int j = 0; j < jaggedArray[i].Length; j++)
                {
                    Console.Write(jaggedArray[i][j] + " ");
                }
                Console.WriteLine();
            }





            Console.ReadKey();

三.Array类

含义：

是 C# 中所有数组的基类，它是在 System 命名空间中定义  提供了各种用于数组的属性和方法

1.常用属性 和方法

            //CreateInstance 静态方法 用于创建一维数组
            //参数1：设置数组数据类型  typeof(int) 转化值类型 为Type类型对象
            //参数2  数组的长度
            Array intArray = Array.CreateInstance(typeof(int), 5);
            Array floatArray  = Array.CreateInstance(typeof(float), 5);

 //参数1 object  添加的元素
            //参数2  数组的索引值  
            intArray.SetValue(100, 0);
            //通过for添加 0-4 到数组中
            for (int i = 0; i < 5; i++)
            {
                intArray.SetValue(i, i);
            }
            //foreach 遍历 array对象
            foreach (int item in intArray) {

                Console.WriteLine(item);
            }

2.获取一维数组指定位置元素

 int  a =  (int) intArray.GetValue(0);
            Console.WriteLine(a);

3.创建二维数组

 Array  intArray2  = Array.CreateInstance(typeof(int), 2, 2);
            intArray2.SetValue(100, 0,0);
          
            Console.WriteLine(intArray2.GetValue(0,0));

for循环添加 和foreach遍历数组

int intA = 1;
             for (int i = 0;i < intArray2.GetLength(0); i++) 
            {
                for (int j = 0; j < intArray2.GetLength(1); j++)
                {
                    intArray2.SetValue(intA, i, j);
                    intA++;
                }
            
            }
             //foreach遍历二维数组
            foreach (var item in intArray2) 
            {
                Console.WriteLine(item);
            }

4.常用的属性

Indexof(Array array, Obejct)    返回第一次出现的下标
Sort(Array array)    从小到大排序 （仅支持一维数组）
Reverse(Array array)    数组逆置
Clear(Array array, int index, int length)    将某个范围内的所有元素设为初始值
Copy      深复制   数组内容到另一个数组

部分解析：

 //   Indexof(Array array, Obejct)    返回第一次出现的下标
            Array intArray3 = Array.CreateInstance(typeof(int), 10);
            for (int i = 0; i < intArray3.Length; i++)
            {
                intArray3.SetValue(intArray3.Length-i, i);
            }

            //查找数组元素的索引值  如果存在 返回对应索引值  反之返回 -1
            int index =    Array.IndexOf(intArray3, 100);
            Console.WriteLine(index);



          //  Sort(Array array)    从小到大排序 （仅支持一维数组）
            Array.Sort(intArray3);

            foreach (var item in intArray3)
            {
                Console.WriteLine(item);
            }

            //Reverse(Array array)    数组逆置 
            // Clear(Array array, int index, int length)    将某个范围内的所有元素设为初始值
            //Copy    深复制   数组内容到另一个数组

四.可变参数params 

1.params是ParamArrayAttribute（参数数组属性）的缩写
2.param解决了C#中不定参数的传递的问题

3.params参数必须定义在参数列表最后面。
4.params必须对一维数组描述
5.params只能在一个方法中 定义一个一维数组
 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ZhiYouDay10_4
{
    internal class Program
    {
        static void Main(string[] args)
        {
           

            int[] intArray = new int[4] { 1, 2, 3, 4 };
            //必选参数 数组 只能写对应数组
            ProgramMothod1(intArray);

            //可变参数 可以直接写对应数组 也可以直接写数组中的元素
            ProgramMothod2(intArray);
            ProgramMothod2(1,2,3,4,5,6);



    
        // int[] ab必选参数
        private static void ProgramMothod1(int[] ab) {

            for (int i = 0; i<ab.Length; i++) {

                Console.WriteLine(ab[i]);
            }
        }
        //params int[] ab 可选参数
        private static void ProgramMothod2(params int[] ab)
        {

            for (int i = 0; i < ab.Length; i++)
            {
                Console.WriteLine(ab[i]);
            }
        }

        //int a  和 int  b 必选参数 
        private static void ProgramMothod(int a, int b,params int[]parIntArray)
        {
            int c = a + b;
            foreach (int item in parIntArray)
            {
                c += item;
            }
            Console.WriteLine(c);

        }
    }
}