java输入输出流（画板五子棋保存）

  File可以创建和删除文件，但是可不可以读取或者写入文件呢？那肯定是不可以的，因为File类里并没有定义读取或写入的方法，
 如果想实现的话，那么就要用到java的输入输出流了。
  文件可以分为以下两种：
 1.文件：就是指的文本文件，扩展名为 .txt  .java的都是文本文件，读取和写入有Writer和Reader方法，存储字节为16位，即一次读取或写入两个字节
 2.流文件：像图片、音乐、视频、office都是流文件，读取和写入就要用InputStream和OutputStream了，它一次读取或写入一个字节的
 
 流：
  我刚学的时候也在想为什么叫流呢？其实流是java中输入和输出的抽象，也就是很形象的体现了java中的输入输出机制，  输入流就是我们在程序中的某个地方（文件、网络）读取数据时用的，输出流就是我们将读取的数据发送到某个地方（文件、网络、控制台）时使用的。
  就像C++中的输入输出一样，cin和cout是C++输入输出流的对象，
  cin缺省对应的是键盘，cin>> 接收从键盘输入的数据
  cout缺省对应的是屏幕，cout<< 是数据输出到屏幕上
 
  流的分类：
   根据基本方法分类：
    输入流：*IputStream  java.io.InputStream是所有输入流的父类
    输出流：*OutputStream java.io.OutputStream是所有输出流的父类
   根据性质可以分为：
   基础字节流：FileInputStream,FileOutputStream  是按字节读取的
   过滤流（缓冲流）：BufferedInputStream,BufferedOutputStream 将读取的文件暂时放到JVM缓冲区后，到一定程度后会一次读出或写入，效率较高
   基于具体数据类型的流：DataInputStream和DataOutputStream    可以读取基本类型的数据
   基于对象的读写：ObjectInputStream和ObjectOutputStream    可以对对象进行保存
  
 输入输出的常用方法：
 InputStream：
   int available() 返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。
   void close() 关闭此输入流并释放与该流关联的所有系统资源。
   void mark(int readlimit)   在此输入流中标记当前的位置。
   boolean markSupported() 测试此输入流是否支持 mark 和 reset 方法。
   abstract  int read()  从输入流中读取数据的下一个字节。
   int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
   int read(byte[] b, int off, int len)   将输入流中最多 len 个数据字节读入 byte 数组。
  
 OutputStream：
   void close() 关闭此输出流并释放与此流有关的所有系统资源。
   void flush() 刷新此输出流并强制写出所有缓冲的输出字节。
   void write(byte[] b)  将 b.length 个字节从指定的 byte 数组写入此输出流。
   void write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
   abstract  void write(int b)  将指定的字节写入此输出流。
  flush()方法要特别注意了，最好每次一涉及到输入输出就调用这个方法，例如在利用BufferedOutputStream时若没调用这个方法，
  就会输不出我们想要的东西
  close() 每次调用完输入输出流后记得关闭文件，如果不关，就像水龙头一样用完不关会出问题的，它会占用系统资源
  
  还有其他一些方法，就不一一列出了，API文档上都有，如果有什么不懂，可以随时查询
  
  之前做了一些简单的画板和五子棋，学习了输入输出流之后就像是不是可以实现基本的保存呢，画板的话就是保存上次画的内容，
  五子棋就保存上次棋局，这个就用到了自定义文件格式了：
   我们自己定义一个文件读写的方法，去读取并输出数据
   我已经实现了画板和五子棋的保存，下面有源码，大家有什么问题和建议可以给我留言
  
  画板的保存

package cn.netjava.xyDraw02;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

import javax.print.Doc;
 
public class DataIO {

	//private int value = 0;
		/**
		 * 保存图形到文件中 
		 * @param njl
		 * :要被保存的队列对象
		 */
	//保存形状的值
 private int value;
	
		public void saveFile(MyQueue<MyShape> muqu) {
			String fileName = "src\\cn\\netjava\\xyDraw02\\MyShape";
			try {
				FileOutputStream fos = new FileOutputStream(fileName);
				DataOutputStream dos = new DataOutputStream(fos);
				// 输出图形的总数到文件
				dos.writeInt(muqu.size());
				// 循环队列中的图形数据
				for (int i = 0; i < muqu.size(); i++) {
					// 得到MyShape对象
					MyShape  mysp = muqu.get(i);
					//得到图形属性
					
					//得到所画图形颜色的RGB值
					int R = mysp.getColor().getRed();
					int G = mysp.getColor().getGreen();
					int B = mysp.getColor().getBlue();
					// 得到坐标值
					int x1 = mysp.getX1();
					int y1 = mysp.getY1();
					int x2 = mysp.getX2();
					int y2 = mysp.getY2();
					if(mysp.getItem().equals("直线")){
						 value = 1;
						System.out.println("value"+value);
					}
					if(mysp.getItem().equals("圆")){
						value = 2;
						System.out.println("value"+value);
					}
					if(mysp.getItem().equals("曲线")){
						value = 3;
						System.out.println("value"+value);
					}
					if(mysp.getItem().equals("长方形")){
						value = 4;
						System.out.println("value"+value);
					}
					
					// 输出图形的坐标到文件中
					dos.writeInt(value);
					dos.writeInt(R);
					dos.writeInt(G);
					dos.writeInt(B);
					dos.writeInt(x1);
					dos.writeInt(y1);
					dos.writeInt(x2);
					dos.writeInt(y2);
					
				}
				System.out.println("文件已输入");
				// 强制写入并关闭
				dos.flush();
				dos.close();

			} catch (Exception e) {
				e.printStackTrace();
			}

		}

