如何使用Java过滤器lambda对Arraylist元素进行分组

Question

我试图按Java数组列表元素分组。

我有一个JSONObjects数组，如下所示，我想按字段price和side分组，然后将股票与新字段buyShares和sellShares相加

    [{"shares":20,"side":"B","orderId":"001","price":"500"}, 
    {"shares":20,"side":"S","orderId":"002","price":"501"}, 
    {"shares":25,"side":"B","orderId":"003","price":"500"}, 
    {"shares":10,"side":"S","orderId":"004","price":"501"}, 
    {"shares":30,"side":"B","orderId":"005","price":"505"}, 
    {"shares":35,"side":"B","orderId":"006","price":"505"}, 
    {"shares":35,"side":"S","orderId":"007","price":"500"}]

我想按价格和侧边分组，得到如下所示:

[{"price":"500","buyShares":45, "sellShares":35}, {"sellShares":30,"price":"501"}, {"price":"505","buyShares":65}]

我使用以下Java代码:

ArrayList<JSONObject> aOrdersArray = new ArrayList<>(aOrders.values());
System.out.println(aOrdersArray);
List<JSONObject> test = aOrdersArray.stream()
        .distinct()
        .collect(Collectors.groupingBy(jsonObject -> jsonObject.getInt("price")))
        .entrySet().stream()
        .map(e -> e.getValue().stream()
        .reduce((f1,f2) -> {
            JSONObject h = new JSONObject();
            h.put("price",f1.get("price"));
            System.out.println(f1);
            if (f1.get("side").equals("B") && f2.get("side").equals("B")) {
                h.put("buyShares", f1.getInt("shares") + f2.getInt("shares"));
            }
            else if (f1.get("side").equals("S") && f2.get("side").equals("S")) {
                h.put("sellShares", f1.getInt("shares") + f2.getInt("shares"));
            }
            else if (f1.get("side").equals("S")) {
                h.put("sellShares", f1.get("shares"));
            }
            else if (f1.get("side").equals("B")) {
                h.put("buyShares",f1.get("shares"));
            }
            else if (f2.get("side").equals("S")) {
                h.put("sellShares", f2.get("shares"));
            }
            else if (f2.get("side").equals("B")) {
                h.put("buyShares",f2.get("shares"));
            }
            return h;
        }))
        .map(f -> f.get())
        .collect(Collectors.toList());
System.out.println(test);

有时会出现以下错误

Exception in thread "main" org.json.JSONException: JSONObject["side"] not found.

Answer 1

要使用gson，可以创建一个类:

public class Share{
    private int shares;
    private String side;
    private String orderId;
    private String price;
    
    //getters and setters
    public int getShares() {
        return shares;
    }

    public void setShares(int shares) {
        this.shares = shares;
    }

    public String getSide() {
        return side;
    }

    public void setSide(String side) {
        this.side = side;
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }
}

然后您可以使用这个从JSON映射object:

 String yourJson = "[{\"shares\":20,\"side\":\"B\",\"orderId\":\"001\",\"price\":\"500\"},{\"shares\":35,\"side\":\"S\",\"orderId\":\"007\",\"price\":\"500\"}]";
 Gson gson = new Gson();
 Type shareListType = new TypeToken<ArrayList<Share>>(){}.getType();
 ArrayList<Share> userArray = gson.fromJson(yourJson, shareListType);  

Answer 2

你试图做的事情是复杂和容易出错的，因为你的开始是错误的。

您首先就不应该有 。JSON输入中的数据是常规的，您希望对其内容进行操作。

正确的开始方法是创建一个表示这样一条记录的Java对象，然后将JSON输入转换为正确的，惯用的Java版本。你想要:

@Value class Record {
  int shares;
  RecordKind kind;
  int orderId;
  int price;

  public PriceGroup toGroup() {
    return new PriceGroup(price,
      kind == BUY ? shares : 0,
      kind == SELL ? shares : 0);
  }
}

@Value class PriceGroup {
  int price;
  int buyShares;
  int sellShares;

  public PriceGroup merge(PriceGroup other) {
    if (other.price != this.price) throw new IllegalArgumentException();
    return new PriceGroup(price,
      this.buyShares + other.buyShares,
      this.sellShares + other.sellShares);
  }
}

注意:使用Lombok's的 。假设这个东西有一个构造函数，所有字段都是final，toString和equals以及hashCode都在正确的位置，等等。

一旦您拥有了上述两种类型，那么您就可以将您的输入JSON转换为一个 list<record> ode=""> 。有了这个 /code>之后，您才应该开始映射，分组等。

当然，该错误将永远不会发生，并且您的MAP/GROUP代码将更容易阅读。您所做的任何错别字都将导致编译时错误。自动完成将工作良好，等等:所有的优点。

要将JSON转换为给定类型，请使用jackson。如果您不想添加该依赖项（确实应该添加），那么在Record类中编写一个 方法，并使用 立即获取记录对象流，而不要返回到JSONObject。

List<Record> orders = ...;
List<PriceGroup> test = orders.stream()
        .distinct()
        .map(Record::toGroup)
        .collect(Collectors.groupingBy(PriceGroup::getPrice))
        .entrySet().stream()
        .map(e -> e.getValue().stream()
        .reduce((f1, f2) -> f1.merge(f2))
        .collect(Collectors.toList());

您的代码现在非常容易阅读，所有方法都有正确的名称（它是 ，而不是 )，并且可以通过自动完成等方式发现，例如，您可以单独测试 功能。