Java 如何转换列表<；列表>；？

我有一个下面的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]

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

---

谢谢。

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

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

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

---

实现2 For循环并将元素放入新矩阵。

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

您有固定数量的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 );
}

ArrayList tempList=new ArrayList（）；
ArrayList outputList=新的ArrayList（）；
对于（index=0；index类似的东西

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))
   );
}

List List=newarraylist（firstList.size（））；
对于（int i=0；i
背后的数学：你需要计算矩阵。如果你使用二维数组或“列表列表”会更容易，这与集合几乎相同。数组列表也可以工作，但会稍微让人困惑

显示了换位的一些算法。
 < P>如果是数据传输任务，如果大小不是太大，你可以考虑你的友好电子表格。

对于矩阵操作的东西，有一个jScience库，它支持矩阵。对于仅仅转置一个metrix来说，这可能有些过分，但这取决于需要使用它做什么。
这称为转置。以下代码片段满足您的需要：

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;
    }
}

import java.util.*；
公共类列表转置{
公共静态void main（字符串[]args）{
对象[][]数据={
{“标题”、“数据1”、“数据2”、“数据3”}，
{“A”，2，3，4}，
{“B”，3，5，7}，
};
列表表=新的ArrayList（）；
对于（对象[]行：数据）{
table.add（Arrays.asList（row））；
}
System.out.println（表）；//[[标题，数据1，数据2，数据3]，
//[A，2，3，4]，
//[B、3、5、7]]
表=转置（表）；
System.out.println（表）；//[[Title，A，B]，
//[数据1,2,3],，
//[数据2,3,5],，
//[数据3、4、7]]
}
静态列表转置（列表表）{
List ret=new ArrayList（）；
final int N=table.get（0.size（）；
对于（int i=0；i

另见


这种技术称为转置。一个实现示例

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;
}

公共静态MyObject[][]转置（MyObject[][]m）{
int r=m.长度；
int c=m[r]。长度；
MyObject[][]t=新的MyObject[c][r]；
对于（int i=0；i
因为
get（index）
可能会极大地损害您的性能，即对于大型链表，我建议使用@polygene解决方案，但使用迭代器方法

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;
    }

公共静态列表转置（列表表）{
List ret=new ArrayList（）；
final int N=table.stream（）.mapToInt（l->l.size（））.max（）.orElse（-1）；
迭代器[]iters=新迭代器[table.size（）]；
int i=0；
用于（列表列：表格）{
iters[i++]=列迭代器（）；
}
对于（i=0；i
这是我的解决方案。感谢@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());
}

公共静态列表转置（列表）{
final int N=list.stream（）.mapToInt（l->l.size（））.max（）.orElse（-1）；
List iterList=List.stream（）.map（it->it.iterator（））.collect（Collectors.toList（））；
返回IntStream.range（0，N）
.mapToObj（n->iterList.stream（）
.filter（it->it.hasNext（））
.map（m->m.next（））
.collect（收集器.toList（））
.collect（Collectors.toList（））；
}
不是一种快速的方法，也不是最干净的方法，而是更多的kotlin-ish代码

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
}

fun List.transpose（）：List{
val result=（first（）.index）.map{mutableListOf（）}.toMutableList（）
forEach{list->result.zip（list.forEach{it.first.add（it.second）}
返回结果
}

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

首先遍历所有列表“a”（每个列表大小为m）
将a的第i项附加到结果中的第i个列表中
请问您为什么不创建一个专用对象来存储数据，例如类数据{private String title；private int a；private int b；..}然后将这些对象存储在一个集合中。尝试两个循环-外部循环遍历数组的长度，内部循环遍历列表的长度。@ponzao数据是动态的，这是一个有趣的问题。您是否将这三个列表视为一个矩阵？如果是，它是您所说的换位。当然，还有什么？看起来像列表