简介

静态工具类 ListUtil，提供了常用的 List 操作方法，包括元素的添加、删除、查找、去重、筛选、排序、分页、批量操作、比较、交集、并集和差集等等。这些方法提供了对 List 对象进行更加复杂和全面的操作，使开发人员能够更加高效地处理 List 数据。

EasyTool.ListUtil 类

方法说明:

• IndexOf: 在列表中查找元素，并返回其索引。如果未找到，则返回 -1。
• AddRange: 向列表中添加多个元素。
• RemoveAt: 在列表中删除指定索引处的元素。
• Remove: 从列表中删除指定元素的第一个匹配项。
• Concat: 将指定的列表连接起来，形成一个新的列表。
• Distinct: 返回一个新的列表，其中包含指定列表中的元素，但不包括重复元素。
• Where: 根据指定的条件筛选出列表中符合条件的元素。
• Select: 将列表中的每个元素应用到指定的转换函数，并返回转换后的新列表。
• ForEach: 对列表中的每个元素应用指定的操作。
• Sort: 将列表中的元素按指定的比较器排序。
• Page: 将列表中的元素分页显示。
• Equals: 判断两个列表是否相等。
• Intersect: 返回两个列表的交集。
• Union: 返回两个列表的并集。
• Except: 返回两个列表的差集。

IndexOf-在列表中查找元素，并返回其索引

/// <summary>
/// 在列表中查找元素，并返回其索引。如果未找到，则返回 -1。
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list">要查找的列表</param>
/// <param name="item">要查找的元素</param>
/// <returns>元素在列表中的索引，如果未找到则返回 -1</returns>
public static int IndexOf<T>(List<T> list, T item)

AddRange-向列表中添加多个元素

/// <summary>
/// 向列表中添加多个元素
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list">要添加元素的列表</param>
/// <param name="items">要添加到列表中的元素</param>
public static void AddRange<T>(List<T> list, IEnumerable<T> items)

RemoveAt-在列表中删除指定索引处的元素

/// <summary>
/// 在列表中删除指定索引处的元素
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list">要删除元素的列表</param>
/// <param name="index">要删除元素的索引</param>
public static void RemoveAt<T>(List<T> list, int index)

Remove-从列表中删除指定元素的第一个匹配项

/// <summary>
/// 从列表中删除指定元素的第一个匹配项
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list">要删除元素的列表</param>
/// <param name="item">要删除的元素</param>
/// <returns>如果找到并成功删除元素，则返回 true；否则返回 false</returns>
public static bool Remove<T>(List<T> list, T item)

Concat-将指定的列表连接起来，形成一个新的列表

/// <summary>
/// 将指定的列表连接起来，形成一个新的列表
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="lists">要连接的列表</param>
/// <returns>连接后的新列表</returns>
public static List<T> Concat<T>(IEnumerable<List<T>> lists)

/// <summary>
/// 将指定的列表连接起来，形成一个新的列表
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="lists">要连接的列表</param>
/// <returns>连接后的新列表</returns>
public static List<T> Concat<T>(params List<T>[] lists)

Distinct-返回一个新的列表，其中包含指定列表中的元素，但不包括重复元素

/// <summary>
/// 返回一个新的列表，其中包含指定列表中的元素，但不包括重复元素
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list">要去重的列表</param>
/// <returns>去重后的新列表</returns>
public static List<T> Distinct<T>(List<T> list)

Where-根据指定的条件筛选出列表中符合条件的元素

/// <summary>
/// 根据指定的条件筛选出列表中符合条件的元素
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list">要筛选的列表</param>
/// <param name="predicate">筛选条件</param>
/// <returns>符合条件的元素列表</returns>
public static List<T> Where<T>(List<T> list, Func<T, bool> predicate)

Select-将列表中的每个元素应用到指定的转换函数，并返回转换后的新列表

/// <summary>
/// 将列表中的每个元素应用到指定的转换函数，并返回转换后的新列表
/// </summary>
/// <typeparam name="TSource">列表元素类型</typeparam>
/// <typeparam name="TResult">转换后的元素类型</typeparam>
/// <param name="list">要转换的列表</param>
/// <param name="selector">转换函数</param>
/// <returns>转换后的新列表</returns>
public static List<TResult> Select<TSource, TResult>(List<TSource> list, Func<TSource, TResult> selector)

ForEach-对列表中的每个元素应用指定的操作

/// <summary>
/// 对列表中的每个元素应用指定的操作
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list">要应用操作的列表</param>
/// <param name="action">要应用的操作</param>
public static void ForEach<T>(List<T> list, Action<T> action)

Sort-将列表中的元素排序

/// <summary>
/// 将列表中的元素排序
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list">要排序的列表</param>
public static void Sort<T>(List<T> list)

Sort-将列表中的元素按指定的比较器排序

/// <summary>
/// 将列表中的元素按指定的比较器排序
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list">要排序的列表</param>
/// <param name="comparer">比较器</param>
public static void Sort<T>(List<T> list, IComparer<T> comparer)

Page-将列表中的元素分页显示

/// <summary>
/// 将列表中的元素分页显示
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list">要分页的列表</param>
/// <param name="pageSize">每页显示的元素数量</param>
/// <param name="pageIndex">要显示的页码，从 0 开始</param>
/// <returns>指定页的元素列表</returns>
public static List<T> Page<T>(List<T> list, int pageSize, int pageIndex)

AddRange-向列表中批量添加元素

