Question

我想在实例股票的矢量中确定最畅销的产品。

public void mostSold(Vector <Stock> temp){
    System.out.println ("Generating Data... Please Wait!");
    delay(650);
    System.out.println ("-------Most Sold Product(s)-------");
    for(int i = 0; i < temp.size(); i ++){
        s = temp.elementAt(i); // Stock s = new Stock();
        sold1 = s.getSold();   
        sold2 = msold.getSold(); //Stock msold = new Stock();
        if(sold1 > sold2)
            msold = s;
        else if (sold2 > sold1)
            msold = msold;
        else if (sold1 == sold2){
            equal = true;
        }
    }
    if(!equal)
        System.out.println (msold.toSold());
    else{
        System.out.println (msold.toSold());
        System.out.println (s.toSold());
    }
    System.out.println ();
}

首先执行它时工作正常，但如果我在一次执行中执行2次，控制台会同时输出最多和最少的......！

OUTPUT !! 第一轮:(工作正常）

Generating Data... Please Wait!
-------Most Sold Product(s)-------
Product Name: iphone 
Product ID: 0123P
Quantity Sold: 10

Generating Data... Please Wait!
-------Least Sold Product(s)-------
Product Name: nexus 
Product ID: 2345P
Quantity Sold: 1

第二轮：

Generating Data... Please Wait!
-------Most Sold Product(s)-------
Product Name: iphone 
Product ID: 0123P
Quantity Sold: 10
Product Name: htc one //WHY IS THIS DISPLAYED!!
Product ID: 3456P
Quantity Sold: 1

Generating Data... Please Wait!
-------Least Sold Product(s)-------
Product Name: nexus 
Product ID: 2345P
Quantity Sold: 1

Answer 1

您可能有两只股票价值相等。

假设你有像1,1,2

这样的股票

因此，您的默认股票的值为0，与while循环中的1（第一股票）相比：

sold1 > sold2 satisfies and with this default becomes 1st stock with value 1

for循环查找下一个股票，其价值再次为1

sold1 == sold2 satisfies and equal becomes true

for循环查找下一个有效值为2的股票

sold2 > sold1 satisfies msold remains unchanged

现在看到相等是正确的，所以你输入else部分并用声明打印两次：

 System.out.println (msold.toSold());
 System.out.println (s.toSold());

您可以打印最大值，而不是打印旧值。

Answer 2

我建议使用以下简单代码，分为两个阶段：

确定sold。
收集具有此值的所有库存商品。
它会返回所有这些库存商品，而不是打印它们。

以下是代码：

public List<Stock> getMostSold(Iterable<Stock> stocks) {
  int maxSold = Integer.MIN_VALUE;
  for (Stock stock : stocks) {
    maxSold = Math.max(maxSold, stock.getSold());
  }

  List<Stock> result = new ArrayList<>();
  for (Stock stock : stocks) {
    if (stock.getSold() == maxSold) {
      result.add(stock);
    }
  }
  return result;
}

重要的是这个方法没有副作用，也就是说，它不会修改类或其他东西的任何字段。因此，您可以根据需要随时调用它，并且您将始终获得相同的结果。

Answer 3

您可以使用Comparator：

private static final Comparator<Stock> COMPARATOR
    = new Comparator<Stock>()
    {
        @Override
        public int compare(final Stock o1, final Stock o2)
        {
            return Integer.compare(o1.getSold(), o2.getSold());
        }
    };

// and then (NOTE: assumes at least one element, and no null elements)
public Stock mostSold(final List<Stock> list)
{
    final int size = list.size();
    Stock ret = list.get(0);

    for (int i = 1; i < size; i++)
        if (COMPARATOR.compare(list.get(i), ret) > 0)
            ret = list.get(i);

    return ret;
}

如果使用Java 8，则更容易：

public Stock mostSold(final List<Stock> list)
{
    return list.stream().max(COMPARATOR).get();
}

我的逻辑是否确定最畅销的产品是正确的？

3 个答案: