如何从流中获取可观察的浮点数组？

Question

这与one 的问题几乎相同，但方向相反。

我知道 Java 8 中没有 FloatStream，float[] 的用例也不多，但我有一个：

在JavaFX 3D 中处理TriangleMesh，您必须为整个网格顶点的3D 坐标提供ObservableFloatArray。

作为一些计算的结果，我会将所有这些坐标都放在List 中，并将它们一次添加到网格中，我将调用triangleMesh.getPoints().addAll()，使用以下方法之一：

• addAll(ObservableFloatArray src)
• addAll(float... 元素)
• addAll(ObservableFloatArray src, int srcIndex, int length)
• addAll(float[] src, int srcIndex, int length)

其中ObservableFloatArray 可以使用FXCollections.observableFloatArray()、FXCollections.observableFloatArray(ObservableFloatArray array) 或FXCollections.observableFloatArray(float... values) 创建。

假设我对每个顶点都有这个 pojo：

private class Vertex {
    private final float x;
    private final float y;
    private final float z;

    public Vertex(float x, float y, float z){
        this.x=x; this.y=y; this.z=z;
    }

    public float[] getCoordenates(){
        return new float[]{x,y,z};
    }
}

在执行一些计算后，我得到了List<Vertex> listVertices。我需要生成float[] arrayVertices 才能最终调用triangleMesh.getPoints().addAll(arrayVertices);。

现在这就是我正在做的事情：

listVertices.forEach(vertex->triangleMesh.getPoints().addAll(vertex.getCoordenates()));

但这会在添加到可观察数组的每个新顶点上触发关联的侦听器，并且对于大量顶点，这会影响性能。

如果FloatStream 和flatMapToFloat() 存在，我会这样做：

float[] arrayVertices = listVertices.stream()
            .map(vertex->FloatStream.of(vertex.getCoordenates()))
            .flatMapToFloat(f->f).toArray();
triangleMesh.getPoints().addAll(arrayVertices);

就像我实际上对面部索引的 int[] 列表所做的那样：

int[] arrayFaces = listFaces.stream()
            .map(face->IntStream.of(face.getFaceIndices()))
            .flatMapToInt(i->i).toArray();
triangleMesh.getFaces().addAll(arrayFaces);

但据我所知，没有办法使用流。

提前感谢任何涉及流的可能解决方案。

Answer 1

请记住，Stream 定义的是操作而不是存储。因此，对于大多数操作，在使用 CPU 寄存器时，使用 float 仅比 double 值提供一点好处。对于可以使用 SSE 或 GPU 加速的操作，理论上可能会有改进，但这与这里无关。

因此您可以使用DoubleStream 进行该操作，您唯一需要的是能够将DoubleStream 收集到float[] 数组中的收集器：

float[] arrayVertices = listVertices.stream()
    .flatMapToDouble(vertex->DoubleStream.of(vertex.x, vertex.y, vertex.z))
    .collect(FaCollector::new, FaCollector::add, FaCollector::join)
    .toArray();

static class FaCollector {
    float[] curr=new float[64];
    int size;
    void add(double d) {
        if(curr.length==size) curr=Arrays.copyOf(curr, size*2);
        curr[size++]=(float)d;
    }
    void join(FaCollector other) {
        if(size+other.size > curr.length)
            curr=Arrays.copyOf(curr, size+other.size);
        System.arraycopy(other.curr, 0, curr, size, other.size);
        size+=other.size;
    }
    float[] toArray() {
        if(size!=curr.length) curr=Arrays.copyOf(curr, size);
        return curr;
    }
}

这支持并行处理，但是，对于仅包含数据复制的操作，并行处理没有任何好处。

Answer 2

我认为没有任何办法可以解决您必须创建一个数据结构（例如 double[] 或 List<Float>）然后将其映射到 float[] 的事实。 （但也许我错过了一些东西。）

如果您想使用类似Stream 的 API 执行此操作，您可以使用Collector 在最后进行映射：

import java.util.List;
import java.util.ListIterator;
import java.util.Random;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import javafx.scene.shape.TriangleMesh;

public class StreamFloatsTest {

    public static void main(String[] args) {

        // The following declaration works in Eclipse 4.4
        // however it won't compile from the command line:
        // Collector<Float, List<Float>, float[]> toFloatArray =

        // This declaration works:

        Collector<Float, ?, float[]> toFloatArray =
                Collectors.collectingAndThen(Collectors.toList(), floatList -> {
                    float[] array = new float[floatList.size()];
                    for (ListIterator<Float> iterator = floatList.listIterator(); iterator.hasNext();) {
                        array[iterator.nextIndex()] = iterator.next();
                    }
                    return array ;
                });


        // Random vertex list for demo purposes:
        Random rng = new Random();
        List<Vertex> vertices = IntStream.range(0, 100)
                .mapToObj(i -> new Vertex(rng.nextFloat(), rng.nextFloat(), rng.nextFloat()))
                .collect(Collectors.toList());

        float[] vertexArray = vertices.stream()
                .flatMap(v -> Stream.of(v.getX(), v.getY(), v.getZ()))
                .collect(toFloatArray);


        TriangleMesh mesh = new TriangleMesh();

        mesh.getPoints().addListener(obs -> System.out.println("mesh invalidated"));
        mesh.getPoints().addListener((array, sizeChanged, from, to) -> System.out.println("mesh changed"));
        mesh.getPoints().addAll(vertexArray);

    }

    public static class Vertex {
        private final float x ;
        private final float y ;
        private final float z ;
        public Vertex(float x, float y, float z) {
            this.x = x ;
            this.y = y ;
            this.z = z ;
        }
        public float getX() {
            return x;
        }
        public float getY() {
            return y;
        }
        public float getZ() {
            return z;
        }
        public float[] getCoordinates() {
            return new float[] {x, y, z};
        }
    }
}