		/**
		 * 打开文件，并获取存储在文件中的数据
		 * 
		 * @return 返回所有的数据
		 */
		public MyQueue<MyShape> openFile() {
			// 实例化一个自定义队列对象
			MyQueue<MyShape> myqu = new MyQueue<MyShape>();
			String fileName = "src\\cn\\netjava\\xyDraw02\\MyShape";
			try {
				FileInputStream fis = new FileInputStream(fileName);
				DataInputStream dis = new DataInputStream(fis);
				// 输入图形的总数到文件
				int size = dis.readInt();
				// 循环队列中的图形数据
				for (int i = 0; i < size; i++) {
					value = dis.readInt();
					//得到颜色值
					int R = dis.readInt();
					int G = dis.readInt();
					int B = dis.readInt();
					// 得到坐标值
					int x1 = dis.readInt();
					int y1 = dis.readInt();
					int x2 = dis.readInt();
					int y2 = dis.readInt();
					// 实例化MyShape对象
					MyShape ms = new MyShape(value,R, G, B,x1, y1, x2, y2);
					myqu.add(ms);
				}
				System.out.println("文件已打开");
				// 关闭
				dis.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
			return myqu;
		
		}

	

}

 
  
  重绘方法（加保存）

		//超类
        super.paint(g);
         //取得监听器对象中队列对象,
        MyQueue<MyShape> sh= ml.getShpaes();
        //判断一下，防止出现空指针异常
        if(ml==null){
  			 System.out.print("ml为空");
  		 } else {
  			 //取出队列中的每一个形状对象
  			 for(int i=0;i<sh.size();i++){
  				 //取得队列中的对象
  				 MyShape m = sh.get(i);
  				 //获取颜色
  				 this.g.setColor(m.getColor());
  				 //画直线
  				 if(m.getItem().equals("直线")){
  					this.g.drawLine(m.getX1(), m.getY1(), m.getX2(), m.getY2());
  				 }
  				 
  				 //画圆
  				 if(m.getItem().equals("圆")){
  					this.g.drawOval(m.getX1(), m.getY1(), m.getX2(), m.getY2());
  				 }
  				 //画曲线
  				 if(m.getItem().equals("曲线")){
  					this.g.drawLine(m.getX1(), m.getY1(), m.getX2(), m.getY2());
  				 }
  				 //4为长方形
  				 if(m.getItem().equals("长方形")){
  					this.g.drawRect(m.getX1(), m.getY1(), m.getX2(), m.getY2());
  				 }
  				 //橡皮擦
  				 if(m.getItem().equals("橡皮擦")){
  					this.g.drawLine(m.getX1(), m.getY1(), m.getX2(), m.getY2());
  				 }
  			 }
  		}
        //判断要取出的对象是否为空
        if(myqu==null){
        	System.out.println("对象为空");
        }else{
        	//获取所画图形的数据
			for(int i=0;i<myqu.size();i++){
				
				MyShape ms = myqu.get(i);
				int R = ms.getR();
				int G = ms.getG();
				int B = ms.getB();
				//通过RGB值获取颜色
				java.awt.Color color = new java.awt.Color(R,G,B);
				g.setColor(color); 
				int value = ms.getValue();
				if(value == 1){
					g.drawLine(ms.getX1(), ms.getY1(), ms.getX2(), ms.getY2());
				}
				if(value == 2){
					g.drawOval(ms.getX1(), ms.getY1(), ms.getX2(), ms.getY2());
				}
				if(value == 3){
					g.drawLine(ms.getX1(), ms.getY1(), ms.getX2(), ms.getY2());
				}
				if(value == 4){
					g.drawRect(ms.getX1(), ms.getY1(), ms.getX2(), ms.getY2());
				}
			}
        }
	 

 

 

 

 

 

 

五子棋保存

package cn.netjava.xyWZQ04;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

 
public class DataIO {
		/**
		 * 保存图形到文件中 
		 * @param njl
		 * :要被保存的队列对象
		 */
	private int[][] chess ;
	//定义一个监听器类的对象
	private ChessListener cl ;
	//private int count = 0;
	public void saveFile(int[][] ch) {
			String fileName = "src\\cn\\netjava\\xyWZQ04\\MyShape";
			try {
				FileOutputStream fos = new FileOutputStream(fileName);
				DataOutputStream dos = new DataOutputStream(fos);
				//输出文件总数
//				for(int i = 0; i< ch.length ;i++){
//					for(int j = 0; j <ch[i].length;j++){
//						if(ch[i][j]!=0){
//							count++;
//						}
//					}
//				}
				//System.out.println("文件总数："+count);
				//for(int a = 0; a <count;a++){
				// 循环队列中的图形数据
				//ch = cl.getChess();
				for (int i = 0; i < ch.length; i++) {
					for(int j = 0; j < ch[i].length ;j++){
						int value = ch[i][j];
						dos.writeInt(value);
						if(value !=0)
						System.out.println("value"+value);
					}
				}		
				chess = ch;
				System.out.println("文件已输入");
				// 强制写入并关闭
				dos.flush();
				dos.close();
				//}
			} catch (Exception e) {
				e.printStackTrace();
			}

		}

