简介

方法说明：

• IsEmpty: 判断数组是否为空
• Length: 获取数组长度
• Max: 获取数组中的最大值
• Min: 获取数组中的最小值
• Sum: 获取数组中的和
• Average: 获取数组的平均值
• Sort: 数组排序
• Reverse: 数组反转
• Contains: 判断数组是否包含某个元素
• Concat: 合并两个数组
• Equals: 判断两个数组是否完全相等

EasyTool. 类

静态工具类 ，提供了丰富的方法来操作数组，包括判断数组是否为空，获取数组的长度、最大值、最小值、和、平均值，对数组进行排序和反转，判断数组是否包含某个元素，合并两个数组，判断两个数组是否完全相等等功能。

IsEmpty-判断数组是否为空

/// <summary>
/// 判断数组是否为空
/// </summary>
/// <param name="array">要判断的数组</param>
/// <returns>如果数组为空，则返回 true；否则返回 false</returns>
public static bool IsEmpty(Array array)

Length-获取数组的长度

/// <summary>
/// 获取数组的长度
/// </summary>
/// <param name="array">要获取长度的数组</param>
/// <returns>返回数组的长度</returns>
public static int Length(Array array)

Max-获取数组中的最大值

/// <summary>
/// 获取数组中的最大值
/// </summary>
/// <param name="array">要获取最大值的数组</param>
/// <returns>返回数组中的最大值</returns>
public static T Max<T>(T[] array) where T : IComparable<T>

Min-获取数组中的最小值

/// <summary>
/// 获取数组中的最小值
/// </summary>
/// <param name="array">要获取最小值的数组</param>
/// <returns>返回数组中的最小值</returns>
public static T Min<T>(T[] array) where T : IComparable<T>

Sum-获取数组中的和

/// <summary>
/// 获取数组中的和
/// </summary>
/// <param name="array">要获取和的数组</param>
/// <returns>返回数组的和</returns>
public static int Sum(int[] array)

Average-获取数组的平均值

/// <summary>
/// 获取数组的平均值
/// </summary>
/// <param name="array">要获取平均值的数组</param>
/// <returns>返回数组的平均值</returns>
public static double Average(int[] array)

Sort-数组排序

/// <summary>
/// 数组排序
/// </summary>
/// <param name="array">要排序的数组</param>
/// <returns>返回排序后的数组</returns>
public static T[] Sort<T>(T[] array) where T : IComparable<T>

Reverse-数组反转

/// <summary>
/// 数组反转
/// </summary>
/// <param name="array">要反转的数组</param>
/// <returns>返回反转后的数组</returns>
public static T[] Reverse<T>(T[] array)

Contains-判断数组是否包含某个元素

/// <summary>
/// 判断数组是否包含某个元素
/// </summary>
/// <param name="array">要操作的数组</param>
/// <param name="item">要判断的元素</param>
/// <returns>如果数组中包含该元素，则返回 true；否则返回 false</returns>
public static bool Contains<T>(T[] array, T item)

Concat-合并两个数组

/// <summary>
/// 合并两个数组
/// </summary>
/// <param name="array1">数组1</param>
/// <param name="array2">数组2</param>
/// <returns>返回合并后的数组</returns>
public static T[] Concat<T>(T[] array1, T[] array2)

Equals-判断两个数组是否完全相等

/// <summary>
/// 判断两个数组是否完全相等
/// </summary>
/// <param name="array1">数组1</param>
/// <param name="array2">数组2</param>
/// <returns>如果两个数组完全相等，则返回 true；否则返回 false</returns>
public static bool Equals<T>(T[] array1, T[] array2)

使用示例

int[] array = { 1, 2, 3, 4, 5 };

// 获取数组长度
int length = ArrayUtil.Length(array);
Console.WriteLine("数组长度：" + length);
// 输出：数组长度：5

// 获取数组的最大值
int max = ArrayUtil.Max(array);
Console.WriteLine("数组的最大值：" + max);
// 输出：数组的最大值：5

// 获取数组的最小值
int min = ArrayUtil.Min(array);
Console.WriteLine("数组的最小值：" + min);
// 输出：数组的最小值：1

// 获取数组的和
int sum = ArrayUtil.Sum(array);
Console.WriteLine("数组的和：" + sum);
// 输出：数组的和：15

// 获取数组的平均值
double average = ArrayUtil.Average(array);
Console.WriteLine("数组的平均值：" + average);
// 输出：数组的平均值：3

// 数组排序
int[] sortedArray = ArrayUtil.Sort(array);
Console.WriteLine("排序后的数组：");
for (int i = 0; i < sortedArray.Length; i++)
{
    Console.Write(sortedArray[i] + " ");
}
// 输出：排序后的数组：1 2 3 4 5

// 数组反转
int[] reversedArray = ArrayUtil.Reverse(array);
Console.WriteLine("\n反转后的数组：");
for (int i = 0; i < reversedArray.Length; i++)
{
    Console.Write(reversedArray[i] + " ");
}
// 输出：反转后的数组：5 4 3 2 1

// 判断数组是否包含某个元素
bool contains = ArrayUtil.Contains(array, 3);
Console.WriteLine("数组是否包含元素3：" + contains);
// 输出：数组是否包含元素3：True

// 合并两个数组
int[] array2 = { 6, 7, 8, 9, 10 };
int[] concatedArray = ArrayUtil.Concat(array, array2);
Console.WriteLine("合并后的数组：");
for (int i = 0; i < concatedArray.Length; i++)
{
Console.Write(concatedArray[i] + " ");
}
// 输出：合并后的数组：1 2 3 4 5 6 7 8 9 10

// 判断两个数组是否完全相等
bool equals = ArrayUtil.Equals(array, array2);
Console.WriteLine("两个数组是否完全相等：" + equals);
// 输出：两个数组是否完全相等：False