Java 如果arraylist中的条件满足，如何比较元素并合并？_Java

Java 如果arraylist中的条件满足，如何比较元素并合并？

java

Java 如果arraylist中的条件满足，如何比较元素并合并？,java,Java,我有一个交易列表，每个交易都有一些属性，比如现在的来源，从交易列表中，我想得到所有具有相同来源价值的交易，并将它们组合成一个交易，例如 tradeName quote source quantity price Google GOOG Goldman Sachs 15 610 Microsoft MSFT Barclays

我有一个交易列表，每个交易都有一些属性，比如现在的来源，从交易列表中，我想得到所有具有相同来源价值的交易，并将它们组合成一个交易，例如

tradeName      quote           source            quantity      price 
Google          GOOG           Goldman Sachs        15           610  
Microsoft       MSFT           Barclays             400          28
Google          GOOG           Goldman Sachs        45           610  
Google          GOOG           Goldman Sachs        40           610  
Microsoft       MSFT           Barclays             1000          28

现在根据来源信息，我应该合并交易，这样我更新的交易列表将是

tradeName      quote           source            quantity        price 
Google          GOOG           Goldman Sachs        100           610  
Microsoft       MSFT           Barclays             1400           28

我不确定比较部分，如何着手解决它

尝试了以下方法

for (Trade trade : tradeList)
{
   //Not sure how to compare this.trade.source with all sources 
   //of all trades present in the trade.
   //Logic should be if source matches then quantity should be added 
   //but am not sure how comparison would work.  
}

Class Trade
{

private tradeName;
private quote;
private source;
private quantity;
private price;

//Getters and Setters for each of above mentioned attributes. 

}

我想我应该创建一个

HashMap

，使用

tradeName+quote+source

作为键，然后将列表中的每笔交易添加到映射中的相应项目中

例如：

Map<String, Trade> map = new HashMap<String, Trade>();
for (Trade trade : tradeList) {
    String key = trade.tradeName + "#" + trade.quote + "#" + trade.source; // signature, what you merge by 
    if (map.containsKey(key)) {
        map.put(key, trade); // the first trade with such a signature 
    } else {
        // not the first, so merge it with the existing one
        map.get(key).add(trade); // you'll have to implement the Trade.add() method
    }
}
List<Trade> merged = new LinkedList<Trade>(map.values());

Map Map=newhashmap（）；
for（贸易：贸易清单）{
String key=trade.tradeName+“#”+trade.quote+“#”+trade.source；//签名，合并的依据
if（地图容器（图例））{
map.put（key，trade）；//有这样签名的第一笔交易
}否则{
//不是第一个，所以将其与现有的合并
map.get（key.add（trade）；//您必须实现trade.add（）方法
}
}
List merged=新链接列表（map.values（））；

虽然我同意使用Hashmap可能更有效，但我更愿意尝试使用O.p提供的方法。如果我们要迭代每个成员，那么让我们检查到目前为止是否找到了该成员。如果是这样，修改他。如果没有，就加上他。我建议对一份新名单做所有这些，然后对新名单做任何你想做的事情（把旧的改成新的，打印新的，发电子邮件给俄罗斯总统，随便什么）

那么像下面这样的东西怎么样？（我没有编辑这篇文章，所以请原谅任何打字错误）

//创建一个新列表，将“简化”结果存储到
ArrayList newTradeList=新的ArrayList（tradeList.size（））；
//对于旧列表中的每一笔交易，称之为“交易”，然后。。。
for（贸易：贸易清单）{
//首先，我们要问的是，这份清单中是否已经有相同来源的交易？
//indexOf查找元素在数组中的位置。我将结果存储在index中
int index=newTradeList.indexOf（贸易）；
//如果元素还不在我们的列表中，indexOf将返回-1。
//如果结果不是-1，那么我们之前已经看到了与该来源的交易
如果（索引！=-1）{
//在这种情况下，获取该元素。我们知道它所在的索引，所以获取它。
Trade t=newTradeList.get（索引）；
//然后，做任何操作来合并这两种交易。我假设你加上数量。
//因此，我们新列表中的交易数量应该是原来的数量，加上新交易的数量
t、 setQuantity（t.getQuantity（）+trade.getQuantity（））；
} 
//但是如果我们以前从未见过这个来源，那么让我们把它添加到我们的新列表中
否则{
newTradeList.add（贸易）；
}
}

当然，这是在做一些假设。为了使

.indexOf

正常工作，您需要

Trade

类正确定义

equals

方法（检查源代码或源代码和价格是否相同-只要看起来正确）。如果您重新定义

等于

，那么实际上还应该定义

hashCode

。它还假设您有一个方法

