基础班第六天的案例，现在加了一些IO流的知识在里面，当然还有很多问题的地方，希望大家多多指点

查询水果的方式有些问题。用readObject()方法一次只能读取一次，有一个指针移动的问题，就是当我读取到最后一个的时候，循环还会往下走一次，这是指针指到最底端，那时候已经没有对应的水果了，所以抛出了EOFException异常，如果用for循环改进的话，那必须得知道循环的次数，这样我每次添加水果都得改一次，显得很麻烦，老师提示我可以再持久化一个集合，然后再遍历就能够得到解决，但是这样得大改啊有没有{:2_44:}，~~~~(>_<)~~~~就没有什么其他的好一点的方法吗

1. package cn.itcast.水果超市IO流版本;
   
2. 
   
3. import java.io.Serializable;
   
4. 
   
5. class Fruit implements Serializable {
   
6.         private String ID;
   
7.         private String name;
   
8.         private double price;
   
9.         private int number;
   
10.         private double money;
    
11.         public Fruit(String iD, String name, double price, int number, double money) {
    
12.                 super();
    
13.                 ID = iD;
    
14.                 this.name = name;
    
15.                 this.price = price;
    
16.                 this.number = number;
    
17.                 this.money = money;
    
18.         }
    
19.         /**
    
20.          * @return the iD
    
21.          */
    
22.         public String getID() {
    
23.                 return ID;
    
24.         }
    
25.         /**
    
26.          * @param iD the iD to set
    
27.          */
    
28.         public void setID(String iD) {
    
29.                 ID = iD;
    
30.         }
    
31.         /**
    
32.          * @return the name
    
33.          */
    
34.         public String getName() {
    
35.                 return name;
    
36.         }
    
37.         /**
    
38.          * @param name the name to set
    
39.          */
    
40.         public void setName(String name) {
    
41.                 this.name = name;
    
42.         }
    
43.         /**
    
44.          * @return the price
    
45.          */
    
46.         public double getPrice() {
    
47.                 return price;
    
48.         }
    
49.         /**
    
50.          * @param price the price to set
    
51.          */
    
52.         public void setPrice(double price) {
    
53.                 this.price = price;
    
54.         }
    
55.         /**
    
56.          * @return the number
    
57.          */
    
58.         public int getNumber() {
    
59.                 return number;
    
60.         }
    
61.         /**
    
62.          * @param number the number to set
    
63.          */
    
64.         public void setNumber(int number) {
    
65.                 this.number = number;
    
66.         }
    
67.         /**
    
68.          * @return the money
    
69.          */
    
70.         public double getMoney() {
    
71.                 return money;
    
72.         }
    
73.         /**
    
74.          * @param money the money to set
    
75.          */
    
76.         public void setMoney(double money) {
    
77.                 this.money = money;
    
78.         }
    
79.         public Fruit() {
    
80.                 super();
    
81.                 // TODO Auto-generated constructor stub
    
82.         }
    
83.         /* (non-Javadoc)
    
84.          * @see java.lang.Object#hashCode()
    
85.          */
    
86.         @Override
    
87.         public int hashCode() {
    
88.                 final int prime = 31;
    
89.                 int result = 1;
    
90.                 result = prime * result + ((ID == null) ? 0 : ID.hashCode());
    
91.                 long temp;
    
92.                 temp = Double.doubleToLongBits(money);
    
93.                 result = prime * result + (int) (temp ^ (temp >>> 32));
    
94.                 result = prime * result + ((name == null) ? 0 : name.hashCode());
    
95.                 result = prime * result + number;
    
96.                 temp = Double.doubleToLongBits(price);
    
97.                 result = prime * result + (int) (temp ^ (temp >>> 32));
    
98.                 return result;
    
99.         }
    
100.         /* (non-Javadoc)
     
101.          * @see java.lang.Object#equals(java.lang.Object)
     
102.          */
     
103.         @Override
     
104.         public boolean equals(Object obj) {
     
105.                 if (this == obj)
     
106.                         return true;
     
107.                 if (obj == null)
     
108.                         return false;
     
109.                 if (getClass() != obj.getClass())
     
110.                         return false;
     
111.                 Fruit other = (Fruit) obj;
     
112.                 if (ID == null) {
     
113.                         if (other.ID != null)
     
114.                                 return false;
     
115.                 } else if (!ID.equals(other.ID))
     
116.                         return false;
     
117.                 if (Double.doubleToLongBits(money) != Double
     
118.                                 .doubleToLongBits(other.money))
     
119.                         return false;
     
120.                 if (name == null) {
     
121.                         if (other.name != null)
     
122.                                 return false;
     
123.                 } else if (!name.equals(other.name))
     
124.                         return false;
     
125.                 if (number != other.number)
     
126.                         return false;
     
127.                 if (Double.doubleToLongBits(price) != Double
     
128.                                 .doubleToLongBits(other.price))
     
129.                         return false;
     
130.                 return true;
     
131.         }
     
132.         /* (non-Javadoc)
     
133.          * @see java.lang.Object#toString()
     
134.          */
     
135.         @Override
     
136.         public String toString() {
     
137.                 return "Fruit [ID=" + ID + ", name=" + name + ", price=" + price
     
138.                                 + ", number=" + number + ", money=" + money + "]";
     
139.         }
     
140.        
     
141. }
     

