我需要帮助从 2 个单独的 Arraylists 创建一个新的 Arraylist

Question

我需要填充我的 totalprices ArrayList 但不知道如何填充。基本上我需要将价格 ArrayList 和数量 ArrayList 相乘。然后获取这些值并将它们添加到 totalprices ArrayList。然后找到总价格的最小值和最大值。我正在拔头发试图弄清楚这一点。请帮忙。谢谢！

我的代码：

import java.util.*;
import java.io.*;

public class Project01 {

public static void main(String[] args) {
    ArrayList<String> titles = new ArrayList<String>();//Declare the array lists that will be used.
    ArrayList<String> types = new ArrayList<String>();
    ArrayList<Double> prices = new ArrayList<Double>();
    ArrayList<Integer> quantities = new ArrayList<Integer>();
    ArrayList<Double> totalprices = new ArrayList<Double>();
    int count = 0;//Set the counter to zero.
    Scanner in = new Scanner(System.in);//Establish the scanner so user input can be properly read.
    String database = getFile(in);//Setting the file name variable from the method below that asks the user for the file's name.
    try {
        File file = new File(database);
        Scanner inputFile = new Scanner(file);
        System.out.println();
        System.out.println("Product Summary Report");
        System.out.println("------------------------------------------------------------");
        while (inputFile.hasNextLine()) {
            getTitle(titles, inputFile.nextLine());
            getQuantity(quantities, inputFile.nextInt());
            inputFile.nextLine();
            getPrice(prices, inputFile.nextDouble());
            inputFile.nextLine();
            getType(types, inputFile.nextLine());
            System.out.println("Title: " + titles.get(count));
            System.out.println(" Product Type: " + types.get(count));
            System.out.println(" Price: " + prices.get(count));
            System.out.println(" Quantity: " + quantities.get(count));
            System.out.println();
            count++;
        }
        System.out.println("-----------------------------------------------------------------");
        System.out.println("Total products in database: " + count);
        Integer index = getLargestQuantityTitle(quantities);
        System.out.println("Largest quantity item : " + titles.get(index) + " (" + types.get(index) + ")");
        ArrayList<Double> highestTotalDollarAmount = getTotalprices(quantities, prices);
        Double highestTotalDollarAmount = getHighestDollarAmount(totalprices);
        System.out.println("Highest total dollar item: $" + highestTotalDollarAmount);
        Integer index2 = getSmallestQuantityTitle(quantities);
        System.out.println("Smallest quantity item: " + titles.get(index2) + " (" + types.get(index2) + ")");
        System.out.println("Lowest total dollar item: ");
        System.out.println("-----------------------------------------------------------------");
        inputFile.close();
    } catch (IOException e) {
        System.out.println("There was a problem reading from " + database);

    }
    in.close();
}
private static String getFile(Scanner inScanner) {
    System.out.print("Enter database filename: ");
    String fileName = inScanner.nextLine();
    return fileName;
}
private static void getTitle(ArrayList<String> titles, String title) { //This method is creating the array list of the titles from the input file.
    titles.add(title);
}
private static void getType(ArrayList<String> types, String type) { //This method is creating the array list of the types from the input file.
    types.add(type);
}
private static void getPrice(ArrayList<Double> prices, double price) { //This method is creating the array list of the prices from the input file.
    prices.add(price);
}
private static void getQuantity(ArrayList<Integer> quantities, int quantity) { //This method is creating the array list of the quantities from the input file.
    quantities.add(quantity);
}
private static Integer getLargestQuantityItem(ArrayList<Integer> quantities){ //This method is determining the maximum value within the quantities array list.
    return Collections.max(quantities);
    }
private static Double getHighestPricedItem(ArrayList<Double> prices){ //This method is determining the maximum price within the prices array list.
    return Collections.max(prices);
}
private static Integer getHighestTotalDollarItem(ArrayList<Integer> prices){ //This method is determining the maximum total value, basically the highest quantity of the item multiplied by it's price.
    return Collections.max(prices);
}
private static Integer getSmallestQuantityItem(ArrayList<Integer> quantities){ //This method is determining the minimum value within the quantities array list.
    return Collections.min(quantities);
    }
private static Integer getLargestQuantityTitle(ArrayList<Integer> quantities){
    int index = 0;
    Integer largestQuantityMainVariable = getLargestQuantityItem(quantities);
    for (int i = 0; i < quantities.size(); i++) {
        if (quantities.get(i) != null && quantities.get(i).equals(largestQuantityMainVariable)) {
            index = i;
            break;
        }
    }
    return index;
}
private static Integer getSmallestQuantityTitle(ArrayList<Integer> quantities){
    int index2 = 0;
    Integer smallestQuantityMainVariable = getSmallestQuantityItem(quantities);
    for (int i = 0; i < quantities.size(); i++) {
        if (quantities.get(i) != null && quantities.get(i).equals(smallestQuantityMainVariable)) {
            index2 = i;
            break;
        }
    }
    return index2;
}
        private static ArrayList<Double> getTotalprices (List<Integer> quantities, List<Double> prices){
    ArrayList<Double> totalprices = new ArrayList<Double>();
    for (int i = 0; i < quantities.size(); i++) {
           totalprices.add(quantities.get(i) * prices.get(i));
      }
      return totalprices;

}
private static Double getHighestDollarAmount(ArrayList<Double> totalprices){ //This method is determining the maximum price within the prices array list.
    return Collections.max(totalprices);
}

}