		/**
		 * 打开文件，并获取存储在文件中的数据
		 * 
		 * @return 返回所有的数据
		 */
		public int[][] openFile() {
			int [][]ch = new int[15][15];
			String fileName = "src\\cn\\netjava\\xyWZQ04\\MyShape";
			try {
				FileInputStream fis = new FileInputStream(fileName);
				DataInputStream dis = new DataInputStream(fis);
				
//				int size = dis.readInt();
//				for(int a = 0; a < size; a++){
				for (int i = 0; i < ch.length; i++) {
					for(int j = 0; j < ch[i].length ;j++){
						int value = dis.readInt();
						ch[i][j] = value;
						if(ch[i][j]!=0)
						System.out.println("ch[j][i]"+ch[i][j]);
				
					}
				}
				System.out.println("文件已打开");
				// 关闭
				dis.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		return ch;
		
		}

		public int[][] getChess() {
			return this.openFile();
			//return chess;
		}

		//返回监听器的方法
		public ChessListener getChessListener() {
			return cl;
		}

}

 

 

重绘方法（保存）

	/**
	 * 定义一个重绘棋子的方法
	 */
	public void drawChess(java.awt.Graphics g) {
		// 判断cl对象是否为空,防止出现空指针异常
		if (null != cl) {
			// 得到数组对象
			int[][] ch = cl.getChess();
			// 循环数组中的每一个元素对象
			for (int i = 0; i < ch.length; i++) {
				for (int j = 0; j < ch[i].length; j++) {
					// 得到 数组中的元素对象
					if (ch[i][j] == 2) {
						//  贴棋子的图片
						java.net.URL url = this.getClass().getResource("b.png");
						// 根据url路径对象创建一个图片对象
						javax.swing.ImageIcon imageW = new javax.swing.ImageIcon(url);
						// 设置图片显示的坐标以及宽度和高度
						g.drawImage(imageW.getImage(),(Config.X + j * Config.SIZE) - Config.CHESS/ 2, (Config.Y + i * Config.SIZE)- Config.CHESS / 2, 
								Config.CHESS, Config.CHESS,observer);
					} else if (ch[i][j] == 1) {
						// 贴棋子的图片
						java.net.URL url = this.getClass().getResource("w.png");
						// 根据url路径对象创建一个图片对象
						javax.swing.ImageIcon imageW = new javax.swing.ImageIcon(url);
						// 设置图片显示的坐标以及宽度和高度
						g.drawImage(imageW.getImage(),(Config.X + j * Config.SIZE) - Config.CHESS/ 2, (Config.Y + i * Config.SIZE)- Config.CHESS / 2, 
								Config.CHESS, Config.CHESS,observer);
					}
				}
			}
		}
		if(ch != null){
			System.out.println("会不出来");
			int[][] ch = dio.getChess(); 
			for(int i = 0; i <ch.length;i++){
				for(int j = 0; j < ch[i].length;j++){
					if(ch[i][j] == 1){
						// 贴棋子的图片
						java.net.URL url = this.getClass().getResource("w.png");
						// 根据url路径对象创建一个图片对象
						javax.swing.ImageIcon imageW = new javax.swing.ImageIcon(url);
						// 设置图片显示的坐标以及宽度和高度
						g.drawImage(imageW.getImage(),(Config.X + j * Config.SIZE) - Config.CHESS/ 2, (Config.Y + i * Config.SIZE)- Config.CHESS / 2, 
								Config.CHESS, Config.CHESS,observer);
					}
					if(ch[i][j]==2){
					//  贴棋子的图片
						java.net.URL url = this.getClass().getResource("b.png");
						// 根据url路径对象创建一个图片对象
						javax.swing.ImageIcon imageW = new javax.swing.ImageIcon(url);
						// 设置图片显示的坐标以及宽度和高度
						g.drawImage(imageW.getImage(),(Config.X + j * Config.SIZE) - Config.CHESS/ 2, (Config.Y + i * Config.SIZE)- Config.CHESS / 2, 
								Config.CHESS, Config.CHESS,observer);
					}
				}
			}
		}
		
	}