我需要幫助創建一個新的Arraylist從2個單獨的Arraylists

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

如果你想乘以兩個對應的元素名單，你這樣做明顯的方式。沒有涉及的技巧。

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

Answer 2

被編輯爲在下面的評論中包括knutknutsen的回答以及OP的示例實現。

你考慮過使用HashMap嗎？ HashMap是一個List對象，它在其中存儲2個對象。在下面的示例代碼中，我將使用String作爲「Key」（它將被索引的電影的標題）和一個名爲StockInfo的創建類作爲「Object」。然後，您只需要參考某處保存的標題或傳遞給所用課程的標題。

喜歡的東西

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 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; 
    } 
}