C#简介 / C#与C++的区别 2

数组

二维数组 交错数组

  //二维数组 声明+初始化+赋值
  int[,] map = new int[4,4] {{1,2,3,4}，{0,0,0,0}，{0,0,0,0}，{2,2,2,2}};
  //读取数组内容的两种方法
  foreach (var item in arr)
  {
      Console.WriteLine(item);
  }
  //array.Length 数组元素总数4 * 4 == 16
  // array.GetLength(0)  获取二维数组行数  4
  // array.GetLength(1)  获取二维数组列数  4
  for (int i=0;i

运行结果

params 参数数组

使用于类型确定，而个数不确定的情况
作用：简化调用方法时的代码

对于方法(函数)内部而言，就是普通数组
对于方法外部(调用时)：
1.可以传递数组
2.传递一组数据类型相同的变量的集合
3.可以不传递参数

       //params 参数数组
       private static int Add(params int[] arr)
       {
           int sum = 0;
           foreach (var item in arr)
           {
               sum += item;
           }
           return sum;
       }
       static  void Main()
       {
           int res1 = Add(new int[] { 1, 3, 5, 7, 9 });
           int res2 = Add(1, 3, 5, 7, 9);
           int res3 = Add();

           //WriteLine重载的方法之一就包含了params参数数组
           Console.WriteLine("{0}{1}{2}", new object[] { 1, 2, 3, 4, 5 });
           Console.WriteLine("{0}{1}{2}", 1, 2, 3, 4, 5); 
       }

.

方法（函数）

值参数 引用参数 输出参数

       int a1,a2,a3;
       a1 = 1;
       a2 = 1;
       Fun1(a1);//值参数：传递实参变量储存的内容
       Fun2(ref a2);//引用参数：传递实参自身变量地址(即引用)
       Fun3(out a3);//输出参数：按引用传递，传递实参自身变量地址

       private static void Fun1(int a)
       {
           //值参数在参数传递前一定有值
           //形参不能改变实参数据
           a = 2;
       }
       private  static void  Fun2(ref int a)
       {
           //引用参数不一定在函数内给变量赋值
           //引用参数在参数传递前一定有值
           //作用：改变数据
           
           //a = 2;
       }
       private static void Fun2(out int a)
       {
           //输出参数必须在函数内给变量赋值
           //输出参数在参数传递前不一定有值
           //作用：返回结果
           a = 2;
       }

Tryparse方法

            int res;
            //Tryparse方法，返回两个结果
            //out:转换后的结果
            //返回值：是否可以转换
            bool result = int.TryParse("250", out res);

.

拆装箱

            int a = 1;
            //装箱操作 [性能最差] 值类型到object类型的转换
            object o = a;
            //拆箱操作 [性能"较"好] object类型到值类型的转换
            int b = (int)o;
            //[性能最好]
            int c = a;

            int num = 100;
            string strNumber01 = num.ToString();//未发生拆装箱操作
            string str = "数字是：" + num;//装箱：int --> object
            //避免方式： string str = "数字是：" + num.ToString(); 

        //如果形参为Object类型 实参传递值类型，会发生拆装箱
        //解决方案：1.重载 (2.泛型)
        private static void fun(object o) { }

主要理解拆装箱概念，实际操作时对程序性能影响不大。

.

字符串

            //特性1：字符串池   
            //字符串常量在创建时，都会先在字符串池中查找是否具有相同的文本。
            //如果不存在则开辟空间存储，如果存储在直接返回引用。
            //作用：提高内存利用率
            string str01 = "八戒";
            string str02 = "八戒";//是同一对象
            string str03 = new string(new char[] { '八', '戒' });
            string str04 = new string(new char[] { '八', '戒' }); //不是同一对象

            bool r1 = object.ReferenceEquals(str03, str04);//判断是否为同一对象

            //特性2：不可变性
            string name = "悟空";
            name = "老孙";
            //将文本"悟空"与文本 "老孙"是字符串常量，无法修改 
            //重新开辟空间，存储"老孙",再替换name中存储的引用

            string strNumber = "";
            for (int i = 0; i < 10; i++)
            {
                //每次循环 都会产生一个新的字符串对象，替换引用，产生垃圾
                //会消耗大量性能，占用空间
                strNumber = strNumber + i.ToString();
            } 
            Console.WriteLine(strNumber);//0 1 2 3 4 5  6 7 8 9

            //可变字符串  一次在内存中开辟可以容纳可变的个数的字符大小的空间
            //空间不够时会自动开辟新的空间代替原有空间，可以直接在原有长度上修改
            //可变字符串不是字符串 是一个类
            //适用性：频繁对字符串操作(增加 替换 移除 插入等)
            StringBuilder builder = new StringBuilder(10);//类似char[]
            for (int i = 0; i < 10; i++)
            {//每次追加新字符串，都在原有空间，避免产生垃圾
                builder.Append(i);    //增加
            }
            //build的其他用法==
            //builder.Insert(0, "ok");  插入
            //builder.Remove            移除
            //builder.Replace           替换
            Console.WriteLine(builder);
            string s1 = "abc";
            s1 = s1.Insert(0, "ok");

字符串的其他用法
ToArray / Insert / Contains / ToLower / ToUpper
IndexOf / Substring / Trim / Split / Replace / Join