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]}");
}