复制代码

1. package cn.itcast.水果超市IO流版本;
   
2. 
   
3. import java.io.BufferedInputStream;
   
4. import java.io.BufferedOutputStream;
   
5. import java.io.FileInputStream;
   
6. import java.io.FileOutputStream;
   
7. import java.io.FileReader;
   
8. import java.io.IOException;
   
9. import java.io.InputStreamReader;
   
10. import java.io.ObjectInputStream;
    
11. import java.io.ObjectOutputStream;
    
12. import java.util.HashMap;
    
13. import java.util.Map;
    
14. import java.util.Scanner;
    
15. import java.util.Set;
    
16. 
    
17. /*
    
18. 文件操作符和序列化能不能一起使用？
    
19. 这里采用序列化方式初始化水果
    
20. 
    
21. * */
    
22. public class MainApp {
    
23.         public static void main(String[] args) throws IOException,
    
24.                         ClassNotFoundException {
    
25.                 Map<String, Fruit> e = new HashMap<String, Fruit>();
    
26.                 // 水果初始化
    
27. 
    
28.                 // 初始化做了两件事，1：将水果序列化 2：给水果配置了文件操作符
    
29.                 init(e);
    
30.                
    
31.                 System.out.println("欢迎来到熊王水果超级市场，熊王水果，越吃越开心！");
    
32.         do{
    
33.                 System.out.println("请根据一下提示完成对应操作");
    
34.                 System.out.println("1：查询水果\t2:增加水果\t3：删除水果\t4：修改水果\t5：退出系统");
    
35.                 Scanner sc = new Scanner(System.in);
    
36.                 int chose = sc.nextInt();
    
37.                 switch (chose) {
    
38.                 case 1:
    
39.                         printAll(e);
    
40.                         break;
    
41.                 case 2:
    
42.                         ftuitFormat(e);
    
43.                         break;
    
44.                 case 3:
    
45.                         fruitRemove(e);
    
46.                         break;
    
47.                 case 4:
    
48.                         updateFruit(e);
    
49.                         break;
    
50.                 case 5:
    
51.                         System.exit(0);
    
52.                         break;
    
53.                 default:
    
54.                         System.out.println("脑残请勿玩坏系统，该干嘛干嘛去");
    
55.                         break;
    
56.                 }
    
57.                 }while(true);
    
58.         }
    
59. 
    
60.         private static void updateFruit(Map<String, Fruit> e) {
    
61.                 System.out.println("请输入要修改的水果编号！");
    
62.                 Scanner sc = new Scanner(System.in);
    
63.                 String idd = sc.next();
    
64.                 Set<Map.Entry<String, Fruit>> ff = e.entrySet();
    
65.                 for(Object g : ff){
    
66.                         Map.Entry<String,Fruit> ee=(Map.Entry<String,Fruit>)g;
    
67.                         String color=ee.getKey();
    
68.                         Fruit gg = ee.getValue();
    
69.                         if(idd==gg.getID()){
    
70.                                 gg.setID(idd);
    
71.                                 System.out.println("请输入新的水果名称");
    
72.                                 String newName = sc.next();
    
73.                                 gg.setName(newName);
    
74.                         // String iD, String name, double price, int number, double money
    
75.                                 System.out.println("请输入新的水果价格");
    
76.                                 double newPrice = sc.nextDouble();
    
77.                                 gg.setPrice(newPrice);
    
78.                                 System.out.println("请输入新的水果数量");
    
79.                                 int newNumber = sc.nextInt();
    
80.                                 gg.setNumber(newNumber);
    
81.                                 System.out.println("请输入新的水果价格");
    
82.                                 double newMoney = sc.nextDouble();
    
83.                                 gg.setMoney(newMoney);
    
84.                         }
    
85.                 }
    
86.                 System.out.println("恭喜！水果更新成功！");
    
87.         }
    
88. 
    
89.         private static void fruitRemove(Map<String, Fruit> e) {
    
90. //删除水果，遍历然后删除水果对象即可，这里任然采用keySet遍历方式
    
91.                 System.out.println("请输入要删除的水果编号");
    
92.                 Scanner sc = new Scanner(System.in);
    
93.                 String idd = sc.next();
    
94.                 Set<String> f = e.keySet();
    
95.                 for(Object g:f){
    
96.                         Fruit l=e.get(g);
    
97.                         if(l.getID()==idd){
    
98.                                 e.remove(l);
    
99.                         }
    
100.                 }
     
101.                 System.out.println("水果删除成功！");
     
102.         }
     
103. 
     
104.         private static void ftuitFormat(Map<String, Fruit> e) {
     
105.                 // 增加水果，需要遍历水果，然后再匹配ID，这时，颜色不需要考虑，只是水果ID不能一致便可添加！这里只用集合的方法来做
     
106. 
     
107.                 Set f = e.keySet();
     
108.         /*        a:while (true) {
     
109.                         Scanner sc = new Scanner(System.in);
     
110.                         String idd = sc.next();
     
111.                         for (Object i : f) {
     
112.                                 Fruit g = e.get(i);
     
113.                                 if (g.getID() == idd) {
     
114.                                         System.out.println("您输入的编号已经存在！");
     
115.                                         continue a;
     
116.                                 }
     
117.                         }
     
118.                         break;
     
119.                 }*/                //这一个验证想法还行，但是感觉无法实施，因为我调用水果类必须先得遍历HashMap，然后再通过匹配不同的值来得到对象，
     
120.                                 //这样就需要用户输入两次才能完成该操作！
     
121.                
     
122.                         System.out.println("请输入要增加的水果编号");
     
123.                         Scanner sc = new Scanner(System.in);
     
124.                         String idd = sc.next();
     
125.                         for (Object i : f) {
     
126.                                 Fruit g = e.get(i);
     
127.                                 if (g.getID() != idd) {
     
128.                                         g.setID(idd);
     
129.                                         // String iD, String name, double price, int number, double money
     
130.                                         System.out.println("请输入要新的水果名称");
     
131.                                         String newname = sc.next();
     
132.                                         g.setName(newname);
     
133.                                         System.out.println("请输入新的水果价格");
     
134.                                         double newprice = sc.nextDouble();
     
135.                                         g.setPrice(newprice);
     
136.                                         System.out.println("请输入新的水果数量");
     
137.                                         int newnumber = sc.nextInt();
     
138.                                         g.setNumber(newnumber);
     
139.                                         System.out.println("请输入新的水果总额");
     
140.                                         double newmoney = sc.nextDouble();
     
141.                                         g.setMoney(newmoney);
     
142.                                         return ;
     
143.                                 }
     
144.                         }
     
145.                         System.out.println("水果添加成功！");
     
146.         }
     
147. 
     
148.         private static void printAll(Map<String, Fruit> e) throws IOException,
     
149.                         ClassNotFoundException {
     
150.                 // 遍历Map集合，打印水果 //遍历方式1
     
151.                 Set<Map.Entry<String, Fruit>> f = e.entrySet();
     
152.                 for (Object i : f) {
     
153.                         Map.Entry<String, Fruit> g = (Map.Entry<String, Fruit>) i;
     
154.                         String color = g.getKey();
     
155.                         Fruit ff = g.getValue();
     
156.                         System.out.println(color + "--------" + ff.getID() + "-------"
     
157.                                         + ff.getName() + "-------" + ff.getNumber()  + "-------"+ ff.getPrice()
     
158.                                          + "-------"+ ff.getMoney());
     
159.                 }
     
160.                 // 遍历文件操作符，打印水果 //遍历方式2
     
161.                 ObjectInputStream input = new ObjectInputStream(
     
162.                                 new BufferedInputStream(new FileInputStream("D:\\3.txt")));
     
163.                 // 持久化对象没有对应的ObjectReader方法，所以这里不能用字符流来读取
     
164.                 Object reading = null;
     
165.                 while ((reading = input.readObject()) != null) {
     
166.                         Fruit dd = (Fruit) reading;
     
167.                         System.out.println(dd.getID() + "-----" + dd.getName() + "-----"
     
168.                                         + dd.getNumber() + "-----" + dd.getPrice() + "-----"
     
169.                                         + dd.getMoney());
     
170.                
     
171.                 }
     
172.                
     
173.                 //EOFException
     
174.                 //这里得持久化一个集合，用这个readObject会产生一个标记问题，这样读取最后一个就会出现EOFException异常！
     
175.         }
     
176. 
     
177.         private static void init(Map<String, Fruit> e) throws IOException {
     
178.                 ObjectOutputStream obj = new ObjectOutputStream(
     
179.                                 new BufferedOutputStream(new FileOutputStream("D:\\3.txt")));
     
180. 
     
181.                 // String iD, String name, double price, int number, double money
     
182.                 /*
     
183.                  * obj.writeObject(new Fruit("0x0001","榴莲",30.0,100,3000.0 ));
     
184.                  * obj.writeObject(new Fruit("0x0002","葡萄",10.0,100,1000.0 ));
     
185.                  * obj.writeObject(new Fruit("0x0003","杨梅",8.0,100,800.0 ));
     
186.                  * obj.writeObject(new Fruit("0x0004","葫芦",3.0,100,300.0 ));
     
187.                  */
     
188.                 Fruit fruit1 = new Fruit("0x0001", "榴莲", 30.0, 100, 3000.0);
     
189.                 obj.writeObject(fruit1);
     
190.                 Fruit fruit2 = new Fruit("0x0002", "葡萄", 10.0, 100, 1000.0);
     
191.                 obj.writeObject(fruit2);
     
192.                 Fruit fruit3 = new Fruit("0x0003", "杨梅", 8.0, 100, 800.0);
     
193.                 obj.writeObject(fruit3);
     
194.                 Fruit fruit4 = new Fruit("0x0004", "葫芦", 3.0, 100, 300.0);
     
195.                 obj.writeObject(fruit4);
     
196. 
     
197.                 obj.close();
     
198.                 // 与此同时，我还需要将其写入集合中，以便完成增删改查的功能,此时Fruit类中已经存了4个对象,因为下面要依次存储，故不用匿名对象
     
199.                 Fruit i = new Fruit();
     
200. 
     
201.                 e.put("黄色", fruit1);
     
202.                 e.put("紫色", fruit2);
     
203.                 e.put("红色", fruit3);
     
204.                 e.put("绿色", fruit4);
     
205. 
     
206.         }
     
207. }
     

复制代码