C#的学习（4）

1. 整数转换，整数和字符串，字符串和整数之间的转换怎么实现？

        1.1 整数转字符串       

int n = 123;

//第一种方式：任何类型和字符串连接，结果都是字符串

Console.WriteLine("" + n);

//第二种方式：通过Convert.ToString()方法进行转换

Console.WriteLine(Convert.ToString(n));

       1.2 字符串转整数 

//字符串转整数

string str = "123";



//第一种方式

int a = int.Parse(str);

Console.WriteLine(a + 10);



//Console.WriteLine("123"+2);

//Console.WriteLine(123+2);



//第二种方式

int b = Convert.ToInt32(str);

Console.WriteLine(b + 1);

补充：当然关于数据类型的转换还有很多，比如括号强转，Parse法和Convert法，这三个是在数据类型中转换最常用的了；

数据类型转换的三个常用方法

	作用	语法	注意
括号强转（）	一般情况下 将高精度的类型强制转换为低精度	变量类型 变量名=（变量类型）变量	精度问题 范围问题
Parse法	把字符串转换为对应的类型	变量类型.Parse("字符串)	字符串必须能够转换成对应类型（合法合规）否则报错
Convert法	更具体的将 各个类型之间相互转换	Convert.To目标类型（变量或常量）	填写的变量或常量必须正确 否则出错

2. 日期转换，获取当前日期，字符串转日期，日期转字符串怎么实现？

        2.1 获取当前日期

//获取当前的时间
DateTime currentDateTime = DateTime.Now;
Console.WriteLine(currentDateTime.ToString());

        2.2 字符串转日期 

String s = "2024-07-04 09:49:03";
DateTime dt = DateTime.Parse(s);
Console.WriteLine(dt);

        2.3日期转字符串

DateTime dt3 = new DateTime(2024, 10, 11);
Console.WriteLine(dt3.ToString());

Console.WriteLine(dt3.Year.ToString());
Console.WriteLine(dt3.Month.ToString());
Console.WriteLine(dt3.Day.ToString());
Console.WriteLine(dt3.ToString("yyyy-MM-dd")); // 输出: 2024-10-11

3. 举例一维、二维、三维数组

        3.1 一维数组

        一维数组是最简单的数组类型，它就像一个列表，其中的元素按线性顺序排列。

// 定义和初始化一维整型数组
int[] arr = new int[5] { 1, 2, 3, 4, 5 };

// 或者可以这样初始化，数组大小由自己输入的数决定，但是这是静态数组
int[] arr1 = { 10, 20, 30, 40, 50 };

// 打印数组元素
foreach (int i in arr1)
{ 
    Console.Write(i+" ");
}

        3.2 二维数组

        二维数组可以看作是一个表格，由行和列组成，所以它也可以被称为矩阵。

// 定义和初始化二维整型数组
int[,] arr = new int[3, 2]{{ 1, 2 },
                           { 3, 4 },
                           { 5, 6 }};

// 或者
int[,] arr1 ={{ 10, 20 },
                { 30, 40 },
                { 50, 60 }};

// 打印数组元素
for (int i = 0; i < arr.GetLength(0); i++)
{
    for (int j = 0; j < arr1.GetLength(1); j++)
    {
        Console.Write(arr1[i, j]+" ");
    }
    Console.WriteLine();
}

        3.3 三维数组

        三维数组可以想象成一个立方体，由层、行和列组成。它适合存储具有三个维度的数据，如空间坐标。

// 定义和初始化三维整型数组
int[,,] arr = new int[2, 3, 2]
{
    {
        { 1, 2 },
        { 3, 4 },
        { 5, 6 }
    },
    {
        { 7, 8 },
        { 9, 10 },
        { 11, 12 }
    }
};

// 或者
int[,,] arr1 =
{
    {
        { 10, 20 },
        { 30, 40 },
        { 50, 60 }
    },
    {
        { 70, 80 },
        { 90, 100 },
        { 110, 120 }
    }
};

// 打印数组元素，依然For循环
for (int i = 0; i < arr1.GetLength(0); i++)
{
    for (int j = 0; j < arr1.GetLength(1); j++)
    {
        for (int k = 0; k < arr1.GetLength(2); k++)
        {
            Console.Write(arr1[i, j, k] + " ");
        }
        Console.WriteLine();
    }
     Console.WriteLine();
}

        大多数人是不是认为三维数组很难理解大家可以这样来看，就是只看第一个数，如果是几，它就是几个二维数组，这样是不是很好理解，比如[2,3,2]就是两个3行2列二维数组的三维数组。

补充：这里再简单的讲解一下交错数组

        交错数组（Jagged Array），在C#中，通常指的是数组的数组，其中每个子数组可以拥有不同的长度。这是因为交错数组的每个元素本身也是一个数组，因此它可以模拟不规则的二维数据结构。交错数组与多维数组不同，后者在每一行的元素数量上是固定的。

交错数组的特点：

• 不规则的形状：交错数组可以有任意长度的子数组，这意味着你可以在第一行有五个元素，第二行有三个元素，第三行有两个元素等等。

• 内存布局：交错数组的每个子数组可能存储在不同的内存位置，因为每个子数组是独立的数组对象。这意味着，即使子数组之间相邻，它们在内存中也不一定是连续的。

• 初始化和访问：交错数组的初始化和访问比多维数组稍微复杂一些。你需要为每个子数组单独分配内存，而且访问元素时需要先访问子数组，然后再访问子数组中的元素。

4. 需求：有个88笔费用记录，总额3亿，金额在300万~800万之间，随机数如何实现？并记录总耗时。 

   需求分析

• 记录数量：88笔费用记录。

• 数值范围：每笔费用在300万至800万之间（包含边界）。

• 总额：所有记录的总和应为3亿元。

代码实现：

using System.Diagnostics;

int totalAmount = 300000000;
int minAmount = 3000000;
int maxAmount = 8000000;
int recordCount = 88;

// 初始化记录列表
int[] records = Enumerable.Repeat(minAmount, recordCount).ToArray();//创建一个指定长度的数组，其中每一个元素都是同一个值

// 计算剩余需要分配的金额
int remainingAmount = totalAmount - (minAmount * recordCount);

// 创建随机数生成器
Random rand = new Random();

// 分配剩余金额
while (remainingAmount > 0)
{
    // 随机选择一个记录
    int index = rand.Next(0,recordCount);
    //Console.WriteLine(index);

    // 确定可以分配的最大金额
    int maxAllocation = Math.Min(remainingAmount, maxAmount - records[index]);
    //Console.WriteLine(maxAllocation);

    // 随机分配金额
    int allocation = rand.Next(1, maxAllocation + 1);
    Console.WriteLine(allocation);
    // 更新记录和剩余金额
    records[index] += allocation;
    remainingAmount -= allocation;
}

// 计时
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();

// 输出结果
int Count = 0;
foreach (int record in records)
{
   /* Count++;
    Console.WriteLine("第{0}条记录: {1}", Count, record);*/
}
long sum = 0;
foreach (int record in records)
{
    sum += record;
}
Console.WriteLine("分配后的总金额: {0}", sum);

stopwatch.Stop();
Console.WriteLine("执行时间: {0} ms",stopwatch.Elapsed.TotalMilliseconds);

        代码的主要思路是先给88个记录分上300万确保大于300万，之后就将剩余的钱随机生成分配给88个记录。

5. 简述常见的集合类型的存储结构和它们的作用以及优缺点，并写出实现案例

        5.1 ArrayList

• 存储结构：动态数组，可以根据需要自动扩展。
• 作用：存储和管理任意类型的对象集合。
• 优点：支持多种数据类型，动态扩展。
• 缺点：类型转换时有装箱和拆箱开销，性能低于泛型集合。

        实现案例：

        ArrayList list = new ArrayList();
        list.Add(1);
        list.Add("Hello");
        list.Add(3.14);
        
        Console.WriteLine(list[0]);
        Console.WriteLine(list[1]);
        Console.WriteLine(list[2]);

        5.2 Hashtable哈希表

• 存储结构：哈希表，通过哈希算法快速定位元素。
• 作用：存储键值对，通过键快速访问值。
• 优点：查找效率高，O(1)平均时间复杂度。
• 缺点：键必须唯一，类型转换时有装箱和拆箱开销。

        案例实现：

Hashtable table = new Hashtable();
table.Add("Key1", "Value1");
table.Add("Key2", "Value2");
        
Console.WriteLine(table["Key1"]);

        5.3  List<T>

• 存储结构：动态数组，类似于ArrayList，但使用泛型。
• 作用：存储和管理特定类型的对象集合。
• 优点：避免了装箱和拆箱，性能高。
• 缺点：只能存储单一类型的数据。

        实现案例：

List<int> numbers = new List<int>();
numbers.Add(1);
numbers.Add(2);
numbers.Add(3);
        
Console.WriteLine(numbers[0]);
Console.WriteLine(numbers[1]);
Console.WriteLine(numbers[2]);

         5.4 链表 (LinkedList<T>)

• 存储结构：链表由一系列节点组成，每个节点包含数据和指向下一个节点的引用。
• 作用：动态地管理数据，可以高效地在中间插入和删除元素。
• 优点：插入和删除操作比数组快，因为不需要移动大量元素。
• 缺点：随机访问慢，因为需要从头开始遍历到目标节点。

        实现案例： 

LinkedList<int> linkedList = new LinkedList<int>();
linkedList.AddLast(1);
linkedList.AddLast(2);
linkedList.AddLast(3);
        
LinkedListNode<int> node = linkedList.First;
while (node != null)
{
    Console.WriteLine(node.Value);
    node = node.Next;
}

        5.5 栈 (Stack<T>)

• 存储结构：栈是一种后进先出（LIFO）的数据结构，只允许在一端（栈顶）进行插入和删除操作。
• 作用：用于需要保存和恢复状态的场景，如函数调用、表达式解析等。
• 优点：插入和删除操作快速。
• 缺点：只能访问栈顶元素。

        实现案例： 

Stack<int> stack = new Stack<int>();
stack.Push(1);
stack.Push(2);
stack.Push(3);

Console.WriteLine(stack.Pop()); // 输出3
Console.WriteLine(stack.Pop()); // 输出2

        5.6 队列 (Queue<T>)

• 存储结构：队列是一种先进先出（FIFO）的数据结构，允许在一端插入元素，在另一端删除元素。
• 作用：用于需要按照顺序处理元素的场景，如任务调度、消息队列等。
• 优点：插入和删除操作快速，保持元素的顺序。
• 缺点：只能访问队首和队尾元素。

        实现案例：

Queue<int> queue = new Queue<int>();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);

Console.WriteLine(queue.Dequeue()); // 输出1
Console.WriteLine(queue.Dequeue()); // 输出2