比较两个数组时，从第三个数组打印正确的项目时出现问题

Question

我正在尝试编写一个购物清单程序，用户在购物清单上输入相应价格的项目。我对购物清单上的商品使用了一个字符串数组，对价格使用了一个双数组。最后，程序应该打印出最贵的项目和最便宜的项目。

为此，我制作了价格数组的副本。然后使用＜code＞数组对原始价格数组进行排序。sort（），因此它按升序重新排列。之后，我使用for循环将重复的价格数组与已排序的原始数组进行比较，当重复数组中的值与已排序数组中的最低/最高值相同时，我将购物项打印到字符串数组的相应位置。

这似乎并不完全有效，因为打印的字符串并不总是对应于准确的位置，而根据我的逻辑，它应该是这样的。我不知道我错在哪里。我认为问题在于< code > getcheapsitem()和< code > getmostpensiveitem()方法。

编辑：可能有更好的方法来做到这一点，比如使用List或ArrayList，但我需要仅使用数组来解决它。

主要类别:

import java.util.Arrays;
import java.util.Scanner;

    public class Main {

    static Scanner scanner = new Scanner(System.in);
    static int listSize;
    static String[] sl;
    static double[] price;
    static double [] price_duplicate;

    public static void main(String[] args) {

        Fruit fruit = new Fruit();

        shoppingList();
        sl = new String[listSize];
        price = new double[listSize];

        //Loop asking user to enter items and prices
        for(int i = 0; i <= listSize - 1; i++)
        {
            System.out.println("Enter item " + (i+1) + ":");
            fruit.setName(scanner.nextLine());
            sl[i] = fruit.getName();

            System.out.print("Price of " + sl[i] + ":");
            fruit.setPrice(scanner.nextDouble());
            scanner.nextLine(); //calling nextLine() to get rid of the         newline character
            price[i] = fruit.getPrice();
        }
        //Loop printing items and their prices
        System.out.println();
        System.out.println("-Your shopping list-");
        for(int i = 0; i <= listSize - 1; i++)
        {
            System.out.println(sl[i] + " cost " + price[i]);
        }
        System.out.println();

        //Duplicate the price array
        price_duplicate = price;

        //Order the array in ascending order so as to be able to easily     access lowest and highest values in the array
        Arrays.sort(price);

        //Identify the cheapest and most expensive items on the shopping list
        getCheapestItem();
        getMostExpensiveItem();

    }

    static int shoppingList(){
        System.out.print("Enter the number of items in your shopping list:");
        listSize = scanner.nextInt();
        scanner.nextLine(); //calling nextLine() to get rid of the newline     character
        return listSize;
    }

    //Method to match the lowest price in the sorted array to its equivalent     value in the duplicate of the original array and print the corresponding string from the sl array, thus identifying the cheapest item on the list
    static void getCheapestItem(){
        Arrays.sort(price);
        for(int i = 0; i < price_duplicate.length; i++){
            if(price_duplicate[i] == price[0])
            {
                System.out.println(sl[i] + " cost(s) " + price[0] + " and is/are the cheapest item(s) on the list.");
            }
        }
    }
    //Method to Match the highest price in the sorted array to its equivalent value in the duplicate of the original array and print the corresponding string from the sl array, thus identifying the most expensive item on the list
    static void getMostExpensiveItem(){
        Arrays.sort(price);
        for(int i = price_duplicate.length - 1; i >= 0; i--){
            if( price_duplicate[i] == price[price.length - 1])
            {
                System.out.println(sl[i] + " cost(s) " + price[price.length -1] + " and is/are the most expensive item(s) on the list.");
            }
        }
    }




}

水果类：

public class Fruit {
    private String name;
    private double price;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

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

Answer 1

你不必把事情复杂化。你可以通过水果对象本身得到最便宜和最贵的水果。看下面的例子。创建水果对象列表。在Collections.sort中，你可以提供你的Comparator的实现(排序任何对象的方法)。在你的情况下，分类必须按价格进行。排序后，你可以在第一个索引中找到最便宜的水果，在最后一个索引中找到最贵的水果

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Main {

    public static void main(String[] args) {

        List<Fruit> fruitList = new ArrayList<>();
        fruitList.add(new Fruit("orange", 3.2));
        fruitList.add(new Fruit("apple", 9.5));
        fruitList.add(new Fruit("banana", 7.4));
        fruitList.add(new Fruit("grapes", 1.3));

        Collections.sort(fruitList, new Comparator<Fruit>() {
            @Override
            public int compare(Fruit o1, Fruit o2) {
                if (o1.getPrice() < o2.getPrice()) {
                    return -1;
                } else if (o1.getPrice() > o2.getPrice())
                {
                    return 1;
                } else {
                    return 0;
                }
            }
        });
        System.out.println("Cheapest fruit " + fruitList.get(0).getName());
        System.out.println("Expensive fruit " + fruitList.get(3).getName());


    }

}

Answer 2

我不知道为什么要使用两个数组，因为这会使事情变得更加复杂。我会选择单个列表静态列表

那么阅读项目也可以简化:

    for(int i = 0; i <= listSize - 1; i++)
    {
        System.out.println("Enter item " + (i+1) + ":");
        name = scanner.nextLine();

        System.out.print("Price of " + sl[i] + ":");
        price = scanner.nextDouble();
        scanner.nextLine(); //calling nextLine() to get rid of the         newline character

        fruits.add(new Fruit(name, price));
    }

当然，这意味着水果需要一个需要名称和价格的构造函数。name和价格应该在循环之外定义。

要进行排序，您可以使用＜code＞Comperator

Comperator<Fruit> compareByPrice = (Fruit f1, Fruit f2) ->
        f1.getPrice().compareTo(f2.getPrice());

升序排序：

Collections.sort(fruits, compareByPrice);

降序排序：

Collections.sort(fruits, compareByPrice.reversed());

Answer 3

我猜你的问题在于复制/复制价格数组。您使用的是price_duplicate=价格；，它实际上不是复制价格数组的内容，而是引用/指向与重复数组相同的价格数组对象。

因此，当您对原始价格数组进行排序时，您的重复数组也会被排序。有几种方法可以将数组对象复制到另一个数组对象。

但我建议您使用现有的代码流之一，当您将价格插入原始价格数组时，您也可以将它们插入重复数组中。

< br > < code > price[I]= fruit . getprice()之后；只需添加< br > < code > price _ duplicate[I]= fruit . getprice()；

不要忘记初始化重复数组，就像您之前初始化原始价格数组一样。