.addQuantity

，因为它使代码比get和set的组合更干净

HashMap的优点是几乎即时（O（1））检查元素是否已经存在，并确保其中的元素是唯一的（因为HashMap是一个集合，集合不能有重复的元素）。代码看起来非常相似，只是我们可以利用HashMap的

containsKey

方法，而不是

indexOf

我觉得应该这样做

Trade gsTrades = new Trade();
    Trade barclaysTrades = new Trade();

    for(Trade trade: tradeList){
        if(trade.getSource().equals("GS")){
            gsTrades.setQuantity(gsTrades.getQuantity()+trade.getQuantity());
            gsTrades.setPrice(gsTrades.getPrice()+trade.getPrice());
        }else{
            barclaysTrades.setQuantity(barclaysTrades.getQuantity()+trade.getQuantity());
            barclaysTrades.setPrice(barclaysTrades.getPrice()+trade.getQuantity());
        }
    }
    System.out.println("GS trade details = " + gsTrades.toString());
    System.out.println("Barclays trade details = " + barclaysTrades.toString());

请检查这两种方法：

Java Bean：

public class Trade {

private String tradeName;
private String quote;
private String source;
private Integer quantity;
private Integer price;

public String getTradeName() {
    return tradeName;
}

public void setTradeName(String tradeName) {
    this.tradeName = tradeName;
}

public String getQuote() {
    return quote;
}

public void setQuote(String quote) {
    this.quote = quote;
}

public String getSource() {
    return source;
}

public void setSource(String source) {
    this.source = source;
}

public Integer getQuantity() {
    return quantity;
}

public void setQuantity(Integer quantity) {
    this.quantity = quantity;
}

public Integer getPrice() {
    return price;
}

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

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((source == null) ? 0 : source.hashCode());
    return result;
}

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Trade other = (Trade) obj;
    if (source == null) {
        if (other.source != null)
            return false;
    } else if (!source.equals(other.source))
        return false;
    return true;
}

@Override
public String toString() {
    StringBuilder builder = new StringBuilder();
    builder.append("Trade [tradeName=");
    builder.append(tradeName);
    builder.append(", quote=");
    builder.append(quote);
    builder.append(", source=");
    builder.append(source);
    builder.append(", quantity=");
    builder.append(quantity);
    builder.append(", price=");
    builder.append(price);
    builder.append("]");
    return builder.toString();
}
}

--编辑--

检查一下，很简单：

import java.util.ArrayList;
import java.util.List;

