[已解决]错误的原因

白痴爱面包

以下代码在编辑时会报 使用了未经检查或不安全的操作，有关详细信息, 请使用 -Xlint:unchecked 重新编译。
怎么解决。

1. import javafx.util.Pair;//多返回值导包
   
2. 
   
3. import java.io.*;//导入包含了流式I/O所需要的所有类
   
4. import java.util.*;
   
5. 
   
6. public class Inventory {
   
7.     //创建Inventory类对象
   
8.     public String itemNumber;//货物型号
   
9.     public int quantity;//货物数量
   
10.     public String supplier;//供应商编号
    
11.     public String description;//货物描述
    
12. 
    
13.     public static void main(String[] args) throws IOException {//抛出读写异常
    
14.         String s = null;
    
15.         List<Inventory> inventoryList = new ArrayList<>();//创建list容器
    
16.         Map<String, Integer> itemToIndex = new HashMap<>();//创建map集合
    
17. 
    
18.         BufferedReader inventoryReader = new BufferedReader(new FileReader("Inventory.txt"));//从文件src/Inventory.txt中读取数据
    
19. 
    
20.         while((s = inventoryReader.readLine()) != null){
    
21.             String[] split =  s.split("\t");
    
22.             inventoryList.add(new Inventory(split[0], Integer.parseInt(split[1]), split[2], split[3]));//将从文件src/Inventory.txt中数据写入到容器inventorylist容器
    
23.             itemToIndex.put(split[0], inventoryList.size() - 1);
    
24.         }
    
25.         inventoryReader.close();//关闭文件
    
26.         System.out.println("Inventory.txt文件读取完成");
    
27. 
    
28.         List<List<String>> transactionsList = new ArrayList<>();
    
29.         for(int i = 0; i < 4; i++){
    
30.             transactionsList.add(new ArrayList<>());
    
31.         }
    
32. 
    
33.         BufferedReader transactionsReader = new BufferedReader(new FileReader("Transactions.txt"));//从文件src/Transactions.txt中读取数据
    
34.         while((s = transactionsReader.readLine()) != null){
    
35.             switch(s.charAt(0)){
    
36.                 case 'O':
    
37.                     transactionsList.get(0).add(s);
    
38.                     break;
    
39.                 case 'R':
    
40.                     transactionsList.get(1).add(s);
    
41.                     break;
    
42.                 case 'A':
    
43.                     transactionsList.get(2).add(s);
    
44.                     break;
    
45.                 case 'D':
    
46.                     transactionsList.get(3).add(s);
    
47.                     break;
    
48.                 default:
    
49.                     break;
    
50.             }
    
51.         }
    
52.         transactionsReader.close();
    
53.         System.out.println("Transaction文件读取完成");
    
54. 
    
55.         for(String temp : transactionsList.get(2)){
    
56.             String[] split = temp.split("\t");
    
57.             inventoryList.add(new Inventory(split[1], 0, split[2], split[3]));
    
58.             itemToIndex.put(split[1], inventoryList.size() - 1);
    
59.         }
    
60. 
    
61.         for(String temp : transactionsList.get(1)){
    
62.             String[] split = temp.split("\t");
    
63.             inventoryList.get(itemToIndex.get(split[1])).quantity += Integer.parseInt(split[2]);
    
64.         }
    
65. 
    
66.         Collections.sort(transactionsList.get(0), new SortByString());
    
67. 
    
68.         Map<String, Pair<String, Integer>> shippingList = new HashMap<>();
    
69.         BufferedWriter errorWriter = new BufferedWriter(new FileWriter("Errors.txt"));
    
70.         for(String temp : transactionsList.get(0)){
    
71.             String[] split = temp.split("\t");
    
72.             if(Integer.parseInt(split[2]) <= inventoryList.get(itemToIndex.get(split[1])).quantity){
    
73.                 inventoryList.get(itemToIndex.get(split[1])).quantity -= Integer.parseInt(split[2]);
    
74.                 if(shippingList.containsKey(split[3]) && shippingList.get(split[3]).getKey() == split[1]){
    
75.                     shippingList.put(split[3], new Pair<String, Integer>(split[1],
    
76.                             Integer.parseInt(split[2]) + shippingList.get(split[3]).getValue()));
    
77.                 }else{
    
78.                     shippingList.put(split[3], new Pair<String, Integer>(split[1], Integer.parseInt(split[2])));
    
79.                 }
    
80.             }else{
    
81.                 errorWriter.write(split[3] + "\t" + split[1] + "\t" + split[2]);
    
82.                 errorWriter.newLine();
    
83.             }
    
84.         }
    
85.         for(String temp : transactionsList.get(3)){
    
86.             String[] split = temp.split("\t");
    
87.             if(inventoryList.get(itemToIndex.get(split[1])).quantity > 0){
    
88.                 errorWriter.write("0" + "\t" + itemToIndex.get(split[1]) + "\t"
    
89.                         + inventoryList.get(itemToIndex.get(split[1])).quantity);
    
90.                 errorWriter.newLine();
    
91.             }
    
92.             inventoryList.remove((int)itemToIndex.get(split[1]));
    
93.         }
    
94.         errorWriter.close();
    
95.         System.out.println("Errors文件写入完成");
    
96. 
    
97.         BufferedWriter shippingWriter = new BufferedWriter(new FileWriter("Shipping.txt"));
    
98.         for (Map.Entry<String, Pair<String, Integer>> entry : shippingList.entrySet()) {
    
99.             shippingWriter.write(entry.getKey() + "\t"
    
100.                     + entry.getValue().getKey() + "\t" + entry.getValue().getValue());
     
101.             shippingWriter.newLine();
     
102.         }
     
103.         shippingWriter.close();
     
104.         System.out.println("shipping文件写入完成");
     
105.         //将新仓库内的物品写入
     
106.         BufferedWriter newInventoryWriter = new BufferedWriter(new FileWriter("NewInventory.txt"));
     
107.         for(Inventory inventory : inventoryList){
     
108.             newInventoryWriter.write(inventory.itemNumber + "\t" + inventory.quantity
     
109.                     + "\t" + inventory.supplier + "\t" + inventory.description);
     
110.             newInventoryWriter.newLine();
     
111.         }
     
112.         newInventoryWriter.close();
     
113.         System.out.println("newInventory文件写入完成");
     
114.         System.out.println("请查看相应文件，了解进出货情况");
     
115.     }
     
116. 
     
117.     public Inventory(String itemNumber, int quantity, String supplier, String description) {//赋值函数，分别将itemNumber,quantity,supplier,description赋值
     
118.         this.itemNumber = itemNumber;
     
119.         this.quantity = quantity;
     
120.         this.supplier = supplier;
     
121.         this.description = description;
     
122.     }
     
123. }
     
