浮点数组列表到Java中的浮点数组的列表答案

【问题标题】：List of List of array of floats to an array of floats in Java浮点数组列表到Java中的浮点数组的列表
【发布时间】：2016-03-14 19:26:05
【问题描述】：

我正在寻找一种优雅的方式来通过展平将 List<List<float[]>> 转换为 float[]。我以为这会是一件轻而易举的事，但显然我错了。我无法使用 Java 8 或外部库来解决问题。我也不知道内部列表和数组的大小，它们的大小不一定相同。

这就是我所拥有的，我认为对于这么简单的任务来说太复杂了：

private float[] toFloatBuffer(List<List<float[]>> buffers) {
    //First: creating a new list to store the Float values
    List<Float> mergedList = new ArrayList<>();
    //Adding the float values to the mergedList
    for(List<float[]> secondBuffer : buffers) {
        for(float[] b : secondBuffer) {
            for(float f : b) {
                mergedList.add(f);
            }
        }
    }
    //Creating the final buffer with the size of mergedList
    float[] merged = new float[mergedList.size()];
    //This doesn't work for some odd reason...
    //float[] merged = mergedList.toArray(); 
    int i = 0;
    //Adding the values of mergedList to merged
    for(float f : mergedList) {
        merged[i++] = f;
    }
    return merged;
}

编辑：出于某些充分的原因，我忘了说外部列表是 LinkedList。也许知道这一点很重要。

【问题讨论】：

有点复杂，效率不高。但是，您不能大大降低复杂性，嵌套的for 循环必须存在。你已经明白了。
可惜了，我觉得这是我今年写的最丑的代码了……

标签： java arrays collections buffer

【解决方案1】：

这就是我的做法，虽然我不确定它是否更漂亮，但它应该更有效，尤其是因为它不会创建任何 Float 对象。

public static float[] flatten(List<List<float[]>> lists) {
    // get the total size.
    int size = 0;
    for (List<float[]> list : lists) 
        for (float[] floats : list) 
            size += floats.length;
    // create an array of the right size.
    float[] ret = new float[size];
    int i = 0;
    for (List<float[]> list : lists)
        for (float[] floats : list) {
            // bulk copy the array
            System.arraycopy(floats, 0, ret, i, floats.length);
            i += floats.length;
        }
    return ret;
}

这会创建一些迭代器，但是逃逸分析可能会将它们放在堆栈上以避免垃圾。

以下只创建一个对象

public static float[] flatten(List<List<float[]>> lists) {
    int size = 0;
    for (int i = 0; i < lists.size(); i++) {
        List<float[]> list = lists.get(i);
        for (int j = 0; j < list.size(); j++) {
            float[] floats = list.get(j);
            size += floats.length;
        }
    }
    float[] ret = new float[size];
    int pos = 0;
    for (int i = 0; i < lists.size(); i++) {
        List<float[]> list = lists.get(i);
        for (int j = 0; j < list.size(); j++) {
            float[] floats = list.get(j);
            System.arraycopy(floats, 0, ret, pos, floats.length);
            pos += floats.length;
        }
    }
    return ret;
}

如果您创建 List<Float>，则每个元素至少创建一个对象。

【讨论】：

彼得的第二个例子就是我所想的。有时丑陋的代码是正确的代码。
谢谢，这看起来已经比我的实现更好了。老实说，我在 Escape 分析部分失去了你。你能简单解释一下为什么第二个例子比第一个更好吗？
请注意，OP 后来补充说“出于某些充分的原因，外部列表是 LinkedList”，因此在其上使用索引访问可能是不明智的。我怀疑 LinkedList 的原因是好的，但这是一个不同的讨论。 :-)
@WardVa 当你迭代一个集合时，这会创建一个 Iterator 对象，除非逃逸分析可以确定该对象没有逃逸方法并且可以放在堆栈上。

【解决方案2】：

请查看这个优雅的递归示例，您可以根据自己的需要进行调整：

https://gist.github.com/l-ray/11472207

与任何递归算法一样，如果您的列表很大，您应该添加一些检查以避免溢出。

【讨论】：