在Java中按属性映射对象集合

我有这样一个自定义类：

public class Client {
    public int ID;
    public String Name;
    public double buys;
    public double getBuys() {
        return this.buys;
    }
}

mapClients(clients, d -> d + 1); // every buys are added 1
mapClients(clients, d -> 2*d); // every buys are multiplied by 2

private static List<Client> mapClients(List<Client> clients, DoubleUnaryOperator op) {
    return clients.stream()
                  .map(c -> new Client(op.applyAsDouble(c.getBuys())))
                  .collect(Collectors.toList());
}

然后，我定义了一个客户端列表，如：

List<Client> clientList;

List客户端列表；

假设该列表中有很多已经初始化的客户机对象。如何使用Java8映射每个客户机对象的字段“buys”

我试过这样的方法：

List<Client> clientList2 = clientList.stream().map(c.getBuys() -> c.getBuys() + 1).collect(Collections.toList());

List clientList2=clientList.stream（）.map（c.getBuys（）->c.getBuys（）+1.collect（Collections.toList（））；

---

当然，它不起作用，但我想不出（或找不到）任何方法来做。我想做的只是修改列表中每个对象的每个“购买”值。在本例中，我添加了一个，但它可以是任何操作

我只会对循环使用一个

for (Client client : clientList)
    client.setBuys(client.getBuys() + 1);

您是否尝试过使用Java提供的迭代器

for( Client c: clientList){ 
System.out.println(c.getBuys());
}

或者将结果添加到地图或其他任何地方。
阅读您的评论后，您需要的是通过应用自定义函数修改每个客户的购买。考虑以下方法：

private static List<Client> mapClients(List<Client> clients, DoubleUnaryOperator op) {
    return clients.stream()
                  .peek(c -> c.setBuys(op.applyAsDouble(c.getBuys())))
                  .collect(Collectors.toList());
}

此方法将对每个客户端进行变异，并使用操作符的结果设置购买（a是一个操作符，它将
double
作为参数，并返回类型为
double
的值）。操作员将购买作为输入进行计算。然后，你可以这样使用它：

public class Client {
    public int ID;
    public String Name;
    public double buys;
    public double getBuys() {
        return this.buys;
    }
}

mapClients(clients, d -> d + 1); // every buys are added 1
mapClients(clients, d -> 2*d); // every buys are multiplied by 2

private static List<Client> mapClients(List<Client> clients, DoubleUnaryOperator op) {
    return clients.stream()
                  .map(c -> new Client(op.applyAsDouble(c.getBuys())))
                  .collect(Collectors.toList());
}

请注意，此解决方案将对现有对象进行变异，这不是一个好的做法。最好让客户端的构造函数将购买作为输入，并将操作结果映射到新客户端，如下所示：

public class Client {
    public int ID;
    public String Name;
    public double buys;
    public double getBuys() {
        return this.buys;
    }
}

mapClients(clients, d -> d + 1); // every buys are added 1
mapClients(clients, d -> 2*d); // every buys are multiplied by 2

private static List<Client> mapClients(List<Client> clients, DoubleUnaryOperator op) {
    return clients.stream()
                  .map(c -> new Client(op.applyAsDouble(c.getBuys())))
                  .collect(Collectors.toList());
}

私有静态列表映射客户端（列表客户端，双一元运算符op）{
返回clients.stream（）
.map（c->newclient（op.applyasdoull（c.getBuys（）））
.collect（Collectors.toList（））；
}
是否要将1添加到每个客户的购买中？尚不清楚您试图对
购买
字段执行什么操作。输出应该是什么样子？这里的“map”到底是什么意思？似乎您希望获得一个包含现有列表的客户机列表。但是你希望新的名单是什么呢？很抱歉，那些没被清理的家伙。谢谢你的评论。我想做的就是修改列表中每个对象的每个值。在本例中，添加一个，但可以是任何操作。创建一个新列表非常容易，其中客户机是具有递增
字段的新对象。或者，如果您想改变现有的客户机对象，您可以使用
forEach
而不是
map
。如果列表中有大量客户机，它是否足够有效？您可以这样使用并行性：
clientList.parallelStream（）.forEach（c->{c.setBuys（c.getBuys（）+1）；}）。同样的问题，如果列表中有大量客户端，它是否足够高效？我认为此功能在较低级别上进行了优化，但我不知道它是否可以更好地用于特定集合（LinkedList、Maps、ecc）。但我认为使用foreach语句总是好的。