0

我正在开发一个java程序，我在一个方法中定义和填充了几个向量（来自一个文件）。我需要从方法中返回所有向量的内容。我听说您可以将它们全部放在一个对象中以返回它们。这可能吗？如果可以，怎么做？如果没有，您对我有任何可能的解决方案吗？在此先感谢您的帮助！

这是一个代码片段：

Object getInventory()
{       
        Vector<String> itemID=new Vector<String>();
        Vector<String> itemName=new Vector<String>();
        Vector<Integer> pOrdered=new Vector<Integer>();
        Vector<Integer> pInStore=new Vector<Integer>();
        Vector<Integer> pSold=new Vector<Integer>();
        Vector<Double> manufPrice=new Vector<Double>();
        Vector<Double> sellingPrice=new Vector<Double>();  
        Object inventoryItem=new Object(); //object to store vectors in

    try
    {
        Scanner infile= new Scanner(new FileReader("Ch10Ex16Data.txt"));

        int i=0;

        while (infile.hasNext())
        {                
            itemID.addElement(infile.next());                
            itemName.addElement(infile.next()+infile.nextLine());
            pOrdered.addElement(infile.nextInt());
            pInStore.addElement(pOrdered.elementAt(i));
            pSold.addElement(0);
            manufPrice.addElement(infile.nextDouble());
            sellingPrice.addElement(infile.nextDouble());
            i++;

        }
        infile.close();

        System.out.println(itemID);
        System.out.println(itemName);
        System.out.println(pOrdered);
        System.out.println(pInStore);  
        System.out.println(pSold);
        System.out.println(manufPrice);
        System.out.println(sellingPrice);

    }
    catch (Exception f)
    {
       System.out.print(f);
    }

     return inventoryItem;
}
4

8 回答 8

9

就个人而言，我会完全放弃这种方法。似乎您需要一个 Product 类：

public class Product {

    private String itemName;
    private int itemID;
    // etc etc

    public Product(String itemName, int itemID) {
       this.itemName = itemName;
       this.itemID = itemID;
       // etc etc
     }

    public String getItemName() {
       return itemName;
    }

     public int getItemID() {
      return itemID;
    } 

    // etc etc
}

然后是这样的：

public class Invertory {

 private List<Product> products = new ArrayList<Product>
 // etc etc

public Inventory(String fileName) throws IOException {
      // Load file,
       // Read each product, 
       products.add(new Product(...product arguments); //add to array
  }

  public Product[] getProducts() {
      return products.toArray(new Product[]{});
  }

}

于 2008-11-26T21:05:01.060 回答
3

首先，使用 ArrayList 而不是 Vector。然后使用 Map 作为您的返回对象，条目的每个值都是您的列表之一。

其次，更好的方法是创建一个实际保存每个字段的对象并返回这些对象的 java.util.List。

public class Item
{
    String id;
    String name
    Integer pOrdered;        
    Integer inStore;
           :
           :
于 2008-11-26T21:03:21.080 回答
2

你做错了几件事。

首先，不要使用 Vector。就像，永远。如果排序对您很重要，您需要 API 上的 List（可能还有 ArrayList 或 LinkedList 作为实现）。

其次，您试图让大量数组的值恰好排列在一起。这几乎是不可能使用的。只需创建一个代表一条记录的类，然后返回这些记录的列表。

第三：不要抓住那个异常。你不知道如何处理它，你只会让自己感到困惑。仅当您非常清楚在错误情况下该怎么做时才捕获异常（打印出没有堆栈的错误消息几乎永远不是正确的事情）。

方法的签名是最重要的部分。如果你做对了，那么实施就没有那么重要了。瞄准看起来像这样的东西：

List<Item> getInventory(File input) throws IOException {
}
于 2008-11-26T21:08:34.593 回答
1

你真的应该在这里重新考虑你的设计。你有多个向量，每个向量都具有相同类型事物的属性——你库存中的一个项目。你可能应该把它变成一个单一的类，也许是InventoryItem带有名称、价格等成员的类。然后，在读取每个项目时，你InventoryItem用给定的属性构造一个，并返回一个单一的Vector<InventoryItem>.

如果您真的很想跟踪所有这些单独Vector的 s，您可以只返回 aVector[]以及您拥有的所有向量：

return new Vector[] { itemID, itemName, pOrdered, pInStore, pSold, manufPrice, sellingPrice };

此外，正如Robin所说，您应该使用ArrayList容器而不是Vector. 唯一会改变的是您需要将所有调用更改someVector.AddElement为someList.add。

于 2008-11-26T21:06:15.113 回答
0

听起来应该将其标记为“家庭作业”。

好的，首先，您是否需要使用所有这些向量，或者这是您自己的决定？尽管有些人可能会指出使用 ArrayLists 更好，但我会取消它们并创建您自己的 Item 类。

这样，不是让概念项目的属性分布在多个向量中（您现在正在做的方式），而是每个项目有 1 个项目实例，其中包含与该项目相关的所有数据的字段。现在，您只需要一个数据结构（Vector 或 ArrayList）用于所有项目对象，您可以从 getInventory() 返回该结构。

于 2008-11-26T21:06:29.513 回答
0

声明对象的最简单方法是

List<Vector<? extends Object>> inventoryItem = new ArrayList<Vector<? extends Object>>

但这有几个问题，即 Java 的泛型没有具体化，因此您必须测试并转换您返回的每个向量的内容。更好的解决方案是定义一个容器对象，将每个向量作为字段并添加到这些对象中。

然而，这看起来真的没有抓住重点。相反，您应该定义一个拥有七个字段中的每一个的 InventoryItem。每次从文件中读取对象时，实例化一个新的 InventoryItem 并填充其字段。然后，将其添加到单个 Vector。

此外，通常建议您不要使用 Vector 类。相反，您应该使用 ArrayList。仅当您需要其同步属性时才应真正使用 Vector，即使那样您也应考虑将其他列表包装在 Collections.synchronizedList() 中。

最后，您只想捕获异常的地方可以用一只手来计算。您确实应该捕获 IOException ，甚至您可能只想考虑重新抛出。此外，您应该对异常调用 printStackTrace() 而不是 System.out.println()。

于 2008-11-26T21:15:33.957 回答
0

我发现一个好的经验法则是，在对象之外传递集合从来都不是一个好主意。它们在您的对象内部显然很有用，但在外部您会失去控制并且它们并不明显。

考虑使您的代码可读而不是记录它的原则。如果你收集一个集合，它如何告诉调用者传递什么？即使您使用泛型，也无法断言对集合发生的事情的控制——有人可能会在它传递给您后在另一个线程中添加和删除它。

没有理由不创建一个包含您的集合以及操作它们的业务逻辑的业务类（是的，总是有业务逻辑 - 它是您可以在访问集合的位置周围找到的复制和粘贴代码）。

我曾经发现 JDK 似乎总是采用内置类型而不是集合的数组令人沮丧，但在接受传递集合（如传递任何基本类型）只是不是一个好主意。

于 2008-11-26T22:47:50.743 回答
-1

虽然总的来说我非常同意使用 List/ArrayList 而不是 Vector 的建议，但了解原因很重要。事实上，我不得不强烈反对达斯汀说“永远”不要使用 Vector。

Vector 本质上是一个同步的 ArrayList。如果您确实需要同步，那么请忽略 Dustin 的警告，使用 Vector。

还有另一个例子，Vector 是有道理的。这就是您需要保持与 Java2 之前的代码库的兼容性的时候。

于 2008-11-26T21:15:38.247 回答