C#作业4

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

1.1整数转换为字符串
使用 ToString() 方法

int num = 123;
string str = num.ToString();
Console.WriteLine("整数转换为字符串: " + str);
ToString() 方法用于将整数转换为字符串。在上面的例子中，num.ToString() 返回的结果是字符串 "123"。

使用格式化字符串

int num = 456;
string str = string.Format("{0}", num);
Console.WriteLine("整数转换为字符串: " + str);
使用 string.Format 方法可以将整数转换为字符串，"{0}" 是格式化字符串中的占位符，用来插入整数值。

1.2字符串转换为整数
使用 int.Parse() 方法

string str = "789";
int num = int.Parse(str);
Console.WriteLine("字符串转换为整数: " + num);
int.Parse() 方法将字符串解析为整数。在上面的例子中，int.Parse(str) 返回的结果是整数 789。

使用 Convert.ToInt32() 方法

string str = "101";
int num = Convert.ToInt32(str);
Console.WriteLine("字符串转换为整数: " + num);
Convert.ToInt32() 方法也可以将字符串转换为整数。这个方法相比 int.Parse() 更为宽松，可以处理更多的输入格式，但性能略低。

1.3异常处理
需要注意的是，以上方法在字符串无法转换为有效的整数时会抛出异常。为了防止程序崩溃，可以使用 int.TryParse() 方法来进行安全的转换：

string str = "xyz";
int num;
if (int.TryParse(str, out num))
{
    Console.WriteLine("字符串转换为整数: " + num);
}
else
{
    Console.WriteLine("无法将字符串转换为整数.");
}
int.TryParse() 尝试将字符串转换为整数，如果转换成功，则将结果存储在 num 变量中，并返回 true；如果转换失败，则返回 false，此时 num 会保持其默认值。

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

2.1获取当前日期时间
DateTime currentDateTime = DateTime.Now;
Console.WriteLine("当前日期时间: " + currentDateTime);
上面的代码使用 DateTime.Now 获取当前的日期和时间，并将其存储在 currentDateTime 变量中。

日期时间转换为字符串
使用 ToString() 方法

DateTime date = DateTime.Now;
string dateString = date.ToString("yyyy-MM-dd");
Console.WriteLine("日期转换为字符串: " + dateString);
ToString() 方法可以将 DateTime 对象转换为指定格式的字符串。在上面的例子中，date.ToString("yyyy-MM-dd") 将日期转换为形如 "2024-07-04" 的字符串。

使用 String.Format 方法

DateTime date = DateTime.Now;
string dateString = String.Format("{0:yyyy-MM-dd HH:mm:ss}", date);
Console.WriteLine("日期转换为字符串: " + dateString);
String.Format 方法也可以格式化日期时间为字符串。"{0:yyyy-MM-dd HH:mm:ss}" 中的格式字符串决定了输出的格式，包括日期、时间和分隔符。

2.2字符串转换为日期时间
使用 DateTime.ParseExact() 方法

string dateString = "2024-07-04";
DateTime date = DateTime.ParseExact(dateString, "yyyy-MM-dd", CultureInfo.InvariantCulture);
Console.WriteLine("字符串转换为日期: " + date.ToString());
DateTime.ParseExact() 方法允许你按照指定格式将字符串解析为 DateTime 对象。在上面的例子中，DateTime.ParseExact(dateString, "yyyy-MM-dd", CultureInfo.InvariantCulture) 将形如 "2024-07-04" 的字符串解析为对应的日期对象。

使用 DateTime.TryParseExact() 方法

string dateString = "2024-07-04";
DateTime date;
if (DateTime.TryParseExact(dateString, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out date))
{
    Console.WriteLine("字符串转换为日期: " + date.ToString());
}
else
{
    Console.WriteLine("无法将字符串解析为日期.");
}
DateTime.TryParseExact() 方法与 DateTime.ParseExact() 类似，但它不会抛出异常。如果解析成功，它会返回 true 并将结果存储在 date 变量中；否则返回 false。

异常处理
在使用 DateTime.ParseExact() 或 DateTime.TryParseExact() 方法时，如果提供的字符串格式与实际格式不匹配，或者字符串无法解析为有效的日期时间，都会导致异常或返回 false。因此，建议在转换时进行适当的异常处理或错误检查，以确保程序的稳定性和可靠性。

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

一维数组
一维数组是最简单的数组形式，只包含一组元素。

声明和初始化一维数组：

// 声明并初始化一个整数类型的一维数组
int[] array1D = new int[5]; // 长度为5的整数数组，元素默认初始化为0

// 直接初始化数组
int[] array1DInit = { 1, 2, 3, 4, 5 }; // 包含5个元素的整数数组，值分别为1到5
访问一维数组中的元素：
Console.WriteLine(array1D[0]); // 访问第一个元素
array1D[1] = 10; // 修改第二个元素的值

二维数组
二维数组是一个表格形式的数组，包含行和列。

声明和初始化二维数组：

