当前位置： 首页 > article >正文

C# 数组和列表的基本知识及 LINQ 查询

article 2025/3/6 20:39:18

数组和列表的基本知识及 LINQ 查询

  • 一、基本知识
  • 二、引用命名空间声明
  • 三、数组
    • 3.1、一维数组
    • 3.2、二维数组
    • 3.3、不规则数组 Jagged Array
  • 四、列表 List
    • 4.1、一维列表
    • 4.2、二维列表
  • 五、数组和列表使用 LINQ的操作和运算
    • 5.1、一维 LIST 删除所有含 double.NaN 的行
    • 5.2、一维 LIST 删除所有含指定数据的行
    • 5.3、一维 LIST 获得非重复的数列
    • 5.4、二维 LIST 的声明、初始化和访问
    • 5.5、二维 LIST 使用 LINQ 筛选掉包含 double.NaN 的行及空行
  • 六、二维 LIST 和二维数组相互转换
    • 6.1、二维数组 int[,] 与 交错数组 int[][] 的区别
    • 6.2、二维 LIST 转换为 交错数组
    • 6.3、二维 LIST 转换为二维数组
      • 6.3.1、直接转换
      • 6.3.2、使用交错数组作为转换过程
      • 6.3.3、使用 List<数组>作为转换过程
    • 6.4、使用 LINQ，简洁地将二维数组[,] 转换为 List

一、基本知识

数组和列表是 C# 操作计算数据的基础，配合 LINQ 查询可以实现代码的简洁访问。
LINQ 语言集成查询(Language Integrated Query)是.NET框架的扩展，一系列直接将查询功能集成到 C# 语言的技术统称,是一种使用类似 SQL 语句操作多种数据源的功能。List 类是 ArrayList 类的泛型等效类。数组可以是多维数据。

二、引用命名空间声明

using System;
using System.Linq;
using System.Collections.Generic;

三、数组

3.1、一维数组

double[] OneDimensionalArray = { 1.0, 2.0, double.NaN };

3.2、二维数组

double[,] TwoDimensionalArray = {
            { 1.0, 2.0, double.NaN },
            { 3.0, 4.0, 5.0 },
            { double.NaN, 6.0, 7.0 }
        };

3.3、不规则数组 Jagged Array

也叫交错数组。不同长度的行，可以使用 Jagged Array。使用Jagged Array时，每行的长度可以不同，这在某些情况下比使用List<List>更灵活。选择哪种方式取决于你的具体需求，比如是否需要动态改变行的长度。

int[][] jaggedArray = new int[3][]; // 声明一个三行的数组，每行的长度可以根据需要进行定义和修改。
jaggedArray[0] = new int[] { 1, 2 }; // 第一行有两个元素
jaggedArray[1] = new int[] { 3, 4, 5 }; // 第二行有三个元素
jaggedArray[2] = new int[] { 6 }; // 第三行有一个元素

四、列表 List

4.1、一维列表

List<double> OneDimensionalList = new List<double> { 1.8, 2.9, 3.7, 4.5 , double.NaN };
List<int> OneDimensionalList = new List<int> { 1, 2, 3, 4, 5 };
List<string> OneDimensionalList = new List<string> { "Alice", "Bob", "Charlie" };
List<object> OneDimensionalList = new List<object> { 1, "Hello", 3.14 };

4.2、二维列表

严格不叫二维，但可以等效数组一样操作，姑且这么称呼。

List<List<int>> TwoDimensionalList = new List<List<int>>() {
          new List<int> { 1, 2, 3 },
          new List<int> { 4, 5, 6 },
          new List<int> { 7, 8, 9 },
};


List<List<int>> TwoDimensionalList = new List<List<int>>();
TwoDimensionalList.Add(new List<int> { 1, 2, 3 });// 添加行
TwoDimensionalList.Add(new List<int> { 4, 5, 6 });
TwoDimensionalList.Add(new List<int> { 7, 8, 9 });

五、数组和列表使用 LINQ的操作和运算

5.1、一维 LIST 删除所有含 double.NaN 的行

List<double> OneDimensionalList = new List<double> { 1.8, 2.9, 3.7, 4.5 , double.NaN, 168 };
OneDimensionalList.RemoveAll(n => double.IsNaN(n));

5.2、一维 LIST 删除所有含指定数据的行

