Question

我正在通过线性规划制定运输问题。主要是我在网上搜索了一下code which is written in Java。但是，我必须用Python编写完整的东西。我正在将其转换为Python。我并不认为自己擅长Java，而不是Python。我试着转换一下。一切都很好，但我不知道如何转换下面的代码片段，它处理Java的LinkedLists和Stream函数。

static LinkedList<Shipment> matrixToList() {
    return stream(matrix)
            .flatMap(row -> stream(row))
            .filter(s -> s != null)
            .collect(toCollection(LinkedList::new));
}

如果您有兴趣研究如何转换上面链接的Java代码，可以看到下面的Shipment类是我的（不完整的）Python代码：

import sys

class TransportationProblem:

    demand = list()
    supply = list()
    costs = list(list())
    matrix = list(list())

    def __init__(self):
        pass

    class Shipment:
        costPerUnit = 0.0
        quantity = 0.0
        r = 0
        c = 0

        def __init__(self, quantity, costPerUnit, r, c):
            self.quantity = quantity
            self.costPerUnit = costPerUnit
            self.r = r
            self.c = c

    def init(self, f_name= ""):
        try:
            with open(f_name) as f:
                val = [int(x) for x in f.readline().strip().split(' ')]
                numSources, numDestinations = val[0], val[1]
                src = list()
                dst = list()

                val = [int(x) for x in f.readline().strip().split(' ')]
                for i in range(0,numSources):
                    src.append(val[i])

                val = [int(x) for x in f.readline().strip().split(' ')]
                for i in range(0, numDestinations):
                    dst.append(val[i])

                totalSrc = sum(src)
                totalDst = sum(dst)

                if totalSrc > totalDst:
                    dst.append(totalSrc - totalDst)
                elif totalDst > totalSrc:
                    src.append(totalDst - totalSrc)

                self.supply = src
                self.demand = dst

                self.costs = [[0 for j in range(len(dst))] for i in range(len(src))]
                self.matrix = [[self.Shipment() for j in range(len(dst))] for i in range(len(src))]

                for i in range(0,len(src)):
                    val = [int(x) for x in f.readline().strip().split(' ')]
                    for j in range(0, len(dst)):
                        self.costs[i][j] = val[j]

                print self.costs
        except IOError:
            print "Error: can\'t find file or read data"

    def northWestCornerRule(self):
        northwest = 0
        for r in range(0, len(self.supply)):
            for c in range(northwest, len(self.demand)):
                quantity = min(self.supply[r], self.demand[c])
                if quantity > 0:
                    self.matrix[r][c] = self.Shipment(quantity=quantity, costPerUnit=self.costs[r][c], r=r, c=c)
                    self.supply[r] = self.supply[r] - quantity
                    self.demand[c] = self.demand[c] - quantity
                    if self.supply[r] == 0:
                        northwest = c
                        break

    def steppingStone(self):
        maxReduction = 0
        move = []
        leaving = self.Shipment()

        self.fixDegenerateCase()
        for r in range(0,len(self.supply)):
            for c in range(0,len(self.demand)):
                if self.matrix[r][c] != None:
                    pass

                trail = self.Shipment(quantity=0, costPerUnit=self.costs[r][c], r=r, c=c)
                path = self.geClosedPath(trail)

                reduction = 0
                lowestQuantity = sys.maxint
                leavingCandidate = None

                plus = True
                for s in path:
                    if plus == True:
                        reduction = reduction + s.costPerUnit
                    else:
                        reduction = reduction - s.costPerUnit
                        if s.quantity < lowestQuantity:
                            leavingCandidate = s
                            lowestQuantity = s.quantity
                    plus = not plus
                if reduction < maxReduction:
                    move = path
                    leaving = leavingCandidate
                    maxReduction = reduction

        if move != None:
            q = leaving.quantity
            plus = True
            for s in move:
                s.quantity = s.quantity + q if plus else s.quantity - q
                self.matrix[s.r][s.c] = None if s.quantity == 0 else s
                plus = not plus
            self.steppingStone()

    def fixDegenerateCase(self):
        pass

    def getClosedPath(self):
        pass

    def matrixToList(self):
        pass

Answer 1

我们可以将其分解为步骤。您从matrix变量开始，该变量是包含Shipment类型的迭代的可迭代变量。

流式传输对象意味着您对流的每个元素执行操作。

流上的map表示您接受每个对象，比如类型A，并将其转换为某种类型B。 flatMap是map生成Stream<B>时使用的特例。 flatMap允许您将这些流连接到单个流中。

假设每个A映射到3个对象{A1, A2} -> {{B11, B12, B13}, {B21, B22, B23}}

的流

flatMap会生成一个流{A1, A2} -> {B11, B12, B13, B21, B22, B23}

在这种情况下，matrix会生成row个对象的流。每个row都映射到Shipment的流中，flatMap用于连接它们。

最后filter用于删除空货件（即值为空），并调用collect方法将Shipment流转换为List。< / p>

在没有流的情况下重新创建它可能看起来像下面：

static LinkedList<Shipment> matrixToList() {
    LinkedList<Shipment> result = new LinkedList<>();
    for (List<Shipment> row : matrix) {
        for (Shipment shipment : row) {
            if (shipment != null) {
                result.add(shipment );
            }
        }
    }
    return result;
}

Java，Python - 如何将Java FlatMap转换为Python LinkedList

1 个答案: