数组
二维数组 交错数组
//二维数组 声明+初始化+赋值
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<arr.GetLength (0);i++)
{
for (int j = 0; j < arr.GetLength(1); j++)
Console.Write(arr[i,j] + "\t");//打印成表格
Console.WriteLine();
}
//交错数组 声明
int[][] arr1;
//创建具有4个元素的交错数组
arr1 = new int[4][];
//创建一维数组，赋值给交错数组的第一个元素
//有点类似c++里的 int* a[4];
//但是c#中没有指针
arr1[0] = new int[3] { 1, 2, 3 };
arr1[1] = new int[5] {2,1,0,0,0};
arr1[2] = new int[4] {2,4,6,8};
arr1[3] = new int[1];
//读取数组内容的两种方法
foreach (int[] array in arr1)
foreach (int item in array)
Console.WriteLine(item);
//交错数组应看成多个不同的一维数组，区别于二维数组
//arr1.Length 交错数组元素数(可以理解为行数)
for (int i=0;i<arr1.Length;i++)
{
for (int j = 0; j < arr1[i].Length; j++) //arr[i].Length大小不相同
Console.Write(arr1[i][j]+"\t"); //打印成表格(不规则)
Console.WriteLine();
}
运行结果
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
