C#基础2024.07.04

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

//将string类型转为int类型
//方法1：使用int.Parse实现
string str = "123";
int a = int.Parse(str);  

//方法2：使用Convert.ToInt32实现
int b = Convert.ToInt32(str);


//将int类型转换为string类型
int n = 123;
//方法1：任何类型和字符串连接，结果都是字符串
Console.WriteLine(""+n);
//方法2：使用Convert.ToString实现
Console.WriteLine(Convert.ToString(n));

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

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

//字符串转日期
String s = "2024-07-04 09:49:03";
DateTime dt = DateTime.Parse(s);

//日期转字符串
DateTime dt3 = new DateTime(2024,10,11);
Console.WriteLine(dt3.ToString());

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

本例展示数组的声明和遍历，对数组进行遍历时，可使用for循环和foreach实现。

//一维数组
//声明一维数组
int[] a1 = new int[3];  //直接声明，不赋值时，所有值均为0
int[] a2 = new int[3] { 1, 2, 3 };  //声明时，同时进行初始化
int[] a3 = { 1, 2, 3 };  //直接为数组赋值

//二维数组
//声明二维数组
int[,] a2 = new int[2, 3]； //直接声明，不赋值时，所有值均为0
int[] a1 = { 1, 2, 3, 4, 5, 6 };  //直接为数组赋值
int[,] a2 = new int[2, 3] { { 1, 2, 3 }, { 4, 5, 6 } };  //声明时，同时进行初始化

//三维数组
//声明三维数组，本例只展示一种声明方式，其他方式可参考上述例子，以此类推
int[,,] a3 = new int[2, 2, 2]
{
    {
        {1,2},
        {3,4}
    },
    {
        {5,6},
        {7,8}
    }
};

//遍历三维数组，GetLength(n)从不同的维度去遍历数组，n从0开始
//for循环遍历
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();
}

//foreach遍历，这种遍历每个数后面都会有一个空格，对输出格式有要求的，最好使用for循环
foreach (int i in a3)
{
    Console.WriteLine(i);
}

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

思路：先用随机数生成前87个数，当第88个数小于300万时，再挑几个数，缩小随机数范围，再次赋值，覆盖掉原来的数。

namespace DJConsoleProject
{
    internal class Test
    {
        public static void Main()
        {
            Random random = new Random();
            double remainAccount = 300000000; //总额3亿，remainAccount为剩余的资金
            DateTime startTime = DateTime.Now; //获取当前时间
            double[] array = new double[88]; //一共88笔交易，创建一个数组
            double sum = 0.0;  //验证最后的总额是否正确
            for (int i = 0; i < 88 - 1; i++)  //先为前87个数赋值
            {
                array[i] = random.Next(3000000, 8000000);  //随机数的取值范围在300万到800万
                remainAccount -= array[i];  //为array赋值后，remainAccount减去当前array值，算出剩余资金
            }
            int tmp = 0;  //创建一个tmp变量，相当于array数组的指针
            //当remainAccount < 3000000并且tmp < 88时，也就是说最后剩余的资金小于三百万，并且没有超出arary数组的长度时
            while (remainAccount < 3000000 && tmp < 88) 
            {
                remainAccount += array[tmp]; //先为remainAccount加上原来的array[i]的值
                array[tmp] = random.Next(3000000,3001000);  //再生成一个范围较小的数
                remainAccount -= array[tmp];  //最后remainAccount减去刚刚生成的随机数
                tmp++;
            }
            array[87] = remainAccount;  //为第88个数赋值
            
            foreach (int i in array)
            {
                sum += i;
                Console.WriteLine(i);
            }
            DateTime emdTime = DateTime.Now;
            Console.WriteLine("花费时间："+(emdTime - startTime).TotalSeconds + "s");
            Console.WriteLine("总和："+sum);
            Console.WriteLine("最小值："+array.Min());
            Console.WriteLine("最大值："+array.Max());
        }
    }
}

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

在C#中，集合类型主要用于存储一组数据。根据数据的存储方式和访问方式的不同，集合被设计成多种类型，每种类型都有其特定的使用场景。以下是几种常见的集合类型及其特点：

1、ArrayList

• ArrayList是一个可变大小的数组，它允许在运行时动态改变其大小。ArrayList在内部使用一个数组来存储元素，这意味着所有元素都存储在连续的内存位置中。当数组空间不足时，ArrayList会自动扩展数组的大小，通常是以当前大小的一定比例（例如1.5倍）进行扩容。
• 优点：随机访问元素非常快，时间复杂度为O(1)，因为元素是按索引存储的。支持多种集合操作，如排序和反转等。
• 缺点：插入和删除元素时，位于插入点之后的所有元素都必须移动，这可能导致较高的时间复杂度（O(n)）。内部数组的扩容可能导致额外的内存使用和复制操作。
• 实现案例

ArrayList arrayList = new ArrayList();
arrayList.Add(700);
arrayList.Add(200);
arrayList.Add(300);
arrayList.Add(400);
//超过申请内存空间，容量翻倍（自动扩容，扩容策略：翻倍，2的倍数）
//一旦申请，不释放
arrayList.Add(500); 
arrayList.RemoveAt(0);

//删除元素
arrayList.Remove(100); //删除元素后，容量不变  //代码的容错性
Console.WriteLine("动态数组的容量：{0}",arrayList.Capacity);
Console.WriteLine("动态数组的元素的个数：{0}",arrayList.Count);

arrayList.Sort();
arrayList.Clear();
foreach (int item in arrayList)
{
    Console.WriteLine(item);
}

2.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);
  }

3、LinkedList

LinkedList是一个双向链表，每个元素包含一个对其前驱和后继的引用。这种结构使得在链表中间插入或删除元素变得非常高效，因为只需要更新前后节点的引用即可，时间复杂度为O(1)。

优点：

• 在链表的任意位置插入或删除元素都非常快，不需要移动其他元素。
• 支持高效的迭代遍历。

缺点：

• 随机访问元素慢，时间复杂度为O(n)，因为需要从头开始遍历到目标元素。
• 每个元素需要额外的内存来存储前后节点的引用，这增加了内存开销。

示例代码

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 item in linkedList)
{
    Console.WriteLine(item);
}