c#类型转换和常见集合类型

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

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

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

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

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

1）List

2）Array

3）ArrayList

4）LinkedList

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

字符串转整型：

1）使用int.Parse()方法：这个方法尝试将字符串参数转换为整数。如果字符串不是有效的整数表示，则会抛出FormatException。如果字符串表示的数字超出了int类型的范围，则会抛出OverflowException。

2）Convert.ToInt32(str) 方法用于将字符串（str）转换为32位整数（int）。如果字符串str包含的是一个有效的整数值（在int类型的范围内），那么这个方法会成功地将它转换为int类型。如果字符串不是一个有效的整数值，或者其表示的数值超出了int类型的范围，那么这个方法会抛出异常。
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);
整型转字符串，有两种方式：

1）任何类型与字符串连接，结果都是字符串

2）使用ToString()方法：这是将整数转换为字符串的最直接方法
int n = 123;
//第一种方式：任何类型与字符串连接，结果都是字符串
Console.WriteLine(""+n);
//第二种方式
Console.WriteLine(Convert.ToString(n));

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

字符串转日期：将字符串转换为DateTime类型，可以使用DateTime.Parse或DateTime.TryParse（后者更安全，因为它不会抛出异常）。
string s = "2024-07-04 09:49:03";
DateTime dt = DateTime.Parse(s);
Console.WriteLine(dt.ToString());
获取当前日期：可以使用DateTime.Now来获取当前的日期和时间（包括时、分、秒等）。
DateTime currentDateTime = DateTime.Now;
Console.WriteLine(currentDateTime.ToString());
日期转字符串：将DateTime对象转换为字符串，可以使用ToString方法，并可选地指定一个格式字符串。
DateTime dt2 = new DateTime(2024, 7, 4, 9, 51, 09);
Console.WriteLine(dt2.ToString());

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

Console.WriteLine(dt.Year.ToString());
Console.WriteLine(dt.Month.ToString());
Console.WriteLine(dt.Day.ToString());

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

在C#中，数组是一种数据结构，用于在内存中连续存储相同类型的数据。数组可以有多个维度，常见的一维、二维和三维数组分别用于存储线性、矩阵和三维空间中的元素。

一维数组：

一维数组是最简单的数组形式，它像一个列表，可以存储一系列的元素。
//声明数组，值类型都有默认值
int[] a1 = new int[3];
for (int i = 0; i < a1.Length; i++)
{
    a1[i] = i;
}
for (int i = 0; i < a1.Length; i++)
{
    Console.Write(a1[i]+" ");
}
Console.WriteLine();
//声明时，同时进行初始化
int[] a2 = new int[3] {1,2,3};
foreach (int i in a2)
{
    Console.Write(i+" "); 
}
Console.WriteLine();

int[] a3 = { 1, 2, 3 };
foreach (int i in a3)
{
    Console.Write(i + " ");
}
Console.WriteLine()
二维数组：

二维数组用于存储矩阵或表格中的数据，每个元素由两个索引（行和列）来访问。
//声明一个二维数组(静态数组)
int[] a1 = { 1, 2, 3, 4, 5, 6 };
//声明一个两行，三列的二维数组
int[,] a2 = new int[2, 3] { { 1, 2, 3 }, { 4, 5, 6 } };
//修改某个值
a2[0, 1] = 200;
//获取某维度的长度，不是总的长度，GetLength（n维度），维度从0开始
for (int i = 0; i < a2.GetLength(0); i++)
{
    for (int j = 0; j < a2.GetLength(1); j++)
    {
        Console.Write(a2[i,j] + " "); 
    }
    Console.WriteLine();
}
三维数组：

三维数组用于存储三维空间中的数据，如立方体中的值，每个元素由三个索引（通常是x, y, z）来访问。
//声明一个三维数组
int[,,] a3 = new int[2, 2, 2]
{
    {
        {1,2}, 
        {3,4}
    },
    {
        {5,6},
        {7,8}
    }

};
a3[0, 0, 0] = 100;
a3[1, 1, 1] = 999;

for (int i = 0; i < a3.GetLength(0); i++)
{
    for (int j = 0; j < a3.GetLength(1); j++)
    {
        for (int k = 0; k < a3.GetLength(2); k++)
        {
            Console.Write(a3[i,j,k] + " ");
        }
        Console.WriteLine();
    }
    Console.WriteLine();
}

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

想要生成一个包含88笔费用记录的数组，总额需要达到3亿，且每笔金额在300万到800万之间（包括300万和800万），可以使用Random类来生成随机数，并使用循环来构建数组。同时，可以使用Stopwatch类来记录整个过程的总耗时。

using System;
using System.Diagnostics;