List<string> OneDimensionalList = new List<string> { 
"Alice TWO Y", 
"Bob WO", 
"Charlie who Y"
"Hi LIST"
};
foreach (string row in OneDimensionalList)
{
    string[] SplitString = row.Split(' ');//行数据分裂
    if (SplitString[2] == "Y")//第3个字符等于Y的
    {
     OneDimensionalList.RemoveAll(x => x == row);//删除第3列等于字符Y的行
    }
}

// 在指定位置插入元素（例如，在索引为2的位置插入7）
 OneDimensionalList.Insert(2, 7);
 
// 移除指定值的第一个匹配项（如果有的话）
OneDimensionalList.Remove(7); // 如果7存在，则移除它
OneDimensionalList.RemoveAt(0); // 移除索引为0的元素，即原本的1
OneDimensionalList.Clear(); // 清空列表中的所有元素
bool containsThree = OneDimensionalList.Contains(3); //检查元素是否存在于列表中，如果3存在，返回true，否则返回false
int count =  OneDimensionalList.Count; // 获取列表中的元素数量

5.3、一维 LIST 获得非重复的数列

List<string> OneDimensionalList = new List<string> { 
"Alice TWO Y", 
"Bob WO", 
"Charlie who Y"
"Hi LIST"
"Charlie who Y"
};
HashSet<string> hs = new HashSet<string>(OneDimensionalList); //HashSet存储一组不重复的元素
OneDimensionalList = hs.ToList();// OneDimensionalList.Distinct().ToList();//返回非重复的数列
OneDimensionalList.Sort();//排序

5.4、二维 LIST 的声明、初始化和访问

//声明新的二维列表
List<List<int>> twoDimensionalList = new List<List<int>>();

//初始化二维列表 List ，添加 3 行 4 列
twoDimensionalList.Add(new List<int> { 1, 2, 3, 4 });//添加一维 List 元素
twoDimensionalList.Add(new List<int> { 5, 6, 7, 8 });
twoDimensionalList.Add(new List<int> { 9, 10, 11, 12 });

// 获取二维列表行数
int rowCount = twoDimensionalList.Count;

// 获取二维列表列数
int columnCount = twoDimensionalList.Count == 0 ? 0 : twoDimensionalList[0].Count;
int cols = twoDimensionalList.Select(row => row.Count).Max(); // 假设所有行长度相同，如果不是，需要处理不一致的情况

//简单访问二维 List 元素或值
int element = twoDimensionalList[0][1]; // 获取第一行、第二列元素的值（行索引为 0，列索引为 1），值为 2
Console.WriteLine(element);
twoDimensionalList[1][2] = 5; // 将第二行第三列的元素修改为5


//遍历二维列表，控制台输出
foreach (List<int> row in twoDimensionalList)
{
   foreach (int item in row)
    {
        Console.Write(item + " ");//控制台调试显示数据
    }
     Console.WriteLine();
}

foreach (var row in twoDList)
{
    foreach (var item in row)
    {
        Console.Write(item + " ");
    }
    Console.WriteLine(); // 换行，用于分隔各行
}

//遍历二维列表，修改数据，控制台输出，
for (int i = 0; i < rowCount; i++)
{
    for (int j = 0; j < columnCount; j++)
    {
       twoDimensionalList[i][j] += 1;//修改数据，二维数据每个数加 1
    }
}

//二维数组或 LIST 控制台显示，采用 Join 输出行数据
foreach (var row in TwoDimensionalArray)
{
  Console.WriteLine(string.Join(", ", row));
}

foreach (var row in TwoDimensionalList)
{
  Console.WriteLine(string.Join(", ", row));
}

//删除列表行，索引默认从零开始
twoDimensionalList.RemoveAt(2);//删除索引 2 的行数据

//删除集合中一定范围内的元素，索引默认从零开始
twoDimensionalList.RemoveRange(0, 2);//从索引 0 开始，删除 2 行数据

//在列表索引前插入元素（在第二行之前插入）
twoDimensionalList.Insert(1, new List<int> { 15, 16, 17, 18 });

//在特定位置插入新行，初始化为 0（在第一行之前插入）
twoDList.Insert(0, new List<int>(Enumerable.Repeat(0, cols)));

//初始化一个具有特定大小和内容的二维List
int rows = 3;
int cols = 4;
List<List<int>> twoDList = new List<List<int>>();
for (int i = 0; i < rows; i++)
{
    twoDList.Add(new List<int>(Enumerable.Repeat(0, cols))); // 添加一个新行，初始化为0
}

