在OOP中，推荐保持对象不变，因为不变对象本质上是线程安全的，更容易调试（你可以共享对象引用而不用担心意外的或未授权的改变），等等。
在你的例子中，我将创建一个函数splitTrade，它将接受任何amount的交易，并返回一个交易列表，其中每个amount小于maxAmount。
下面是一些伪java代码：

private List<Trade> splitTrade(Trade trade, List<Trade> acc) {
  if (trade.getAmount() > Trade.MAX_AMOUNT) {
    Trade trade1 = new Trade(Trade.MAX_AMOUNT, trade.getDescription(), trade.getDate());
    Trade trade2 = new Trade(trade.getAmount() - Trade.MAX_AMOUNT, trade.getDescription(), trade.getDate());
    acc.add(trade1);
    return splitTrade(trade2, acc);
  } else {
    acc.add(trade);
    return acc;
  }
}

public List<Trade> splitAllTrades(List<Trade> listToSend) {
  return listToSend.stream().flatMap((t) -> splitTrade(t, new ArrayList<Trade>()).stream().toList();
}

不使用lambda语法：

public List<Trade> splitAllTrades(List<Trade> listToSend) {
  List<Trade> validTrades = new ArrayList<>();
  for (Trade trade: listToSend) {    
    validTrades.addAll(splitTrade(trade, new ArrayList<Trade>()));
  }
  return validTrades;
}

一个可能的解决方案是在Trade中使用一个方法，生成满足以下条件的交易流：

public class Trade {
    ...
    public Stream<Trade> streamLegalTrades() {
        if (amount < maxAmount)
            return Stream.of(this);

        Trade halfTrade = new Trade(amount / 2, ...);
        return Stream.of(halfTrade, halfTrade)
            .flatMap(Trade::streamLegalTrades);
    }
}

如果你不熟悉交易流，那么这个语句可能会有点混乱，但它本质上产生了2个新的交易，然后为每个交易产生了一个法律的的交易流。
这就使得转换你的交易列表变得很简单：

tradeList.stream().flatMap(Trade::streamLegalTrades).toList();