124. 
     
125. class SortByString implements Comparator {//比较函数类，并返回1或-1
     
126.     public int compare(Object o1, Object o2) {
     
127.         String[] s1 = ((String)o1).split("\t");
     
128.         String[] s2 = ((String)o2).split("\t");
     
129.         return Integer.parseInt(s1[2]) > Integer.parseInt(s2[2]) ? 1 : -1;
     
130.     }
     
131. }

复制代码

最佳答案

月排行榜 / 总排行榜

isdkz

2023-4-19 16:53:19

白痴爱面包 发表于 2023-4-19 16:41
还是不行

警告信息只是提醒您可以对代码进行优化，以避免未来潜在的问题。警告并不会影响代码的执行。

如果您仍然希望消除这个警告，可以按照以下步骤操作：

1、在编译时添加 -Xlint:unchecked 选项。这将显示详细的警告信息，帮助您找到产生警告的具体位置。例如，如果您使用 javac 进行编译，可以执行以下命令：

1. javac -Xlint:unchecked Inventory.java

复制代码

2、根据详细的警告信息，检查代码中的类型转换或使用泛型的地方。确保所有类型转换都是安全的，并为泛型指定具体的类型参数。

3、如果找不到产生警告的具体原因，或者您确信代码是安全的，可以选择忽略这个警告。将 @SuppressWarnings("unchecked") 注解添加到相关方法或类上，可以抑制这个警告。