5.5、二维 LIST 使用 LINQ 筛选掉包含 double.NaN 的行及空行

 
 List<List<double>> TwoDimensionalList = new List<List<double>>()
 {
      new List<double> {  1.8, 2.9, 3.7, 4.5, 9.9, 168 },
      new List<double> {  1.8, 2.9, 3.7, 4.5, double.NaN, 168 },
      new List<double> { }, // 空行
      new List<double> {  2.8, 3.9, 4.7, 5.5, double.NaN, 668, },
      new List<double> {  1.8, 2.9, 3.7, 4.5, 9.9, 168 }
 };

 TwoDimensionalList = TwoDimensionalList.Where(row => !row.Contains(double.NaN) && row.Any()).ToList();//删除存在 double.NaN 的行及空行

// TwoDimensionalList = TwoDimensionalList.Where(row => row.Any()).ToList();//删除空行
// TwoDimensionalList = TwoDimensionalList.Where(row => !row.Contains(double.NaN)).ToList();//删除存在 double.NaN 的行

foreach (var row in TwoDimensionalList) { Console.WriteLine(string.Join(" ", row)); }

 //var filteredData = twoDimensionalList.Where(row => !row.Contains(double.NaN)).ToArray();

六、二维 LIST 和二维数组相互转换

6.1、二维数组 int[,] 与 交错数组 int[][] 的区别

二维 LIST 转换为二维数组 double[][] arrayOfArrays，严格说不是二维数组。
关于 double[][] 是交错数组，它其实是一个 double[] 里嵌套着double[]，可以理解为 (double[])[]。

对于int[,]，数组的行数和列数如下：

int[,] a=new int[2,3];
int row = a.GetLength(0);  //第一维的长度（即行数）  row=2;
int col = a.GetLength(1); //第二维的长度（即列数）col=3;
int length = a.Length;//二维数组的总长度  lenth=6;

对于交错数组 int[][]

int[][] a = { new int[] { 1, 5 }, new int[] { 7, 3 }, new int[] { 3, 5 } };
   //accounts.Length表示数组a中一维数组的个数3
   for (int i = 0; i < accounts.Length; i++)
   {
     int col = accounts[i].Length;//表示一维数组中其中一维数组的个数，看上面数组a,那么这里数组的个数就为2
     int sum = 0;
      for (int j = 0; j < col; j++)
       {
         sum = sum + accounts[i][j];
       }         
    }

6.2、二维 LIST 转换为 交错数组

List<List<double>> TwoDimensionalList = new List<List<double>>
{
    new List<double> { 1, 2, 3 },
    new List<double> { 4, 5, 6 },
    new List<double> { 7, 8, 9 }
};
//此二维数组不是double[,] arrayOfArrays 数组       
double[][] arrayOfArrays = TwoDimensionalList.Select(row => row.ToArray()).ToArray();

6.3、二维 LIST 转换为二维数组

6.3.1、直接转换

List<List<string>> lists = new List<List<string>>()
{
  new List<string>() { "C", "C++" },
  new List<string>() { "Java", "Kotlin" }
};

string[,] arrays = new string[lists.Count, lists[0].Count];
for (int i = 0; i < lists.Count; i++)
{
     for (int j = 0; j < lists[i].Count; j++)
     {
         arrays[i, j] = lists[i][j];
     }
}

//控制台输出二维数组结果
foreach (var array in arrays)
{
      Console.WriteLine(String.Join(", ", array));
}

//控制台输出结果(取数组的行列大小)
for (int i = 0; i < arrays.GetLength(0); i++)
{
     for (int j = 0; j < arrays.GetLength(1); j++)
     {
          Console.Write(arrays[i, j] + " ");
     }
     Console.WriteLine();
}

//控制台输出结果(取lists的行列大小)
int rows = lists.Count;
int cols = lists[0].Count;
for (int i = 0; i < rows; i++)
{
     for (int j = 0; j < cols; j++)
     {
         Console.Write(arrays[i, j] + " ");
     }
     Console.WriteLine();
}

6.3.2、使用交错数组作为转换过程

List<List<double>> TwoDimensionalList = new List<List<double>>
{
new List<double> { 1, 2, 3 },
new List<double> { 4, 5, 6 },
new List<double> { 7, 8, 9 }
};
//先转换为行列规则的交错数组形式 double[][] arrayOfArrays
double[][] arrayOfArrays = TwoDimensionalList.Select(row => row.ToArray()).ToArray();

int rows = arrayOfArrays.Length;//交错数组行数
int cols = arrayOfArrays.Max(array => array.Length);//交错数组列数
double[,] multiDimArray=new double[rows, cols];//声明二维数组
//转换为二维数组
for (int i = 0; i < rows; i++)
{
     for (int j = 0; j < cols; j++)
     {
          multiDimArray[i, j] = arrayOfArrays[i][j]; // 直接赋值
     }
}
//控制台输出结果
for (int i = 0; i < multiDimArray.GetLength(0); i++)
{
     for (int j = 0; j < multiDimArray.GetLength(1); j++)
     {
          Console.Write(multiDimArray[i, j] + " ");
     }
     Console.WriteLine();
}

6.3.3、使用 List<数组>作为转换过程

方法1

 List<List<int>> TwoDimensionalList = new List<List<int>>() {
          new List<int> { 1, 2, 3 },
          new List<int> { 4, 5, 6 },
          new List<int> { 7, 8, 9 }
            };
// 将List<List<int>>转换为List<int[]>
var listOfArrays = TwoDimensionalList.Select(row => row.ToArray()).ToList();

int[,] array = new int[listOfArrays.Count, listOfArrays[0].Length];
for (int i = 0; i < listOfArrays.Count; i++)
{
     for (int j = 0; j < listOfArrays[i].Length; j++)
     {
         array[i, j] = listOfArrays[i][j];
     }
}

// 输出结果验证
for (int i = 0; i < array.GetLength(0); i++)
{
     for (int j = 0; j < array.GetLength(1); j++)
     {
         Console.Write(array[i, j] + " ");
     }
     Console.WriteLine();
}

方法2

        // 示例二维List
        List<List<int>> listOfLists = new List<List<int>>
        {
            new List<int> { 1, 2, 3 },
            new List<int> { 4, 5, 6 },
            new List<int> { 7, 8, 9 }
        };
 
        // 将List<List<int>>转换为List<int[]>
        List<int[]> listOfArrays = new List<int[]>();
        foreach (var list in listOfLists)
        {
            listOfArrays.Add(list.ToArray());
        }
 
 
        // 然后将List<int[]>转换为二维数组int[,]
        int[,] array = new int[listOfArrays.Count, listOfArrays[0].Length];
        for (int i = 0; i < listOfArrays.Count; i++)
        {
            for (int j = 0; j < listOfArrays[i].Length; j++)
            {
                array[i, j] = listOfArrays[i][j];
            }
        }
 
        // 输出结果验证
        for (int i = 0; i < array.GetLength(0); i++)
        {
            for (int j = 0; j < array.GetLength(1); j++)
            {
                Console.Write(array[i, j] + " ");
            }
            Console.WriteLine();
        }

6.4、使用 LINQ，简洁地将二维数组[,] 转换为 List

int[,] TwoDimensionalArray = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
int rowCount = TwoDimensionalArray.GetLength(0);
int colCount = TwoDimensionalArray.GetLength(1);

List<List<int>> TwoDimensionalList = Enumerable.Range(0, rowCount)
                    .Select(i => Enumerable.Range(0, colCount)
                    .Select(j => TwoDimensionalArray[i, j])
                    .ToList())
                    .ToList();

http://www.kler.cn/a/527321.html

相关文章：

  • Spring Boot 基础开发：实现 RESTful API 开发
  • 【算法设计与分析】实验4：动态规划—0/1背包问题
  • Baklib赋能企业实现高效数字化内容管理提升竞争力
  • 【基于SprintBoot+Mybatis+Mysql】电脑商城项目之用户注册
  • 第05章 16 Implicit Function应用举例
  • 【蓝桥杯】43697.机器人塔
  • origin如何在已经画好的图上修改数据且不改变原图像的画风和格式
  • 知识库管理如何推动企业数字化转型与创新发展的深层次探索
  • 智联出行公司布局中国市场，引领绿色出行新潮流
  • riscv xv6学习笔记
  • 使用vhd虚拟磁盘安装两个win10系统
  • cmd命令行无法进入D：盘怎么办
  • 论文阅读笔记 —— 英文论文常见缩写及含义
  • 优盘恢复原始容量工具
  • 为AI聊天工具添加一个知识系统 之73 详细设计之14 正则表达式 之1
  • deepseek本地部署使用教程
  • three.js+WebGL踩坑经验合集(6.1):负缩放，负定矩阵和行列式的关系（2D版本）
  • 可被electron等调用的Qt截图-录屏工具【源码开放】
  • 根据每月流量和市场份额排名前20 的AI工具列表
  • langgraph实现 handsoff between agents 模式 (1)