// 声明并初始化一个整数类型的二维数组
int[,] array2D = new int[3, 4]; // 3行4列的整数数组，默认元素初始化为0

// 直接初始化数组
int[,] array2DInit = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; // 3行3列的整数数组，值从1到9

访问二维数组中的元素：

Console.WriteLine(array2D[0, 0]); // 访问第一行第一列的元素
array2D[1, 2] = 20; // 修改第二行第三列的元素值

三维数组
三维数组是一种包含多个二维数组的数组。

声明和初始化三维数组：

// 声明并初始化一个整数类型的三维数组
int[,,] array3D = new int[2, 3, 4]; // 2个3行4列的整数数组，默认元素初始化为0

// 直接初始化数组
int[,,] array3DInit =
{
    {
        { 1, 2, 3, 4 },
        { 5, 6, 7, 8 },
        { 9, 10, 11, 12 }
    },
    {
        { 13, 14, 15, 16 },
        { 17, 18, 19, 20 },
        { 21, 22, 23, 24 }
    }
}; // 两个3行4列的整数数组，每个数组中的元素从1到24
访问三维数组中的元素：

Console.WriteLine(array3D[0, 1, 2]); // 访问第一个二维数组的第二行第三列的元素
array3D[1, 2, 3] = 30; // 修改第二个二维数组的第三行第四列的元素值

假设有一个三维数组 a3：

int[,,] a3 = new int[3, 4, 5]; // 一个3x4x5的三维数组
如果要遍历一个三维数组 a3，
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();
}

a3.GetLength(0) 返回数组的第一维度（深度）的长度。
a3.GetLength(1) 返回数组的第二维度（行数）的长度。
a3.GetLength(2) 返回数组的第三维度（列数）的长度。

还可以使用

foreach(int item in a3)
{
    Console.WriteLine(item + " ");
}

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

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace KeTangLianXi
{
    internal class RandomAmount
    {
        public void Amount()
        {

            const int totalRecords = 88;
            const double totalAmount = 300000000;
            const double minAmount = 3000000;
            const double maxAmount = 8000000;

            Random random = new Random();
            double[] amounts = new double[totalRecords];
            double sum = 0;

            Stopwatch stopwatch = Stopwatch.StartNew();

            // 生成一组随机数
            for (int i = 0; i < totalRecords; i++)
            {
                amounts[i] = random.NextDouble();
                sum += amounts[i];
            }

            // 按比例调整这组随机数，使其总和等于1
            for (int i = 0; i < totalRecords; i++)
            {
                amounts[i] /= sum;
            }

            // 将这组随机数映射到[minAmount, maxAmount]区间，并调整它们的总和为totalAmount
            double scale = totalAmount / (minAmount * totalRecords);
            for (int i = 0; i < totalRecords; i++)
            {
                amounts[i] = amounts[i] * (maxAmount - minAmount) * scale + minAmount;
            }

            // 修正最后一笔金额，使得总金额等于目标总额
            double total = amounts.Sum();
            amounts[totalRecords - 1] += totalAmount - total;

            stopwatch.Stop();

            // 输出生成的费用记录和总金额
            Console.WriteLine("生成的费用记录：");
            for (int i = 0; i < totalRecords; i++)
            {
                Console.WriteLine($"记录{i + 1}: {amounts[i]}");
            }
            Console.WriteLine($"总金额: {amounts.Sum()}");
            Console.WriteLine($"总耗时: {stopwatch.Elapsed.TotalMilliseconds}毫秒");
        }
    }
}

using KeTangLianXi;
RandomAmount a= new RandomAmount();
a.Amount();

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

1. Array
中文名称：数组
存储结构：连续内存空间，存储相同类型的元素。
作用：用于存储固定大小的元素集合，支持通过索引访问元素，但大小固定不变。

int[] numbers = new int[5]; // 创建一个包含5个整数的数组
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
Console.WriteLine("Array Example:");
foreach (var number in numbers)
{
    Console.WriteLine(number);
}
数组是最基本的数据结构之一，它提供了快速的元素访问和较低的内存消耗，但缺点是大小固定，无法动态调整。

2. List<T>(列表（泛型）)
存储结构：动态数组，存储指定类型的元素。
作用：用于存储和操作指定类型的元素集合，支持动态大小调整。
优点：
提供类型安全和高效的操作。
支持动态增删元素。

示例用法：
class Program
{
    static void Main()
    {
        // 创建一个 List<T>
        List<object> list = new List<object>();

        // 添加元素
        list.Add(10);               // 添加整数
        list.Add("Hello");          // 添加字符串
        list.Add(3.14);             // 添加浮点数

        // 遍历并输出元素
        Console.WriteLine("List<T> Example:");
        foreach (var item in list)
        {
            Console.WriteLine(item);
        }

        // 修改元素
        list[1] = "World";          // 修改索引为1的元素

        // 移除元素
        list.RemoveAt(0);           // 移除索引为0的元素

        // 再次遍历并输出
        Console.WriteLine("\nModified List<T>:");
        foreach (var item in list)
        {
            Console.WriteLine(item);
        }
    }
}
3. ArrayList(动态数组列表)
存储结构：动态数组，内部是object数组，可以存储任意类型的对象。
作用：用于存储和操作对象的集合，支持动态大小调整。
优点：
可以存储任意类型的对象。
支持动态增删元素。
缺点：
存储和检索时需要进行装箱和拆箱操作，性能较差。

