Easy-DotNET Easy-DotNET
🏠首页
  • 知识地图
  • 源码脑图

    • 总览
    • Program
    • WebApplication
    • Host主机
    • WebHost主机
    • 依赖注入
    • Autofac
    • Middleware中间件
    • RateLimiter限制速率
    • 响应缓存、请求解压缩
  • 设计初衷
  • 克隆
  • 类型转换
  • 日期时间
  • IO流
  • 工具类
  • 语言特性
  • 集合类
  • Codec编码
  • 文本操作
  • 数学
  • 图片
  • 网络
  • Emoji表情
  • C# 12
  • C# 11
  • C# 10
  • C# 9.0
  • C# 8.0
  • C# 早期版本
  • C# 教程
  • ORM
  • 定时任务
  • 日志
  • 认证与授权
  • Swagger
  • 对象映射
  • 熔断重试限流
  • 缓存
  • 注册发现
  • 网关
  • GraphQL
  • 更多
  • Docker

    • 简介
    • Adminer
    • Apisix
    • Apollo
    • Cassandra
    • Cerebro
    • ClickHouse
    • Consul
    • EasyMock
    • Elasticsearch
    • Emqx
    • FastDFS
    • Flink
    • Gitlab
    • Jenkins
    • Jrebel
    • MariaDB
    • MySQL
    • Percona
    • Phpmyadmin
    • PostgreSQL
    • Redis
  • Linux

    • 查看Linux系统信息
    • CentOS7调整磁盘分区
    • IO压测
    • 图形化监控工具Cockpit
  • 总览
  • 列表

    • 算法数据结构
    • API
    • 应用框架
    • 应用模板
    • 操作系统
    • 工作流
    • 入门套件
    • 示例
    • 人工智能
    • 程序集
    • Assets
    • 认证授权
    • Blazor
    • 区块链
    • 书籍
    • 自动构建
    • 报表
    • 缓存
    • 日历
    • 聊天
    • CLI
    • CLR
    • CMS
    • 代码分析和指标
    • 代码片段
    • 压缩
    • 持续集成
    • 密码学
    • 数据库
    • 数据库驱动
    • 日期时间
    • 反编译
    • 部署
    • DirectX
    • 分布式计算
    • DLR
    • 文档
    • 电商支付
    • 模拟器
    • 环境管理
    • ETL
    • 事件消息
    • Exception
    • 扩展
    • 函数式编程
    • 游戏引擎
    • GIS
    • Git工具
    • 绘图
    • GraphQL
    • GUI
    • HTML-CSS
    • HTTP
    • IDE
    • 图片处理
    • 安装工具
    • 交互式编程
    • 国际化
    • 互操作性
    • IoC
    • JS引擎
    • 日志
    • 机器学习和数据科学
    • Markdown
    • 邮件
    • 数学
    • 媒体
    • 指标
    • 微型框架
    • 最小化器
    • MVVM
    • 网络
    • 对象映射
    • Office
    • OpenAI
    • ORM
    • 包管理器
    • PDF
    • 性能分析工具
    • 协议
    • 推送通知
    • SQL构建器
    • 消息队列
    • RPC
    • 响应式编程
    • 实时通信
    • 正则表达式
    • 任务调度
    • SDK和API
    • 搜索引擎
    • 序列化
    • SMS
    • 状态机
    • 静态站点生成
    • 强命名
    • 风格指南
    • 模板引擎
    • 测试
    • 工具
    • 交易
    • UI自动测试
    • Visual Studio 插件
    • Web浏览器
    • Web框架
    • WebServers
    • WebSocket
    • Windows服务
    • WPF
    • 解析器
    • 源码生成
    • 其他
    • 资源
  • AspNetCore面试题
  • Elasticsearch面试题
  • MongoDB面试题
  • MySql面试题
  • Nginx面试题
  • RabbitMQ面试题
  • Redis面试题
  • 设计模式
  • 微服务
