如何转置List？

Question

我有一个以下 ArrayList，

[Title,Data1,Data2,Data3]
[A,2,3,4]
[B,3,5,7]

我想像这样转换这个，

[Title,A,B]
[Data1,2,3]
[Data2,3,5]
[Data3,4,7]

我对这种方法有点困惑。任何提示将不胜感激。

谢谢。

Answer 1

这称为转置。以下代码段满足您的需要：

import java.util.*;
public class ListTranspose {
    public static void main(String[] args) {
        Object[][] data = {
            { "Title", "Data1", "Data2", "Data3" },
            { "A", 2, 3, 4 },
            { "B", 3, 5, 7 },
        };
        List<List<Object>> table = new ArrayList<List<Object>>();
        for (Object[] row : data) {
            table.add(Arrays.asList(row));
        }
        System.out.println(table); //  [[Title, Data1, Data2, Data3],
                                   //   [A, 2, 3, 4],
                                   //   [B, 3, 5, 7]]"
        table = transpose(table);
        System.out.println(table); //  [[Title, A, B],
                                   //   [Data1, 2, 3],
                                   //   [Data2, 3, 5],
                                   //   [Data3, 4, 7]]
    }
    static <T> List<List<T>> transpose(List<List<T>> table) {
        List<List<T>> ret = new ArrayList<List<T>>();
        final int N = table.get(0).size();
        for (int i = 0; i < N; i++) {
            List<T> col = new ArrayList<T>();
            for (List<T> row : table) {
                col.add(row.get(i));
            }
            ret.add(col);
        }
        return ret;
    }
}

另请参阅

• Wikipedia/Transpose

Answer 2

这是我的解决方案。感谢@jpaugh 的代码。希望这对您有帮助。^_^

public static <T> List<List<T>> transpose(List<List<T>> list) {
   final int N = list.stream().mapToInt(l -> l.size()).max().orElse(-1);
   List<Iterator<T>> iterList = list.stream().map(it->it.iterator()).collect(Collectors.toList());
   return IntStream.range(0, N)
       .mapToObj(n -> iterList.stream()
       .filter(it -> it.hasNext())
       .map(m -> m.next())
       .collect(Collectors.toList()))
   .collect(Collectors.toList());
}

Answer 3

这不是一种快速的方法，也不是最干净的方法，而是更多 kotlin 风格的代码。

fun <T> List<List<T>>.transpose(): List<List<T>> {
    val result = (first().indices).map { mutableListOf<T>() }.toMutableList()
    forEach { list -> result.zip(list).forEach { it.first.add(it.second) } }
    return result
}

第一行创建一个 M 大小的“结果”列表（对于 NxM 原始矩阵），而第二行 =>

1. 迭代第一个（每个列表大小为 m）中的所有列表“a”，
2. 将 a 的第 i 个项目附加到结果中的第 i 个列表。

Answer 4

这称为转置操作。代码示例位于此处，但需要进行重大修改因为你有一个数组的 ArrayList （我从你的问题中推断出）

Answer 5

也许是这样的

List<List<String>> list = new ArrayList<List<String>>(firstList.size());
for(int i = 0; i < firstList.size(); i++) {
   list.add(Arrays.asList(
      firstList.get(i),
      secondList.get(i),
      thirdList.get(i))
   );
}

Answer 6

背后的数学原理：您需要转置矩阵。如果使用二维数组或“列表列表”会更容易，这与集合几乎相同。数组列表也可以工作，但它有点令人困惑。

这篇维基百科文章展示了一些转置算法。

Answer 7

该技术称为转置。实施示例。

public static MyObject [][] transpose(MyObject [][] m){
    int r = m.length;
    int c = m[r].length;
    MyObject [][] t = new MyObject[c][r];
    for(int i = 0; i < r; ++i){
        for(int j = 0; j < c; ++j){
            t[j][i] = m[i][j];
        }
    }
    return t;
}

Answer 8

检查所有列表的大小是否相同。

将信息放入矩阵（例如，包含列表元素的列表）中以获取列表的数量和列表的大小。

使用旋转后的尺寸信息创建一个新的矩阵。 （3x4 到 4x3）

实施 2 个 For 循环并将元素放入新矩阵中。

Answer 9

如果是用于数据迁移任务，如果大小不太大，您可以考虑使用友好的电子表格。

对于矩阵操作，jScience 库具有矩阵支持。对于仅仅转置矩阵来说，这有点过分了，但这取决于需要用它做什么。

Answer 10

您是否有固定数量的 ArrayList，并且它们一开始就有固定的大小？如果它是固定的，你可以做的是有一个 int 索引值并在同一个循环中依次处理每个 ArrayList。然后，您可以将每个值传输到临时 ArrayList，然后将对此的引用放置在最终 ArrayList 中以进行输出。

听起来很混乱？这是一个粗略的解决方案：

ArrayList tempList = new ArrayList();
ArrayList outputList = new ArrayList();

for(index=0;index<list1.getsize();index++){
// Add null checks and other validation here
tempList.add( list1.get(index) );
tempList.add( list2.get(index) );
tempList.add( list3.get(index) );
outputList.add( tempList );
}

Answer 11

由于 get(index) 可能会极大地损害您的性能，即对于大链接列表，我建议使用 @polygenelubricants 解决方案，但使用迭代器方法。

public static <T> List<List<T>> transpose(List<List<T>> table) {
        List<List<T>> ret = new ArrayList<List<T>>();
        final int N = table.stream().mapToInt(l -> l.size()).max().orElse(-1);
        Iterator[] iters = new Iterator[table.size()];

        int i=0;
        for (List<T> col : table) {
            iters[i++] = col.iterator();
        }

        for (i = 0; i < N; i++) {
            List<T> col = new ArrayList<T>(iters.length);
            for (Iterator it : iters) {
                col.add(it.hasNext() ? (T) it.next() : null);
            }
            ret.add(col);
        }
        return ret;
    }

Answer 12

在 Kotlin 中，简单的转置如下所示：

   fun transpose( matrix: List<List<String>> ) {
        return matrix.first().forEachIndexed { 
            i, _ -> matrix.map { it.getOrNull(i) }
        }
   }

图例：

• forEachIndexed 迭代第一行的索引。
• 然后，每个这样的索引都映射到该索引上所有行的项目。 getOrNull 处理较短行中缺失的项目。
• 它由 map() 作为 List 返回。