示例用法：
class Program
{
    static void Main()
    {
        // 创建一个 ArrayList
        ArrayList arrayList = new ArrayList();

        // 添加元素
        arrayList.Add(10);              // 添加整数
        arrayList.Add("Hello");         // 添加字符串
        arrayList.Add(3.14);            // 添加浮点数

        // 遍历并输出元素
        Console.WriteLine("ArrayList Example:");
        foreach (var item in arrayList)
        {
            Console.WriteLine(item);
        }

        // 修改元素
        arrayList[1] = "World";         // 修改索引为1的元素

        // 移除元素
        arrayList.RemoveAt(0);          // 移除索引为0的元素

        // 再次遍历并输出
        Console.WriteLine("\nModified ArrayList:");
        foreach (var item in arrayList)
        {
            Console.WriteLine(item);
        }
    }
}

4. LinkedList<T>
中文名称：链表（泛型）
存储结构：双向链表，用于存储和操作元素。
作用：支持高效的插入和删除操作，但访问元素时性能较差。

示例用法：
class Program
{
    static void Main()
    {
        // 创建一个 LinkedList<T>
        LinkedList<string> linkedList = new LinkedList<string>();

        // 向链表尾部添加元素
        linkedList.AddLast("John");
        linkedList.AddLast("Jane");
        linkedList.AddLast("Doe");

        // 遍历并输出链表元素
        Console.WriteLine("LinkedList<T> Example:");
        foreach (var item in linkedList)
        {
            Console.WriteLine(item);
        }

        // 在链表开头插入元素
        linkedList.AddFirst("Alice");

        // 移除链表中的一个元素
        linkedList.Remove("Jane");

        // 再次遍历并输出链表元素
        Console.WriteLine("\nModified LinkedList<T>:");
        foreach (var item in linkedList)
        {
            Console.WriteLine(item);
        }
    }
}
5. Stack<T>(栈（泛型）)
存储结构：后进先出（LIFO），基于数组或链表实现。
作用：用于需要后进先出顺序的数据存取。
优点：
简单高效，支持快速压栈和出栈操作。

示例用法：
class Program
{
    static void Main()
    {
        // 创建一个 Stack<T>
        Stack<int> stack = new Stack<int>();

        // 压栈操作
        stack.Push(1);
        stack.Push(2);
        stack.Push(3);

        // 出栈操作
        int poppedItem = stack.Pop(); // 移除并返回栈顶元素
        Console.WriteLine("Popped item: " + poppedItem);

        // 查看栈顶元素但不移除
        int peekedItem = stack.Peek(); // 返回但不移除栈顶元素
        Console.WriteLine("Peeked item: " + peekedItem);

        // 遍历并输出栈中的元素（注意：Stack<T> 本身不支持直接遍历，需要先转换成数组或者列表）
        Console.WriteLine("\nStack<T> Example:");
        foreach (var item in stack.ToArray())
        {
            Console.WriteLine(item);
        }
    }
}
6. Queue<T>(队列（泛型）)
存储结构：先进先出（FIFO），基于数组或链表实现。
作用：用于需要先进先出顺序的数据存取。
优点：
简单高效，支持快速入队和出队操作。

示例用法：
class Program
{
    static void Main()
    {
        // 创建一个 Queue<T>
        Queue<string> queue = new Queue<string>();

        // 入队操作
        queue.Enqueue("John");
        queue.Enqueue("Jane");
        queue.Enqueue("Doe");

        // 出队操作
        string dequeuedItem = queue.Dequeue(); // 移除并返回队列头部元素
        Console.WriteLine("Dequeued item: " + dequeuedItem);

        // 查看队列头部元素但不移除
        string peekedItem = queue.Peek(); // 返回但不移除队列头部元素
        Console.WriteLine("Peeked item: " + peekedItem);

        // 遍历并输出队列中的元素
        Console.WriteLine("\nQueue<T> Example:");
        foreach (var item in queue)
        {
            Console.WriteLine(item);
        }
    }
}

7. Hashtable(哈希表)
存储结构：哈希表，存储键值对。
作用：用于快速查找和存储键值对。
优点：
快速查找，平均时间复杂度为 O(1)。
缺点：
不支持泛型，存储和检索值时需要进行类型转换。

示例用法：
Hashtable hashtable = new Hashtable();
hashtable.Add("key1", "value1");
hashtable.Add("key2", "value2");
hashtable.Add("key3", "value3");
Console.WriteLine("Hashtable Example:");
foreach (var key in hashtable.Keys)
{
    Console.WriteLine($"{key}: {hashtable[key]}");
}