🧑‍💻.NET Blog
GitHub (opens new window)
🏠首页
  • 知识地图
  • 源码脑图

    • 总览
    • Program
    • WebApplication
    • Host主机
    • WebHost主机
    • 依赖注入
    • Autofac
    • Middleware中间件
    • RateLimiter限制速率
    • 响应缓存、请求解压缩
  • 设计初衷
  • 克隆
  • 类型转换
  • 日期时间
  • IO流
  • 工具类
  • 语言特性
  • 集合类
  • Codec编码
  • 文本操作
  • 数学
  • 图片
  • 网络
  • Emoji表情
  • C# 12
  • C# 11
  • C# 10
  • C# 9.0
  • C# 8.0
  • C# 早期版本
  • C# 教程
  • ORM
  • 定时任务
  • 日志
  • 认证与授权
  • Swagger
  • 对象映射
  • 熔断重试限流
  • 缓存
  • 注册发现
  • 网关
  • GraphQL
  • 更多
  • Docker

    • 简介
    • Adminer
    • Apisix
    • Apollo
    • Cassandra
    • Cerebro
    • ClickHouse
    • Consul
    • EasyMock
    • Elasticsearch
    • Emqx
    • FastDFS
    • Flink
    • Gitlab
    • Jenkins
    • Jrebel
    • MariaDB
    • MySQL
    • Percona
    • Phpmyadmin
    • PostgreSQL
    • Redis
  • Linux

    • 查看Linux系统信息
    • CentOS7调整磁盘分区
    • IO压测
    • 图形化监控工具Cockpit
  • 总览
  • 列表

    • 算法数据结构
    • API
    • 应用框架
    • 应用模板
    • 操作系统
    • 工作流
    • 入门套件
    • 示例
    • 人工智能
    • 程序集
    • Assets
    • 认证授权
    • Blazor
    • 区块链
    • 书籍
    • 自动构建
    • 报表
    • 缓存
    • 日历
    • 聊天
    • CLI
    • CLR
    • CMS
    • 代码分析和指标
    • 代码片段
    • 压缩
    • 持续集成
    • 密码学
    • 数据库
    • 数据库驱动
    • 日期时间
    • 反编译
    • 部署
    • DirectX
    • 分布式计算
    • DLR
    • 文档
    • 电商支付
    • 模拟器
    • 环境管理
    • ETL
    • 事件消息
    • Exception
    • 扩展
    • 函数式编程
    • 游戏引擎
    • GIS
    • Git工具
    • 绘图
    • GraphQL
    • GUI
    • HTML-CSS
    • HTTP
    • IDE
    • 图片处理
    • 安装工具
    • 交互式编程
    • 国际化
    • 互操作性
    • IoC
    • JS引擎
    • 日志
    • 机器学习和数据科学
    • Markdown
    • 邮件
    • 数学
    • 媒体
    • 指标
    • 微型框架
    • 最小化器
    • MVVM
    • 网络
    • 对象映射
    • Office
    • OpenAI
    • ORM
    • 包管理器
    • PDF
    • 性能分析工具
    • 协议
    • 推送通知
    • SQL构建器
    • 消息队列
    • RPC
    • 响应式编程
    • 实时通信
    • 正则表达式
    • 任务调度
    • SDK和API
    • 搜索引擎
    • 序列化
    • SMS
    • 状态机
    • 静态站点生成
    • 强命名
    • 风格指南
    • 模板引擎
    • 测试
    • 工具
    • 交易
    • UI自动测试
    • Visual Studio 插件
    • Web浏览器
    • Web框架
    • WebServers
    • WebSocket
    • Windows服务
    • WPF
    • 解析器
    • 源码生成
    • 其他
    • 资源
  • AspNetCore面试题
  • Elasticsearch面试题
  • MongoDB面试题
  • MySql面试题
  • Nginx面试题
  • RabbitMQ面试题
  • Redis面试题
  • 设计模式
  • 微服务