/// <summary>
/// 向列表中批量添加元素
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list">要添加元素的列表</param>
/// <param name="items">要添加到列表中的元素</param>
public static void AddRange<T>(List<T> list, params T[] items)

Equals-判断两个列表是否相等

/// <summary>
/// 判断两个列表是否相等
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list1">要比较的第一个列表</param>
/// <param name="list2">要比较的第二个列表</param>
/// <returns>如果两个列表相等，则返回 true；否则返回 false</returns>
public static bool Equals<T>(List<T> list1, List<T> list2)

Intersect-返回两个列表的交集

/// <summary>
/// 返回两个列表的交集
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list1">要比较的第一个列表</param>
/// <param name="list2">要比较的第二个列表</param>
/// <returns>交集列表</returns>
public static List<T> Intersect<T>(List<T> list1, List<T> list2)

Union-返回两个列表的并集

/// <summary>
/// 返回两个列表的并集
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list1">要比较的第一个列表</param>
/// <param name="list2">要比较的第二个列表</param>
/// <returns>并集列表</returns>
public static List<T> Union<T>(List<T> list1, List<T> list2)

Except-返回两个列表的差集

/// <summary>
/// 返回两个列表的差集
/// </summary>
/// <typeparam name="T">列表元素类型</typeparam>
/// <param name="list1">要比较的第一个列表</param>
/// <param name="list2">要比较的第二个列表</param>
/// <returns>差集列表</returns>
public static List<T> Except<T>(List<T> list1, List<T> list2)

代码示例

using System;
using System.Collections.Generic;
using ListUtil;

class Program
{
    static void Main(string[] args)
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 3, 4, 5, 6, 7 };

        // 添加元素
        ListUtil.ListUtil.Add(list1, 6);
        ListUtil.ListUtil.AddRange(list2, new int[] { 8, 9 });

        // 删除元素
        ListUtil.ListUtil.RemoveAt(list1, 0);
        ListUtil.ListUtil.Remove(list2, 6);

        // 查找元素
        int index = ListUtil.ListUtil.IndexOf(list1, 4);

        // 去重
        List<int> distinctList = ListUtil.ListUtil.Distinct(list2);

        // 筛选
        List<int> filteredList = ListUtil.ListUtil.Where(list1, x => x % 2 == 0);

        // 转换
        List<string> stringList = ListUtil.ListUtil.Select(list1, x => x.ToString());

        // 操作
        ListUtil.ListUtil.ForEach(list2, x => Console.WriteLine(x));

        // 排序
        ListUtil.ListUtil.Sort(list1);

        // 分页
        List<int> pageList = ListUtil.ListUtil.Page(list1, 2, 1);

        // 比较
        bool isEqual = ListUtil.ListUtil.Equals(list1, list2);

        // 集合运算
        List<int> intersectList = ListUtil.ListUtil.Intersect(list1, list2);
        List<int> unionList = ListUtil.ListUtil.Union(list1, list2);
        List<int> exceptList = ListUtil.ListUtil.Except(list1, list2);

        Console.WriteLine("List 1:");
        ListUtil.ListUtil.ForEach(list1, x => Console.Write(x + " "));
        Console.WriteLine();

        Console.WriteLine("List 2:");
        ListUtil.ListUtil.ForEach(list2, x => Console.Write(x + " "));
        Console.WriteLine();

        Console.WriteLine("Index of 4 in List 1: " + index);

        Console.WriteLine("Distinct list 2:");
        ListUtil.ListUtil.ForEach(distinctList, x => Console.Write(x + " "));
        Console.WriteLine();

        Console.WriteLine("Filtered list 1 (even numbers only):");
        ListUtil.ListUtil.ForEach(filteredList, x => Console.Write(x + " "));
        Console.WriteLine();

        Console.WriteLine("String list 1:");
        ListUtil.ListUtil.ForEach(stringList, x => Console.Write(x + " "));
        Console.WriteLine();

        Console.WriteLine("Sorted list 1:");
        ListUtil.ListUtil.ForEach(list1, x => Console.Write(x + " "));
        Console.WriteLine();

        Console.WriteLine("Page 2 of list 1 (page size = 2):");
        ListUtil.ListUtil.ForEach(pageList, x => Console.Write(x + " "));
        Console.WriteLine();

        Console.WriteLine("List 1 and list 2 are equal: " + isEqual);

        Console.WriteLine("Intersect of list 1 and list 2:");
        ListUtil.ListUtil.ForEach(intersectList, x => Console.Write(x + " "));
        Console.WriteLine();

        Console.WriteLine("Union of list 1 and list 2:");
        ListUtil.ListUtil.ForEach(unionList, x => Console.Write(x + " "));
        Console.WriteLine();

        Console.WriteLine("Except of list 1 and list 2:");
        ListUtil.ListUtil.ForEach(exceptList, x => Console.Write(x + " "));
        Console.WriteLine();
    }
}

输出结果

List 1:
2 3 4 5 6 
List 2:
3 4 5 7 8 9 
Index of 4 in List 1: 2
Distinct list 2:
3 4 5 7 8 9 
Filtered list 1 (even numbers only):
2 4 6 
String list 1:
2 3 4 5 6 
3
4
5
7
8
9
Sorted list 1:
2 3 4 5 6 
Page 2 of list 1 (page size = 2):
4 5 
List 1 and list 2 are equal: False
Intersect of list 1 and list 2:
3 4 5 
Union of list 1 and list 2:
2 3 4 5 6 7 8 9 
Except of list 1 and list 2:
2 6