class Program
{
    static void Main(string[] args)
    {
        Stopwatch stopwatch = Stopwatch.StartNew();
        Random random = new Random();
        int totalRecords = 88;
        long totalAmountNeeded = 300000000; // 3亿  
        long[] expenses = new long[totalRecords];
        long currentTotal = 0;

        // 初步分配费用，尽量平均分配  
        for (int i = 0; i < totalRecords - 1; i++)
        {
            // 为了避免最后一笔费用过小，我们可以先计算一个平均金额，然后在此基础上加上或减去一个随机数  
            long average = totalAmountNeeded / totalRecords;
            // 允许一定的波动，但不超过平均金额的10%  
            long fluctuation = random.Next((int)-(average / 10), (int)((average / 10) + 1)); 
            long amount = average + fluctuation;

            // 确保金额在合理范围内  
            amount = Math.Max(3000000, Math.Min(amount, 8000000));

            expenses[i] = amount;
            currentTotal += amount;
        }

        // 计算最后一笔费用，确保总额达到或稍微超过3亿  
        long lastAmount = totalAmountNeeded - currentTotal;
        // 如果最后一笔费用小于最小金额，则将其设置为最小金额  
        expenses[totalRecords - 1] = Math.Max(3000000, lastAmount);

        stopwatch.Stop();

        // 输出总耗时  
        Console.WriteLine($"总耗时: {stopwatch.ElapsedMilliseconds} 毫秒");

        // 输出费用数组  
        foreach (var expense in expenses)
        {
            Console.Write(expense +"  ");
        }

        // 验证总额
        long actualTotal = 0;
        foreach (var expense in expenses)
        {
            actualTotal += expense;
        }
        Console.WriteLine($"总金额: {actualTotal}");
    }
}

运行后的结果如图：

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

1）List<T>

存储结构：基于数组实现，支持动态扩容。
作用：用于存储元素的序列，支持随机访问。
优点：访问速度快（通过索引访问），支持动态扩容。
缺点：在列表中间插入或删除元素时效率较低，因为需要移动其他元素。
//<>泛型，编译器编译时可以进行类型的检查
List<int> list = new List<int>();
list.Add(100);
//list.Add("200"); //泛型在编译时就进行类型的检查，防止运行时报错
list.Add(200);
list.Add(300);
list.Add(900);
list.Add(400);

Console.WriteLine("容量：{0}",list.Capacity);
Console.WriteLine("元素的个数：{0}",list.Count);
list.Remove(200);
list.RemoveAt(1);
list.Sort();
foreach (int item in list)
{
    Console.WriteLine(item);
}
2）Array

存储结构：固定大小的连续内存块。
作用：用于存储固定数量的同类型元素，支持随机访问。
优点：访问速度快，因为元素在内存中是连续的。
缺点：大小固定，不支持动态扩容。
int[] numbers = new int[3] { 1, 2, 3 };  
Console.WriteLine(numbers[1]); // 输出 2
3）ArrayList

存储结构：ArrayList是一个非泛型集合，内部通过动态数组实现，可以存储不同类型的对象。
作用：ArrayList在泛型集合出现之前广泛使用，用于存储和操作动态数组的元素。
优点（相较于List<T>）：可以存储不同类型的对象。
缺点
性能开销：由于需要存储不同类型的对象，可能存在内存分配和类型转换的性能开销。
强制类型转换：访问元素时需要进行类型转换，增加了出错的可能性。
ArrayList arrayList = new ArrayList();
//添加一个元素
arrayList.Add(700);
arrayList.Add(200);
arrayList.Add(300);
arrayList.Add(800);
//超过申请的内存空间，翻倍（自动扩容，扩容策略：翻倍，2的倍数）
arrayList.Add(500);
//删除元素
arrayList.Remove(100);//代码的容错性
arrayList.RemoveAt(0); //索引值来删除
arrayList.RemoveAt(0); //索引值来删除

Console.WriteLine("动态数组的容量：{0}", arrayList.Capacity);
Console.WriteLine("动态数组的元素的个数：{0}", arrayList.Count);

arrayList.Sort(); //排序：从小到大
arrayList.Clear(); //清空

foreach (int item in arrayList)
{
    Console.WriteLine(item);
}
4）LinkedList<T>

存储结构：由一系列节点组成，每个节点包含数据和指向列表中下一个节点的引用（双向链表还包含指向前一个节点的引用）。
作用：在不需要快速随机访问元素的情况下，提供高效的插入和删除操作。
优点：
插入和删除操作高效，特别是在列表的开始或结束位置。
不需要像数组那样在添加或删除元素时移动其他元素。
缺点：
索引访问元素的速度相对较慢，需要从头或尾开始遍历。
占用内存比数组多，因为每个节点都需要额外的存储来保存指向其他节点的引用
LinkedList<string> linkedList = new LinkedList<string>();
linkedList.AddFirst("陈晨");
linkedList.AddFirst("陈希");
linkedList.AddFirst("陈冲");

linkedList.AddLast("陈川");

linkedList.Remove("陈晨");
linkedList.Remove("陈晨");

var node  = linkedList.Find("陈冲");
Console.WriteLine("当前节点的值：{0}",node.Value);
foreach (string linked in linkedList)
{
    Console.WriteLine(linked);
}