🧑‍💻.NET Blog
GitHub (opens new window)
npm
  • 最全工具类

    • 设计初衷
  • 克隆

    • 对象克隆-CloneUtil
  • 类型转换

    • 类型转换-ConvertUtil
  • 日期时间

    • 日期工具-DateTimeUtil
    • 时间戳工具-TimestampUtil
    • 农历工具-LunarCalendarUtil
    • 计时器工具-TimerUtil
  • IO流

    • IO工具类-IoUtil
    • 文件工具类-FileUtil
    • 文件类型判断-FileTypeUtil
    • 文件监听-WatchMonitor
    • 文件跟随-Tailer
  • 工具类

    • 概述
    • 信息脱敏工具-DesensitizedUtil
    • 字符串工具-StrUtil
    • 16进制工具-HexUtil
    • Escape工具-EscapeUtil
    • Hash算法-HashUtil
    • URL工具-URLUtil
    • XML工具-XmlUtil
    • 对象工具-ObjectUtil
    • 反射工具-ReflectUtil
    • 泛型类型工具-TypeUtil
    • 分页工具-PageUtil
    • 类工具-ClassUtil
    • 程序集工具-DLLUtil
    • 枚举工具-EnumUtil
    • 环境工具-EnvUtil
    • 进程工具-ProcessUtil
    • 运行时工具-RuntimeUtil
    • 数字工具-NumberUtil
    • 数组工具-ArrayUtil
    • 随机工具-RandomUtil
    • 唯一ID工具-IdUtil
    • 压缩工具-ZipUtil
    • 正则工具-RegexUtil
    • 身份证工具-IdcardUtil
    • 社会信用代码工具-CreditCodeUtil
    • MEF加载工具-MEFUtil
  • 语言特性

    • 单例工具-SingletonUtil
    • 二进码十进数-BCDUtil
    • 树结构工具-TreeUtil
  • 集合类

    • 概述
    • 字典工具-DictionaryUtil
    • 列表工具-ListUtil
      • 简介
      • EasyTool.ListUtil 类
        • IndexOf-在列表中查找元素,并返回其索引
        • AddRange-向列表中添加多个元素
        • RemoveAt-在列表中删除指定索引处的元素
        • Remove-从列表中删除指定元素的第一个匹配项
        • Concat-将指定的列表连接起来,形成一个新的列表
        • Distinct-返回一个新的列表,其中包含指定列表中的元素,但不包括重复元素
        • Where-根据指定的条件筛选出列表中符合条件的元素
        • Select-将列表中的每个元素应用到指定的转换函数,并返回转换后的新列表
        • ForEach-对列表中的每个元素应用指定的操作
        • Sort-将列表中的元素排序
        • Sort-将列表中的元素按指定的比较器排序
        • Page-将列表中的元素分页显示
        • AddRange-向列表中批量添加元素
        • Equals-判断两个列表是否相等
        • Intersect-返回两个列表的交集
        • Union-返回两个列表的并集
        • Except-返回两个列表的差集
      • 代码示例
        • 输出结果
    • Iterator工具-IteratorUtil
    • 队列工具-QueueUtil
    • 堆栈工具-StackUtil
    • 双向链表-LinkedListUtil
  • Codec编码

    • Base62编码解码-Base62
    • Base64编码解码-Base64
    • Base32编码解码-Base32
    • 莫尔斯电码-Morse
    • BCD码-BCD
    • 回转N位密码-Rot
    • Punycode实现-PunyCode
  • 文本操作

    • CSV文件处理工具-CsvUtil
    • Unicode编码转换工具-UnicodeUtil
    • 字符串切割-StrSplitter
  • 数学

    • 数学相关-MathUtil
    • 数据预测-PredictUtil
  • 图片

    • 图片工具-ImgUtil
  • 网络

    • 网络工具-NetUtil
  • Emoji表情

    • Emoji工具-EmojiUtil
目录

列表工具-ListUtil

# 简介

静态工具类 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 
上次更新: 2023/04/26, 22:10:06
字典工具-DictionaryUtil
Iterator工具-IteratorUtil

← 字典工具-DictionaryUtil Iterator工具-IteratorUtil→

Theme by Vdoing | Copyright © 2019-2024 一个大西瓜 | MIT License | 苏ICP备2023013501号
  • 跟随系统
  • 浅色模式
  • 深色模式
  • 阅读模式