输出应如下所示：

Enter database filename: proj1_input.txt

Product Summary Report
------------------------------------------------------------
Title: The Shawshank Redemption
    Product Type: DVD
    Price: 19.95
    Quantity: 100

Title: The Dark Knight
    Product Type: DVD
    Price: 19.95
    Quantity: 50

Title: Casablanca
    Product Type: DVD
    Price: 9.95
    Quantity: 137

Title: The Girl With The Dragon Tattoo
    Product Type: Book
    Price: 14.95
    Quantity: 150

Title: Vertigo
    Product Type: DVD
    Price: 9.95
    Quantity: 55

Title: A Game of Thrones
    Product Type: Book
    Price: 8.95
    Quantity: 100

-----------------------------------------------------------------
Total products in database: 6
Largest quantity item: The Girl With The Dragon Tattoo (Book)
Highest total dollar item: $[1995.0, 997.5, 1363.1499999999999, 2242.5, 547.25, 894.9999999999999]
Smallest quantity item: The Dark Knight (DVD)
Lowest total dollar item: Vertigo ($547.25)
-----------------------------------------------------------------

输入文件（.txt 文件）：

The Shawshank Redemption
100
19.95
DVD
The Dark Knight
50
19.95
DVD
Casablanca
137
9.95
DVD
The Girl With The Dragon Tattoo
150
14.95
Book
Vertigo
55
9.95
DVD
A Game of Thrones
100
8.95
Book

Answer 1

已编辑以在下面的 cmets 中包含 knutknutsen 的答案以及 OP 的示例实现。

您是否考虑过为此使用 HashMap？ HashMap 是一个列表对象，其中存储了 2 个对象。在下面的示例代码中，我将使用一个字符串作为“键”（这将是被索引的电影的标题），并使用一个名为 StockInfo 的创建类作为“对象”。然后，您只需要对保存在某处或传递给使用的类的标题的引用。

有点像

public class Project01{
     static HashMap<String, StockInfo> movies = new HashMap<String, StockInfo>();
     static StockInfo movieWithMaxPrice = new StockInfo();
     static StockInfo movieWithMinPrice = new StockInfo();
     static StockInfo movieWithMaxQuantity = new StockInfo();
     static StockInfo movieWithMinQuantity = new StockInfo();

     public static void main(String[] args){
          int counter = 0;
          Scanner in = new Scanner(System.in);
          String database = getFile(in);
          try{
              File file = new File(database);
              Scanner inputFile = new Scanner(file);
              System.out.println();
              System.out.println("Product Summary Report");
              System.out.println("---------------------------------------");
              while(inputFile.hasNextLine()){
                   StockInfo movieInfo = new StockInfo();
                   getTitle(movieInfo, inputFile.nextLine());
                   getQuantity(movieInfo, inputFile.nextInt());
                   inputFile.nextLine();
                   getPrice(movieInfo, inputFile.nextDouble());
                   inputFile.nextLine();
                   getType(movieInfo, inputFile.nextLine());

                   /**This works because we over-rode the toString 
                     *call that java makes on an object when we try to 
                     *print out the object to the console.
                     */
                   System.out.println(movieInfo);
                   System.out.println();

                  /**The last thing we do is save the created  
                    *StockInfo to the saved HashMap
                    */
                   movies.put(movieInfo.getTitle(),movieInfo);
              }
              System.out.println("------------------------------------");
              System.out.println("Total products in database: "+movies.size());
              System.out.println("Largest Quantity item: "+movieWithMaxQuantity.getTitle()+" "+movieWithMaxQuantity.getQuantity());
              System.out.println("Highest total dollar item: "+movieWithMaxPrice.getTitle()+" $"+movieWithMaxPrice.getPrice());
              System.out.println("Smallest Quantity Item: "+movieWithMinQuantity.getTitle()+" "+movieWithMinQuantity.getQuantity());
              System.out.println("Lowest total dollar item: "+movieWithMinPrice.getTitle()+" $"+movieWithMinPrice.getPrice());
          } catch(IOException e){
              System.out.println("There was a problem reading from "+database);
          }
     }

     /**This method will return the fileName that is housing the 
       *database, which is provided to provided through an in console 
       *input from the user
       */
     private static String getFile(Scanner inScanner){
         System.out.print("Enter database filename: ");
         String fileName = inScanner.nextLine();
         return fileName;
     }

     /**This is a re-written method from the OP code, to read the line 
       *in the database file and fill the created StockInfo class with 
       *the title
       */
     private static void getTitle(StockInfo si, String lineToRead){
         si.setTitle(lineToRead);
     }

     /**This is a re-written method from the OP code, to read the line 
       *in the database file and fill the created StockInfo class with 
       *the quantity. This method also compares the given quantity 
       *with the saved quantities above Max and Min
       */
     private static void getQuantity(StockInfo si, int quantity){
         si.setQuantity(quantity);
         if(movieWithMaxQuantity.getQuantity()<quantity){
               movieWithMaxQuantity = si;
         }
         if(movieWithMinQuantity.getQuantity()>quantity){
               movieWithMinQuantity = si;
         }
     }
     /**This is a re-written method from the OP code, to read the line
       *in the database file and fill the created StockInfo class with
       *the price. This method also compares the given price with the
       *max and min StockInfo objects saved at the top of the class, 
       *to see if this is higher or lower then those. If it is
       *then is saves the new StockInfo object at its respective place
       *so that we always have a pointer towards the max and min
       */
     private static void getPrice(StockInfo si, double price){
         si.setPrice(price);
         if(movieWithMaxPrice.getPrice()<price){
              movieWithMaxPrice = si;
         }
         if(movieWithMinPrice.getPrice()>price){
              movieWithMinPrice = si;
         }
     }

     /**This is a re-written method from the OP code, that takes the
       *next line in the database and assigns it to the StockInfo as
       *its type
       */
     private static void getType(StockInfo si, String lineToRead){
         si.setType(lineToRead);
     }   

   }

/**This is the created class that will be used with the information
  *that gets provided
  */
class StockInfo{
    private String title = "";    //saved reference to the title
    private String type  = "";    //saved reference to the type
    /**saved reference to the price, pre filled at -1 to avoid null pointer exception*/
    private double price = -1;    
    /**saved reference to the quantity available, pre filled at -1 to avoid null pointer exception*/
    private int quantity = -1;


    /**This is the constructor, which needs nothing in this case*/
    public StockInfo(){} 

    /**This is the setter for our saved title string above*/
    public void setTitle(String title){
         this.title=title;
    }    

    /**This is the setter from our saved type string above*/
    public void setType(String type){
         this.type=type;
    }

    /**This is the setter for our saved price integer above*/
    public void setPrice(double price){
         this.price=price;
    }

    /**This is the setter for our saved quantity integer above*/
    public void setQuantity(int quantity){
         this.quantity=quantity;
    }

    /**This is the getter for the title*/
    public String getTitle(){
         return this.title;
    }

    /**This is the getter for the type*/
    public String getType(){
         return this.type;
    }

    /**This is the getter for the saved price*/
    public double getPrice(){
         return this.price;
    }

    /**This is the getter for the saved quantity*/
    public int getQuantity(){
         return this.quantity;
    }

    /**Overriding the toString call and making it return the info needed*/
    @Override
    public String toString(){
         return "Title: "+title+" Type: "+type+"  Price: "+price+" Quantity: "+quantity;
    }
}

Answer 2

如果您想将两个列表中的对应元素相乘，您可以按照显而易见的方式进行操作。没有任何技巧。

for(int k = 0; k < prices.size(); k++) {
    totalprices.add(prices.get(k) * quantities.get(k));
}

Answer 3

就像@immibis 已经说过的答案一样，将两个列表相乘（假设长度相同）并不神奇。但我建议您重新考虑您的方法：

您应该创建一个代表库存项目的单个类，而不是维护多个列表。这样，您只需维护一个列表。

像这样：

public class Project {

  public static class StockItem  {
    public String name;
    public double price;
    public int quantity;
    // ....
  }

  public static void main(String[] args) {
    List<StockItem> stockList = new ArrayList<>(); // <> works with Java 7+ 

    // make new items
    StockItem newItem = new StockItem();
    newItem.name = nameFromInput;
    newItem.price = priceFromInput;
    // etc.

    // adding it to list
    stockList.add(newItem);

    List<Double> totalPrices = computeTotalPrices(stockList);
  }

  public static List<Double> computeTotalPrices(List<StockItem> stockList) {
    List<Double> totals = new ArrayList<>();
    for (StockItem item : stockList) {
      total.add(item.quantity * item.price);
    }
    return totals;
  }

这应该使您更容易维护商品、价格、数量等的上下文。

请注意，我的代码中的类有很大的改进空间（或者更确切地说是设计缺陷），但它可以解决问题。还有更多，您将需要更多有关设计课程等的知识。我不确定您是否已经具备这些知识。 （如果你有，我可以修改我的答案；D）

Answer 4

我认为最优雅的解决方案是

public class Order {
    public String name;
    public double price;
    public int quantity;

    public double getTotal(){
      return  price*quantity;
   }
}

public class ReportProvider {
   public double getMin(List<Order> orders){
      double min = double.MaxValue;
      for(Order order : orders) {
          double total = order.getTotal();
          if(total < min) // same in max just use > instead
          {
            min = total;
          } 
      }
    return min;
  }
}