C# 转换包含列表的列表<；双倍>；到单个展平阵列

要将列表转换为数组[，]，请执行以下代码：

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

代码更改为

double[] arr = new double[list.Count * list[0].Length];
for (int i = 0; i < list.Count  ; i++)
{
    for (int j = 0; j < list[0].Length; j++)
    {
           arr[i] = list[i * list[0].Length +  j];
    }

}

double[]arr=new double[list.Count*list[0].Length]；
for（int i=0；i

但是将

列表

转换为扁平数组的代码是什么？ 是否可以像上面的代码那样在两个循环中完成

---

列表

表示一个

双[，]arr

老实说，我不是100%确定你在问什么，但是要将

列表

展平，你可以使用Linq中的

SelectMany

，下面是一个简单的例子：

    static void Main(string[] args)
    {
        var first = new List<double> {1, 2, 3};
        var second = new List<double> { 3, 4, 5 };

        var lists = new List<List<double>> {first, second};

        var flatten = lists.SelectMany(a => a).ToArray();

        foreach (var i in flatten)
        {
            Console.WriteLine(i);
        }
    }

static void Main（字符串[]args）
{
var first=新列表{1,2,3}；
var second=新列表{3,4,5}；
var lists=新列表{first，second}；
var flant=lists.SelectMany（a=>a.ToArray（）；
foreach（展平中的var i）
{
控制台写入线（i）；
}
}

老实说，我不是100%确定你在问什么，但要将

列表展平

你可以使用Linq中的

SelectMany

，下面是一个简单的例子：

    static void Main(string[] args)
    {
        var first = new List<double> {1, 2, 3};
        var second = new List<double> { 3, 4, 5 };

        var lists = new List<List<double>> {first, second};

        var flatten = lists.SelectMany(a => a).ToArray();

        foreach (var i in flatten)
        {
            Console.WriteLine(i);
        }
    }

static void Main（字符串[]args）
{
var first=新列表{1,2,3}；
var second=新列表{3,4,5}；
var lists=新列表{first，second}；
var flant=lists.SelectMany（a=>a.ToArray（）；
foreach（展平中的var i）
{
控制台写入线（i）；
}
}

鉴于您的列表是一个嵌套的可枚举列表，您只需使用Linq即可

double[] array = nestedList.SelectMany(a => a).ToArray();

---

鉴于您的列表是一个嵌套的可枚举列表，您可以简单地使用Linq

double[] array = nestedList.SelectMany(a => a).ToArray();

在循环中（即没有LINQ）将类似于

public static void Main()
{
    List<List<double>> listOfLists = new List<List<double>>();

    listOfLists.Add(new List<double>() { 1, 2, 3 });
    listOfLists.Add(new List<double>() { 4, 6 });

    int flatLength = 0;
    foreach (List<double> list in listOfLists)
        flatLength += list.Count;

    double[] flattened = new double[flatLength];

    int iFlat = 0;

    foreach (List<double> list in listOfLists)
        foreach (double d in list)
            flattened[iFlat++] = d;

    foreach (double d in flattened)
        Console.Write("{0} ", d);

    Console.ReadLine();
}

publicstaticvoidmain（）
{
List listOfLists=新列表（）；
Add（newlist（）{1,2,3}）；
Add（newlist（）{4,6}）；
int flatLength=0；
foreach（列表中的列表）
flatLength+=list.Count；
double[]展平=新的double[flatLength]；
int iFlat=0；
foreach（列表中的列表）
foreach（列表中的双d）
平坦的[iFlat++]=d；
foreach（双d扁平）
Console.Write（“{0}”，d）；
Console.ReadLine（）；
}

在循环中（即没有LINQ）类似于

public static void Main()
{
    List<List<double>> listOfLists = new List<List<double>>();

    listOfLists.Add(new List<double>() { 1, 2, 3 });
    listOfLists.Add(new List<double>() { 4, 6 });

    int flatLength = 0;
    foreach (List<double> list in listOfLists)
        flatLength += list.Count;

    double[] flattened = new double[flatLength];

    int iFlat = 0;

    foreach (List<double> list in listOfLists)
        foreach (double d in list)
            flattened[iFlat++] = d;

    foreach (double d in flattened)
        Console.Write("{0} ", d);

    Console.ReadLine();
}

publicstaticvoidmain（）
{
List listOfLists=新列表（）；
Add（newlist（）{1,2,3}）；
Add（newlist（）{4,6}）；
int flatLength=0；
foreach（列表中的列表）
flatLength+=list.Count；
double[]展平=新的double[flatLength]；
int iFlat=0；
foreach（列表中的列表）
foreach（列表中的双d）
平坦的[iFlat++]=d；
foreach（双d扁平）
Console.Write（“{0}”，d）；
Console.ReadLine（）；
}

不应

arr[i]=list[i*list[0]。长度+j]be
arr[i*list[0]。长度+j]=list[i][j]？如果要将列表列表转换为多维数组，这不是“展平”。展平列表将导致一维数组。不应
arr[i]=list[i*list[0]。Length+j]be
arr[i*list[0]。长度+j]=list[i][j]？如果要将列表列表转换为多维数组，这不是“展平”。将列表列表展平将产生一个一维数组。该查询如何处于for循环中？该查询如何处于for循环中？