如何使用java 8流获取路径长度

Question

我有 List<Vector3D> ，其中 Vector3D 是一个坐标。我想找到列表中Vector3D 元素之间所有距离的总和。我想使用 java 8 流找到它。我尝试使用reduce，但它无法帮助我。

UPD：

类Vector3D 有方法double distance(Vector3D) 女巫找到两个位置之间的距离。例如我有（1,0,0）（2,0,0）（3,0,0）的列表。结果，我想找到这条路径的长度。现在是 3。

如果我们使用的是 java 7 或更低版本，我们必须这样做：

public static double calcPathLength(List<Vector3D> path){
    double length = 0d;
    for (int i=0; i< path.size()-1; i++){
        length += path.get(i).distance(path.get(i+1));
    }
    return length;
}

Answer 1

您正在执行的操作称为Mutable reduction。

Pshemo’s answer 展示了如何通过提供三个必要的功能来实现这种临时操作。但是，当所有三个函数都由专用类实现时，在实现 Collector 的类中实现这些函数可能会很有用，以便于重用：

public class Distance implements Collector<Vector3D, Distance.Helper, Double> {

    public static final Distance COLLECTOR = new Distance();

    static final class Helper {
        private double sum = 0;
        private Vector3D first = null, previous = null;
    }
    public Set<Characteristics> characteristics() {
        return Collections.emptySet();
    }
    public Supplier<Helper> supplier() {
        return Helper::new;
    }
    public BiConsumer<Helper, Vector3D> accumulator() {
        return (helper,vector3d)-> {
            if (helper.previous != null)
                helper.sum += vector3d.distance(helper.previous);
            else helper.first = vector3d;
            helper.previous = vector3d;
        };
    }
    public BinaryOperator<Helper> combiner() {
        return (h1,h2)-> {
            h2.sum += h1.sum;
            if(h1.previous!=null && h2.first!=null) {
                h2.sum += h1.previous.distance(h2.first);
                h2.first=h1.first;
            }
            return h2;
        };
    }
    public Function<Helper, Double> finisher() {
        return helper -> helper.sum;
    }
}

您将从 ad-hoc 版本中识别出这三个功能。新的是第四个函数finisher，它允许指定如何从可变容器中提取最终结果，因此我们不需要getSum() 调用。

用例简化为：

List<Vector3D> list;
//…
double distance=list.stream().collect(Distance.COLLECTOR);

Answer 2

其中一个选项是创建一些帮助类，该类会记住以前使用的向量并基于它计算它与当前向量之间的差异。这个类可能看起来像

class DistanceHelper {
    private double sum = 0;
    private Vector3D first = null;
    private Vector3D last = null;

    public void add(Vector3D vector3d) {
        if (first == null)
            first = vector3d;
        if (last != null)
            sum += vector3d.distance(last);
        last = vector3d;
    }

    public void combine(DistanceHelper otherHelper) {
        //add distance of path from current thread with distance of path
        //from other thread
        sum += otherHelper.sum;
        //also add distance between paths handled by separate threads like
        // when path of Thread1 is A->B and Thread2 is C->D then we need to 
        // include path from `B` to `C`
        if (this.last!=null && otherHelper.first!=null)
            sum += this.last.distance(otherHelper.first);
        this.last = otherHelper.last;
    }

    public double getSum() {
        return sum;
    }
}

例如，您可以将它与combine 一起使用，而不是reduce 之类的

double sum = list
        .stream()//or parallelStream()
        .collect(DistanceHelper::new, DistanceHelper::add,
                DistanceHelper::combine).getSum();