Java，Python - 如何將Java FlatMap轉換爲Python LinkedList

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類型的迭代。

要流式傳輸對象意味着您要對流中的每個元素執行操作。

在流上的A map表示您將每個對象（比如說類型爲A）轉換爲某種類型B。 A 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。

不流重塑這種看起來像波紋管：

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