我需要帮助创建一个新的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; 
    } 
}