输入流输出流小结

http://feng1990liu.iteye.com/blog/1911957

输入流输出流主要作用是保存数据，读取数据，作用是可以保存自己的画过的东西，还可以用于数据加密，在写进数据时给出一个规则，在读取数据时利用你规则就可以读出数据，否则数据就是一堆乱码

初步小结，日后在大总结

保存画过的线和图片代码  

1. package FrameIO20130920;  
2. import java.awt.Color;  
3. import java.awt.Graphics;  
4. import java.awt.List;  
5. import java.awt.event.ActionEvent;  
6. import java.awt.event.ActionListener;  
7. import java.awt.event.MouseEvent;  
8. import java.awt.event.MouseListener;  
9. import java.awt.image.BufferedImage;  
10. import java.io.DataInputStream;  
11. import java.io.DataOutputStream;  
12. import java.io.FileInputStream;  
13. import java.io.FileNotFoundException;  
14. import java.io.FileOutputStream;  
15. import java.util.ArrayList;  
16. import java.util.Random;  
17. import javax.swing.ImageIcon;  
18. import javax.swing.JFrame;  
19. import javax.swing.JMenu;  
20. import javax.swing.JMenuBar;  
21. import javax.swing.JMenuItem;  
22. public class drawDrame extends JFrame{  
23.     ImageIcon con=new ImageIcon("images/picture.jpg");  
24.     private BufferedImage  image01;  
25.     //定义坐标属性  
26.     private int x1,y1,x2,y2;  
27.     //画布属性  
28.     private Graphics g;  
29.     private Color color;  
30.     //标志  
31.     private String drawCmd="line";  
32.     //shaape队列  
33.     ArrayList<Shape> lineList=new ArrayList<Shape>();  
34.     //函数入口  
35.     public static void main(String[] args){  
36.         drawDrame frame=new drawDrame();  
37.         frame.showUI();  
38.     }  
39.     //构造初始化界面的方法  
40.     public void showUI(){  
41.         this.setTitle("保存文件");  
42.         this.setSize(800,600);  
43.         this.setDefaultCloseOperation(3);  
44.         JMenuBar bar=new JMenuBar();  
45.         JMenu menu=new JMenu("文件");  
46.         JMenu menu01=new JMenu("图片");  
47.         JMenuItem drawLine=new JMenuItem("画线");  
48.         JMenuItem drawCircle=new JMenuItem("画圆");  
49.         JMenuItem openItem=new JMenuItem("打开");  
50.         JMenuItem saveItem=new JMenuItem("保存");  
51.         JMenuItem closeItem=new JMenuItem("关闭");  
52.         JMenuItem drawpic=new JMenuItem("画图片");  
53.         JMenuItem savepic=new JMenuItem("保存图片");  
54.         JMenuItem openpic=new JMenuItem("打开图片");  
55.         menu.add(drawLine);  
56.         menu.add(drawCircle);  
57.         menu.add(openItem);  
58.         menu.add(saveItem);  
59.         menu.add(closeItem);  
60.         menu01.add(drawpic);  
61.         menu01.add(savepic);  
62.         menu01.add(openpic);  
63.         bar.add(menu);  
64.         bar.add(menu01);  
65.         this.setJMenuBar(bar);  
66.         this.setVisible(true);  
67.         g=this.getGraphics();  
68.         //加事件监听器  
69.         saveItem.addActionListener(menuListener);  
70.         openItem.addActionListener(menuListener);  
71.         drawLine.addActionListener(menuListener);  
72.         drawCircle.addActionListener(menuListener);  
73.         drawpic.addActionListener(menuListener);  
74.         savepic.addActionListener(menuListener);  
75.         openpic.addActionListener(menuListener);  
76.         //鼠标监听器  
77.         this.addMouseListener(new MouseListener() {  
78.             public void mouseReleased(MouseEvent e) {  
79.                 x2=e.getX();  
80.                 y2=e.getY();  
81.                 if(drawCmd.equals("line")){  
82.                 Random random=new Random();  
83.                 //随机色彩  
84.                 color=new Color(random.nextInt(256),random.nextInt(256),random.nextInt(256));  
85.                 Line line=new Line();  
86.                 line.setX1(x1);  
87.                 line.setY1(y1);  
88.                 line.setX2(x2);  
89.                 line.setY2(y2);  
90. //              line.setColor(color);  
91.                 g.drawLine(x1, y1, x2, y2);  
92.                 lineList.add(line);  
93.                 }else if(drawCmd.equals("circle")){  
94.                     g.drawOval(x1, y1, Math.abs(x1-x2), Math.abs(y1-y2));  
95.                 }  
96.             }  
97.             @Override  
98.             public void mousePressed(MouseEvent e) {  
99.                  x1=e.getX();  
100.                  y1=e.getY();  
101.             }  
102.               
103.             @Override  
104.             public void mouseExited(MouseEvent e) {  
105.                 // TODO Auto-generated method stub  
106.                   
107.             }  
108.               
109.             @Override  
110.             public void mouseEntered(MouseEvent e) {  
111.                 // TODO Auto-generated method stub  
112.                   
113.             }  
114.               
115.             @Override  
116.             public void mouseClicked(MouseEvent e) {  
117.                 // TODO Auto-generated method stub  
118.                   
119.             }  
120.         });  
121.           
122.     }  
123.     //实例化事件监听器对象  
124.     ActionListener menuListener=new ActionListener() {  
125.           
126.         public void actionPerformed(ActionEvent e) {  
127.             String cmd=e.getActionCommand();  
128.             if("画线".equals(cmd)){  
129.                 drawCmd="line";  
130.             }else if("画圆".equals(cmd)){  
131.                 drawCmd="circle";  
132.             }  
133.             if("保存".equals(cmd)){  
134.                 try {  
135.                     java.io.FileOutputStream fos=new FileOutputStream("D:/draw02.dat");  
136.                     DataOutputStream dos=new DataOutputStream(fos);  
137.                     //把总线条的数量放在第一个位置  
138.                     dos.writeInt(lineList.size());  
139.                     for(int i=0;i<lineList.size();i++){  
140.                         Shape shape=lineList.get(i);  
141.                         //判断shape是什么类型  
142.                         if(shape instanceof Line){  
143.                             //用数据1表示线段数据  
144.                             dos.writeInt(1);  
145.                             Line line=(Line)shape;  
146.                             dos.writeInt(line.getX1());  
147.                             dos.writeInt(line.getY1());  
148.                             dos.writeInt(line.getX2());  
149.                             dos.writeInt(line.getY2());  
150. //                          dos.writeInt(line.getColor().getRGB());  
151.                         }else if(shape instanceof Circle){  
152.                             //用数据2表示画圆  
153.                             dos.writeInt(2);  
154.                             Circle circle=(Circle)lineList.get(i);  
155.                         }  
156.                     }  
157.                     //画完再关闭！！！！  
158.                     dos.close();  
159.                     fos.close();//关闭数据流  
160.                     System.out.println("保存成功");  
161.                 } catch (Exception e1) {  
162.                     e1.printStackTrace();  
163.                 }  
164.                   
165.             }  
166.       
167.             if("打开".equals(cmd)){  
168.                 try {  
169.                     java.io.FileInputStream fis=new FileInputStream("D:/draw02.dat");  
170.                     DataInputStream dis=new DataInputStream(fis);  
171.                     //把总线条的数量放在第一个位置  
172.                     int total=dis.readInt();  
173.                     for(int i=0;i<total;i++){  
174.                         int type=dis.readInt();  
175.                         if(type==1){  
176.                               
177.                             Line line=new Line();  
178.                             line.setX1(dis.readInt());  
179.                             line.setY1(dis.readInt());  
180.                             line.setX2(dis.readInt());  
181.                             line.setY2(dis.readInt());  
182. //                          line.setColor(new Color(dis.readInt()));  
183. //                      刚开始只画一条线                              
184. //                      x1=dis.readInt();  
185. //                      y1=dis.readInt();  
186. //                      x2=dis.readInt();  
187. //                      y2=dis.readInt();  
188. //                          g.setColor(line.getColor());  
189.                             g.drawLine(line.getX1(),line.getY1(),line.getX2(),line.getY2());  
190.                         }else if(type==2){  
191.                             Circle circle=new Circle();  
192.                             }  
193.                         }  
194.                     dis.close();  
195.                     fis.close();//关闭数据流  
196.                     System.out.println("打开成功");  
197.                 } catch (Exception e1) {  
198.                     e1.printStackTrace();  
199.                 }  
200.             }  
201.             /********图片类处理************/  
202.             if("画图片".equals(cmd)){  
203.                 //缓冲图像，是一张白纸，实为窗体  
204.                 image01=new BufferedImage(con.getIconWidth(), con.getIconHeight(), BufferedImage.TYPE_INT_RGB);  
205.                 Graphics g2=image01.getGraphics();  
206. //              g2.fillOval(100, 100, 100, 100);  
207.                 //白纸上上画图片  
208.                 g2.drawImage(con.getImage(), 0, 0, null);  
209.                 //白纸画到窗体上  
210.                 g.drawImage(image01, 0, 0, null);  
211.             }  
212.             if("打开图片".equals(cmd)){  
213. //              java.io.FileInputStream fis;  
214.                 try {  
215.                     java.io.FileInputStream fis = new FileInputStream("D:/pic.txt");  
216.                     java.io.DataInputStream dis=new DataInputStream(fis);  
217.                     int wide=dis.readInt();  
218.                     int height=dis.readInt();  
219.                     for(int i=0;i<wide;i++){  
220.                         for (int j=0;j<height;j++){  
221. //                          dis.readInt();  
222. //                          g.setColor(new Color(dis.readInt()));  
223.                             g.setColor(new Color(dis.readInt()));  
224.                             g.drawLine(i+200, j+200, i+200, j+200);  
225.                         }  
226.                     }  
227.                     System.out.println("打开图片成功");  
228.                 } catch (Exception e1) {  
229.                     e1.printStackTrace();  
230.                 }  
231.             }  
232.             if("保存图片".equals(cmd)){  
233.                 try {  
234.                     java.io.FileOutputStream fos=new FileOutputStream("D:/pic.txt");  
235.                     java.io.DataOutputStream dos=new DataOutputStream(fos);  
236.                     int width=image01.getWidth();  
237.                     int height=image01.getHeight();  
238.                     dos.writeInt(width);  
239.                     dos.writeInt(height);//写入四个字节  
240.                     for(int x=0;x<width;x++){  
241.                         for(int y=0;y<height;y++){  
242.                             //把点的色彩存入文件  
243. //                          System.out.println("写点1");  
244.                             dos.writeInt(image01.getRGB(x, y));  
245. //                          System.out.println("写点2");  
246.                         }  
247.                     }  
248.                     dos.close();  
249.                     fos.close();  
250.                     System.out.println("保存图片成功");  
251.                 } catch (Exception e1) {  
252.                     e1.printStackTrace();  
253.                 }  
254.             }  
255.         }  
256.     };  
257. }