例如，将其添加到 main 方法上：

1. @SuppressWarnings("unchecked")
   
2. public static void main(String[] args) throws IOException {
   
3.     // ...
   
4. }

复制代码

请注意，使用 @SuppressWarnings 注解要谨慎，因为它会隐藏潜在的问题。只有在您确信代码是安全的情况下才使用它。

跳转到最佳答案楼层

isdkz

该警告信息表示存在未经检查或不安全的操作。在这个例子中，警告是由于在 Pair 类型参数未指定具体类型所致。为消除此警告，可以在使用 Pair 时显式地指定类型参数。以下是修改后的代码：

首先，将导入语句从 import javafx.util.Pair; 更改为 import java.util.AbstractMap.SimpleEntry;。我们将使用 SimpleEntry 替换 Pair，因为 Pair 是 JavaFX 库的一部分，在一些环境中可能不可用。

然后，将代码中所有的 Pair<String, Integer> 替换为 SimpleEntry<String, Integer>，并相应地更新创建 Pair 实例的方法。这是修改后的部分代码：

1. // ...
   
2. 
   
3. Map<String, SimpleEntry<String, Integer>> shippingList = new HashMap<>();
   
4. BufferedWriter errorWriter = new BufferedWriter(new FileWriter("Errors.txt"));
   
5. for (String temp : transactionsList.get(0)) {
   
6.     String[] split = temp.split("\t");
   
7.     if (Integer.parseInt(split[2]) <= inventoryList.get(itemToIndex.get(split[1])).quantity) {
   
8.         inventoryList.get(itemToIndex.get(split[1])).quantity -= Integer.parseInt(split[2]);
   
9.         if (shippingList.containsKey(split[3]) && shippingList.get(split[3]).getKey().equals(split[1])) {
   
10.             shippingList.put(split[3], new SimpleEntry<>(split[1],
    
11.                     Integer.parseInt(split[2]) + shippingList.get(split[3]).getValue()));
    
12.         } else {
    
13.             shippingList.put(split[3], new SimpleEntry<>(split[1], Integer.parseInt(split[2])));
    
14.         }
    
15.     } else {
    
16.         errorWriter.write(split[3] + "\t" + split[1] + "\t" + split[2]);
    
17.         errorWriter.newLine();
    
18.     }
    
19. }
    
20. 
    
21. // ...
    

复制代码

这样修改后，不安全操作的警告应该消除了。

白痴爱面包

isdkz 发表于 2023-4-19 15:48
该警告信息表示存在未经检查或不安全的操作。在这个例子中，警告是由于在 Pair 类型参数未指定具体类型所致 ...

还是不行

isdkz

白痴爱面包 发表于 2023-4-19 16:41
还是不行

警告信息只是提醒您可以对代码进行优化，以避免未来潜在的问题。警告并不会影响代码的执行。

如果您仍然希望消除这个警告，可以按照以下步骤操作：

1、在编译时添加 -Xlint:unchecked 选项。这将显示详细的警告信息，帮助您找到产生警告的具体位置。例如，如果您使用 javac 进行编译，可以执行以下命令：

1. javac -Xlint:unchecked Inventory.java

复制代码

2、根据详细的警告信息，检查代码中的类型转换或使用泛型的地方。确保所有类型转换都是安全的，并为泛型指定具体的类型参数。

3、如果找不到产生警告的具体原因，或者您确信代码是安全的，可以选择忽略这个警告。将 @SuppressWarnings("unchecked") 注解添加到相关方法或类上，可以抑制这个警告。

例如，将其添加到 main 方法上：

1. @SuppressWarnings("unchecked")
   
2. public static void main(String[] args) throws IOException {
   
3.     // ...
   
4. }

复制代码

请注意，使用 @SuppressWarnings 注解要谨慎，因为它会隐藏潜在的问题。只有在您确信代码是安全的情况下才使用它。