public class TradeTest {

/**
 * @param args
 */
public static void main(String[] args) {
    Trade t1 = new Trade();
    t1.setPrice(610);
    t1.setQuantity(15);
    t1.setQuote("GOOG");
    t1.setSource("Goldman Sachs");
    t1.setTradeName("Google");

    Trade t2 = new Trade();
    t2.setPrice(28);
    t2.setQuantity(400);
    t2.setQuote("MSFT");
    t2.setSource("Barclays");
    t2.setTradeName("Microsoft");

    Trade t3 = new Trade();
    t3.setPrice(610);
    t3.setQuantity(45);
    t3.setQuote("GOOG");
    t3.setSource("Goldman Sachs");
    t3.setTradeName("Google");

    Trade t4 = new Trade();
    t4.setPrice(610);
    t4.setQuantity(40);
    t4.setQuote("GOOG");
    t4.setSource("Goldman Sachs");
    t4.setTradeName("Google");

    Trade t5 = new Trade();
    t5.setPrice(28);
    t5.setQuantity(1000);
    t5.setQuote("MSFT");
    t5.setSource("Barclays");
    t5.setTradeName("Microsoft");

    List<Trade> trades = new ArrayList<Trade>();
    trades.add(t1);
    trades.add(t2);
    trades.add(t3);
    trades.add(t4);
    trades.add(t5);

    List<Trade> googleTrades = new ArrayList<Trade>();
    List<Trade> microsoftTrades = new ArrayList<Trade>();

    Integer googleQuantities = 0;
    Integer microsoftQuantities = 0;

    for (Trade trade : trades) {
        if (trade.getSource().equals("Goldman Sachs")) {
            googleTrades.clear();
            googleQuantities += trade.getQuantity();
            trade.setQuantity(googleQuantities);
            googleTrades.add(trade);
        } else if (trade.getSource().equals("Barclays")) {
            microsoftTrades.clear();
            microsoftQuantities += trade.getQuantity();
            trade.setQuantity(microsoftQuantities);
            microsoftTrades.add(trade);
        }
    }

    System.out.println("Google trades: \n");
    System.out.println(googleTrades);
    System.out.println("\n");
    System.out.println("Microsoft trades: \n");
    System.out.println(microsoftTrades);

}

import java.util.ArrayList；
导入java.util.List；
公共类交易测试{
/**
*@param args
*/
公共静态void main（字符串[]args）{
贸易t1=新贸易（）；
t1.设定价格（610）；
t1.设定量（15）；
t1.setQuote（“GOOG”）；
t1.setSource（“高盛”）；
t1.setTradeName（“谷歌”）；
贸易t2=新贸易（）；
t2.设定价格（28）；
t2.设定量（400）；
t2.设定报价（“MSFT”）；
t2.setSource（“巴克莱”）；
t2.setTradeName（“微软”）；
贸易t3=新贸易（）；
t3.设定价格（610）；
t3.设置数量（45）；
t3.setQuote（“GOOG”）；
t3.setSource（“高盛”）；
t3.setTradeName（“谷歌”）；
贸易t4=新贸易（）；
t4.设定价格（610）；
t4.设定数量（40）；
t4.setQuote（“GOOG”）；
t4.setSource（“高盛”）；
t4.setTradeName（“谷歌”）；
贸易t5=新贸易（）；
t5.设定价格（28）；
t5.设定数量（1000）；
t5.setQuote（“MSFT”）；
t5.setSource（“巴克莱”）；
t5.setTradeName（“微软”）；
列表交易=新的ArrayList（）；
新增（t1）；
增加(t2);；
新增（t3）；
增加（t4）；
新增（t5）；
List googleTrades=new ArrayList（）；
List microsoftTrades=new ArrayList（）；
整数Google数量=0；
整数数量=0；
贸易（贸易：贸易）{
if（trade.getSource（）等于（“高盛”））{
googleTrades.clear（）；
Google数量+=trade.getQuantity（）；
trade.setQuantity（谷歌数量）；
googleTrades.add（trade）；
}else if（trade.getSource（）.equals（“巴克莱”））{
microsoftTrades.clear（）；
MicrosoftQuantilities+=trade.getQuantity（）；
trade.setQuantity（微软数量）；
添加（交易）；
}
}
System.out.println（“谷歌交易：\n”）；
System.out.println（谷歌交易）；
System.out.println（“\n”）；
System.out.println（“Microsoft交易：\n”）；
System.out.println（微软贸易）；
}

}

检查这是否适合您。

您尝试过什么？您需要知道如何编写循环吗？通讯

import java.util.ArrayList;
import java.util.List;

public class TradeTest {

/**
 * @param args
 */
public static void main(String[] args) {
    Trade t1 = new Trade();
    t1.setPrice(610);
    t1.setQuantity(15);
    t1.setQuote("GOOG");
    t1.setSource("Goldman Sachs");
    t1.setTradeName("Google");

    Trade t2 = new Trade();
    t2.setPrice(28);
    t2.setQuantity(400);
    t2.setQuote("MSFT");
    t2.setSource("Barclays");
    t2.setTradeName("Microsoft");

    Trade t3 = new Trade();
    t3.setPrice(610);
    t3.setQuantity(45);
    t3.setQuote("GOOG");
    t3.setSource("Goldman Sachs");
    t3.setTradeName("Google");

    Trade t4 = new Trade();
    t4.setPrice(610);
    t4.setQuantity(40);
    t4.setQuote("GOOG");
    t4.setSource("Goldman Sachs");
    t4.setTradeName("Google");

    Trade t5 = new Trade();
    t5.setPrice(28);
    t5.setQuantity(1000);
    t5.setQuote("MSFT");
    t5.setSource("Barclays");
    t5.setTradeName("Microsoft");

    List<Trade> trades = new ArrayList<Trade>();
    trades.add(t1);
    trades.add(t2);
    trades.add(t3);
    trades.add(t4);
    trades.add(t5);

    List<Trade> googleTrades = new ArrayList<Trade>();
    List<Trade> microsoftTrades = new ArrayList<Trade>();

    Integer googleQuantities = 0;
    Integer microsoftQuantities = 0;

    for (Trade trade : trades) {
        if (trade.getSource().equals("Goldman Sachs")) {
            googleTrades.clear();
            googleQuantities += trade.getQuantity();
            trade.setQuantity(googleQuantities);
            googleTrades.add(trade);
        } else if (trade.getSource().equals("Barclays")) {
            microsoftTrades.clear();
            microsoftQuantities += trade.getQuantity();
            trade.setQuantity(microsoftQuantities);
            microsoftTrades.add(trade);
        }
    }

    System.out.println("Google trades: \n");
    System.out.println(googleTrades);
    System.out.println("\n");
    System.out.println("Microsoft trades: \n");
    System.out.println(microsoftTrades);

}