javaio

转自：http://baihe747.iteye.com/blog/2071000

JAVA IO FileInputStream和FileOutputStream，字节流的打包输出

在程序设计语言中，数据的保存是基本，如果某程序语言不能保存数据那么该语言是不可能存在的，JAVA是当今最流行的面向对象设计语言之一，在保存数据中也有自己独特的一面，字节流和字符流

1，字节流是由字节构成的，字符流是由字符构成的 字节流和字符流都是继承的InputStream和OutPutStream ,java中两种最基本的就是字节流和字符流

 

类 FileInputStream 从文件系统中的某个文件中获得输入字节

 

 

类 FileOutputStream 文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。文件是否可用或能否可以被创建取决于基础平台。特别是某些平台一次只允许一个 FileOutputStream（或其他文件写入对象）打开文件进行写入。在这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。

 

2，数据流：用于传输的管道

 

3.java.io 输入流 InputStream 输出流 OutputStream

 

4.对文件系统的输入和输出 字节流：数据在管道中是以字节的方式传输的

文件输入流 FileInputStream

文件输出流 FileOutputStream

将字节流包装到缓冲流中，传输的速度回提高几百倍，在下面的代码中我们将做测试

缓冲字节输入流 BufferedInputStream

缓冲字节输出流 BufferedOutputStream

 

5，使用FileInputStream来一字节一个字节的读取字节：在写代码之前先看api文档中字节输入流中有哪些方法，

在java输入流中，如果程序读取的文件不存在 程序是不会自动的创建该文件，输出流则会自己创建

 

在工程中创建一个FileInputstream01.txt 文本，里面写"中国式"个字符

 

package FileIO0523;
/**
 * 字节流的操作
 * 使用FileInputStream来一字节一个字节的读取字节
 */

import java.io.File;
import java.io.FileInputStream;

public class FileInputstream01 {

	public static void main(String[] args) {
      //创建文件的对象
		File file = new File("FileInputstream01.txt");
		try{
         //try-catch是因为这个文件可能不存在，程序可能会无法执行抛出异常
			//使用文本创建输入流对象
			FileInputStream fis =new FileInputStream(file);
			
//			for(int i=0;i<file.length();i++){
//				//byte ch = (byte) fis.read();
//				char ch  = (char) fis.read();
//				System.out.println(ch);
//				}
			//根据文件的长度来创建一个byte数组用来保存字节
                     //
			byte[] by= new byte[(int) (file.length())];
			fis.read(by);
			String str = new String(by);
				System.out.println(str);
				
				
			//	fis.read();
			
				fis.close();
				
			//}
			
			
		}catch(Exception e){
			e.printStackTrace();
		}

	}

}

 

运行结果;
中国式

 分析read()；也可以用来判断读的字节，当read为-1的时候表示已经是最后一个字节了

fis.read(by);将by数组中的字符一个一个读出来

String str = new String(by);通过使用平台的默认字符集解码指定的 byte 数组 ，  构造一个
新的 String
System.out.println(str);
将这个String打印出来

fis.close();关闭这个输入流，java程序是运行在java虚拟机上面的，虚拟机的运行空间是由系统内存分配的，如果不关闭输入流空间，会导致大量的内存浪费，及内存空间不足

 

6，使用FileOutputStream来一字节一个字节的写字节：在写代码之前先看api文档中字节输入流中有哪些方法，

在java输入输出的文件操作中，如果该文件在程序要输出时不存在 程序会自动的创建该文件  ，

package FileIO0523;

import java.io.File;
import java.io.FileOutputStream;

/**
 * 创建一个字节输出流
 * @author Administrator
 *
 */

public class FileoutputStream01 {

	public static void main(String[] args) {

		String str ="湖南长沙";
		//由于是静态方法可直接通过方法名来调用
		put01(str);
	}
	//创建一个静态的方法，方便在主函数中来调用该方法
	public static void put01(String str){
		//创建文件对象，文件输出对象会在输出时候判断
//		该文件是否存在，如果不存在会自动创建该标准文件
		File file = new File("FileoutputStream01.txt");
		try{
			//通过文件创建输出字节流的对象
			//创建输出流
			//参数一：要写入的文件
			//参数二：是否需要将数据追到数据的末尾ture表示追加到末尾，false表示覆盖
			FileOutputStream stream = new FileOutputStream(file,true);
			//将字符串保存到数组中
			byte[] buf=str.getBytes();
			//将数组中的元素写出来
			stream.write(buf);
			//强制的从内存写到硬盘中
			stream.flush();
			//关闭流
			stream.close();
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}

}

 

运行结果：
湖南长沙

 

分析:该程序在写出字符时会先判断要写出的文件是否存在，如果不存会自动的创建

 

 

7，如何在一个程序中将读取到的方法写到文件中去：下面是一个复制程序:

package FileIO0523;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * 文件流的操作
 * 
 *
 * 
 */
public class FIleIO2 {

	public static void main(String args[]) {

		String path = "C:\\Users\\Administrator\\Desktop\\import";
		String path1 = "F:\\file1\\import";
		// 创建文件对象
		File f = new File(path);
		File f1 = new File(path1);

		long t1 = System.currentTimeMillis();
		byte[] str = readFile(f);
		writeFile(f1, str);
		long t2 = System.currentTimeMillis();
		System.out.println("复制完成！耗时：" + (t2 - t1) + "ms");

	}

	public static void writeFile(File f, byte[] bs) {
		try {
			// 根据文件对象建立文件输出流
			// 参数1：要写入数据的文件路径
			// 参数2：是否将数据追加到文件末尾
			FileOutputStream fos = new FileOutputStream(f, false);
			// 将输出流包装成缓冲输出流
			BufferedOutputStream bos = new BufferedOutputStream(fos);

			// 使用缓冲流将数组写入输出流
			bos.write(bs);

			// 强制将管道中的数据输出到目标，保证数据写完整
			bos.flush();
			// 关闭输出流
			fos.close();

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

	/**
	 * 读取文件数据的方法
	 * 
	 * @param f
	 *            要读读取的文件路径
	 */
	public static byte[] readFile(File f) {
		try {
			// 根据文件建立建立文件输入流
			FileInputStream fis = new FileInputStream(f);
			// 将文件输入流打包成缓冲输入流
			BufferedInputStream bis = new BufferedInputStream(fis);

			int len = bis.available();// 得到流中的字节数
			// 方式一：通过流的长度决定读的次数
			// while(len>0){
			// //读取流中的一个字节
			// int b = fis.read();
			// System.out.println("字节:"+b);
			// len = fis.available();
			// }

			byte[] bs = new byte[len];

			// 方式二，通过读取的字节判断读取的次数〉若为-1，就结束
			// int i=0;
			// int b = fis.read();
			// while(b!=-1){
			// System.out.println("字节:"+b);
			// //将字节保存到字节数组
			// bs[i]=(byte)b;
			// i++;
			//
			// b = fis.read();
			// }

			// 方式三：直接将数据读取到字节数组，数组有多大，就读取多少次
			bis.read(bs);
			fis.close();

			return bs;

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

		}

		return null;

	}

}

 分析：在这个复制程序中创建两个方法分别是读和写，在程序的执行中会先调用读的方法，将读取到的内容保存到数组中 在读的方法中不直接打印出来 通过return返回主函数中以数组的形式来接受；并且该数组要作为参数传递到写的方法中；

 

 

7，作业：在一个方法中完成文件的复制

分析：方法中要包读和写的操作

 

package FileIO0523;
/**
 * 不可以拷贝文件夹，图片
 */

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 *  作业：在一个方法中完成文件的复制
 
 * @author Administrator
 *
 */
public class copyinputoutput02 {

	public static void main(String[] args) {
		
		//源文件的地址
		String path1 ="C:\\Users\\Administrator\\Desktop\\文件操作.rar";
		//copy的地址
		String path2 = "F:\\file1\\文件操作.rar";
		
		File file1 = new File(path1);
		File file2 = new File(path2);
		copy02(file1,file2);
		System.out.println("拷贝完成");
	}
	
	
	public static void copy02(File file1,File file2){
		
		try{
			//读
			FileInputStream fis= new FileInputStream(file1);
			//创建输入缓冲流
			BufferedInputStream bis = new BufferedInputStream(fis);
			//根据读到文件的大小来创建数组
			byte[] by = new byte[(int) (file1.length())];
			//读取
			bis.read(by);
			//关闭流
			fis.close();
			
			//写
			FileOutputStream fos = new FileOutputStream(file2);
			//创建输出缓冲流
			BufferedOutputStream bos = new BufferedOutputStream(fos);
			//直接写保存在数组中的数据
			bos.write(by);
			//强制写出来
			bos.flush();
			//关闭流空间
			fos.close();
			
		}catch(Exception e){
			e.printStackTrace();
		}
		

	
	}
	

	
}

 

分析：该程序的可读性高，在一个方法中不做任何的返回，将读取到的数据保存到根据读取的文件大小创建的数组中，写的方法可以调用；

 JAVA IO InputStreamReader和OutputStreamReader

这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励 我会更加的去学 加油！：

JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流

 

字节流和字符的难点：a,怎么将读到的数据保存起来，怎么检测已经数据已经读完     使用read（）方法和根据文件大小创建数组

                              b,怎么将读到的数据写出，通过遍历和String类

 

1，字符数据流 char 字符流建立在字节流的基础上的

 

,2，InputStreamReader字符输入流： 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。 每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节

 

,3，OutputStreanWriter字符输出流： 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。 每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。可以指定此缓冲区的大小，不过，默认的缓冲区对多数用途来说已足够大。

 

,4，InputStreamReader中的read（）方法和文件操作流的方法一样，当read为-1时，表示已经读到了最后一个

 

5，定义一个字符流来读取文本中的字符数据：

 

public class File11 {

	public static void main(String args[]) {
       //在桌面上创建一个文件“新建文本文档.txt”
        File f1 = new File("C:\\Users\\Administrator\\Desktop\\新建文本文档.txt");
	copyFile(f1);

	}

public static void copyFile(File f1) {
		try {
			// 获得输入流
			FileInputStream fis = new FileInputStream(f1);
			// 包装成字符流
			InputStreamReader reader = new InputStreamReader(fis);
   //			char[] ch = new char[(int) f1.length()];
//			reader.read(ch);
//			System.out.println(ch);

//			// 读取一个字符
			int c = reader.read();
			while (c != -1) {
				char ch = (char) c;
				 
			// 写出字符
				System.out.println(ch);
				// 读取下一个字符
				c = reader.read();
			   
			}
			fis.close();
		

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

	}
}

 

分析：在上述程序中读取文本中的内容有谢了两个方法，第一个是根据文本的长度来创建一个数组保存数据

char[] ch = new char[(int) f1.length()];

第二种是使用read（）方法，当read不为-1时 表示继续读取，将其转换成字符的形式

			int c = reader.read();
			while (c != -1) {
				char ch = (char) c;

 

 

6，使用字符流来创建一个输出的字符流，程序的写法与字节流相似

 

 

package 字符流01;

import java.io.*;

public class File001 {

	public static void main(String[] args) {
		String str= "湖南长沙";
		writeFile(str);
		System.out.println("完成");
	}
	
	public static void writeFile( String str) {
              //如果不存在会自动创建
		File file= new File("E:\\502\\新建文本文档.txt");
		try {
			// 文件输出流
			FileOutputStream fos = new FileOutputStream(file);

			// 将字节流包装成字符输出流
			OutputStreamWriter writer = new OutputStreamWriter(fos);

			// 遍历字符串，写出字符
			for (int i = 0; i < str.length(); i++) {
				// 取出一个字符
				char c = str.charAt(i);
				writer.write(c);
			}

			// 强制输出
			writer.flush();
			fos.close();

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

}

 

运行结果：
湖南长沙

 分析:创建文件对象-->创建文件输出流--->创建字符流输出---->将数组中的数遍历出来--->取出字符串并且强制转换成char   char c = str.charAt(i); -->写出文本-->强制写出----->关闭流空间

 

 

 

 

7，使用字符流来拷贝文件：

分析：字符流做的拷贝程序 只能拷贝字符类的，字节流做的拷贝程序可以拷贝所有的

 

 

	
package 字符流01;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class FileUtil {

	public static void main(String args[]) {

		File f1 = new File("C:\\Users\\Administrator\\Desktop\\新建文本文档.txt");
		File f2 = new File("E:\\502\\新建文本文档.txt");
		copyFile(f1, f2);

	}

/**
	 * 字符串文件复制
	 * 
	 * @param f1
	 *            要复制的原文件
	 * @param f2
	 *            复制后的新文件
	 */
	public static void copyFile(File f1,File f2) {
		try {
			// 获得输入流
			FileInputStream fis = new FileInputStream(f1);
			// 包装成字符流
			InputStreamReader reader = new InputStreamReader(fis);
			

			// 获得输出流
			FileOutputStream fos = new FileOutputStream(f2);
			// 将字节流包装成字符输出流
			OutputStreamWriter writer = new OutputStreamWriter(fos);
			char[] ch = new char[(int) f1.length()];
			reader.read(ch);
			System.out.println(ch);

			writer.write(ch);
			writer.flush();
			fis.close();
			fos.close();

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

	}
}

 

 

分析：先创建输入输出字符流--->将输入流的文件保存在char数组中char[] ch = new char[(int) f1.length()];--->再读reader.read(ch);--->写出去writer.write(ch);-->强制写出--->关闭两个基本流

 java.io操作 DataInputStream和DataOutputStream基本数据流

1，java中如果不保存整个对象，只保存类中的属性，那么我们可以使用本篇文章中的方法，如果要保存整个对象  先将类实例化  后面的文章将详细写到

 

 

2，DataInputStream 是java.io包中一个数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。

 

3，DataOutputStream是java.io包中一个数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后， 应用程序可以使用数据输入流将数据读入。

 

4，DataInputStream和DataOutputStream主要是对java中的基本 数据的读写操作read()和write(); readBoolean(); readByte(); readcChar(); readShort(); readInt(); readFloat(); readDouble(); readLong();

上面的这些读基础数据的方法，他们都会有一个返回都是以字 节的形式返回的，JAVA的api中说的很清楚

 

5，下面将使用DataInputStream和DataOutputStream来写一个读写的程序；

 

分析;下面的程序不能可以将属性写入到文本，读取不到资源？

 

 

package File0524;
import java.io.*;

public class Date {

	public static void main(String[] args) {
		File file  = new File("F:\\file1\\读取_Data.doc");
		writer(file);
		reads(file);
	}
	
	public static void writer(File file){
		try{
			FileOutputStream fos = new FileOutputStream(file);
			DataOutputStream dos = new DataOutputStream(fos );
			dos.writeChar('王');
			dos.writeFloat(123.33F);
			dos.writeInt(2222);
			dos.flush();
			fos.close();
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
	
		
		public static void reads(File file){
			
			try{
				FileInputStream fis = new FileInputStream(file);
				DataInputStream dis = new  DataInputStream(fis);
                              //使用read来读取数据时，不要写要读取的数据  ，读的数据要和写/                             //的数据顺序一样
				char c =dis.readChar();
				float f1=dis.readFloat();
				int  i = dis.readInt();
				System.out.println("完成");
				System.out.println(c);
				System.out.println(f1);
				System.out.println(i);
				
			
			}catch(Exception e){
				e.printStackTrace();
			}
		}
}

 

运行结果
完成
王
123.33
2222

 分析：

 

 

在本类中我们先创建一个写的方法，并创建一个“读取_Data.doc'，当我们使用wps打开的时候，里面是:"s婤雳"这表明我们不能直接看到我们写进去的东西，我们在创建一个读的方法，在开发软件中会返回给我们读取到的结果

 

 

 

 

5，使用java.io中的基础数据流来保存属性

 

package File0524;

public class Date1 {
	private String name;
	private int age;
	
	
	public Date1(String name,int age){
		this.name=  name;
		this.age = age;
	}
	
	public void setName(String name){
		this.name = name;
	}
	public void setAge(int age){
		this.age = age;
	}
	
	public String getName(){
		return name;
	}
	
	public int getAge(){
		return age;
	}
	

}

 

package File0524;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 *定义Date1Test来保存Data1中的数据
 * @author Administrator
 *
 */
public class Date1Test {

	public static void main(String[] args) {
		 Date1[] d1 ={ new Date1("王佳1",10),
		 			new Date1("王佳2",20),
		 			new Date1("王佳3",30)};

		 
		 try{
			 File file = new File("F:\\file1\\Data_File.txt");
			 File file1 = new File("F:\\file1\\Data_File1.txt");
			 
//			 FileOutputStream fos = new FileOutputStream(file);
//			 DataOutputStream dos = new DataOutputStream(fos);
			 
			 DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
			 //使用for循环将读取到的数据一个一个输出
			 for(Date1 date1 : d1){
				 dos.writeUTF(date1.getName());
				 dos.writeInt(date1.getAge());
				 System.out.println("写出的数据：" +date1.getName()+date1.getAge());
				 
			 }
			 dos.flush();
			 dos.close();
//			 //创建字节输入流
//			 FileInputStream fis = new FileInputStream(file1);
//			 //创建java基础数据操作输入流
//			 DataInputStream dis = new DataInputStream(fis) ;
			 DataInputStream dis = new DataInputStream(new FileInputStream(file1)) ;
			 //使用for循环将读取到的数据一个一个的读取出来，保存在d1的数组中
			 for(int i =0;i<d1.length;i++){
				 //读取UTF的字符串
				//String name = dis.readUTF();
				String name = dis.readUTF(); 
				//读取int数据
				int age = dis.readInt();
				 System.out.printf("%s\t%d%n",name,age);
				 //d1[i] = new Date1(name,age);
			 }
			 
			 dis.close();
			 //显示还原后的数据
			 //将读取到的文件进行遍历
//			 for(Date1 Date1:d1){
////			 System.out.println("获取到了对象，对其进行全部的打印输出："
////			 		+ Date1.getName(),Date1.getAge());
//				 
//			 System.out.printf("%s\t%d%n",Date1.getName(),Date1.getAge());
//			 }
			 
			 
		 }catch(Exception e){
			 e.printStackTrace();
		 }
	}
	
	
}

 

运行结果：
写出的数据：王佳110
写出的数据：王佳220
写出的数据：王佳330
java.io.EOFException
	at java.io.DataInputStream.readUnsignedShort(Unknown Source)
	at java.io.DataInputStream.readUTF(Unknown Source)
	at java.io.DataInputStream.readUTF(Unknown Source)
	at File0524.Date1Test.main(Date1Test.java:48)

 数据输入流和对象流分别保存画图板的图形      

        基础数据流与对象流分别保存对象

 

 

一:前几天在考虑如何使用基础数据流来保存画图板中的数据;

分析:

1,截取图片之后根据图片的大小的创建二维数组,将颜色点保存在数组二维数组中;

2,在paint()方法中将保存在二维数组中的颜色点遍历出来,并绘制


3,如何将绘制的图形保存到文件中
  
    保存;
       创建文件输出流:FileOutputStream fos = new FileOutputStream(file);
       创建基础数据流:DataOutputStream dos = new DataOutputStream(fos);
       再判断监听器中是否存在
       if(lis !=null){
       int colors[][] = lis.colors;
          再判断是否有颜色
	  if(colors !=null){
	  dos.wirteInt(lis.colors.lenght);
	   dos.wirteInt(lis.colors[0].lenght);
		for (int i = 0; i < lis.colors.length; i++) {
                  for (int j = 0; j < lis.colors[i].length; j++) {
		  //将创建出来的颜色保存到创建的二维数组中
			int color = lis.colors[i][j];
			dos.wirteInt(color);
		  }
		}
	  }
       }

       打开:
       FileInputStream fis = new FileInputStream(file);
	DataInputStream dis = new DataInputStream(fis);
	// 读取高度和t宽度
	int height = dis.readInt();
	int width = dis.readInt();
	// 定义数组来存放读取的数据
	lis.colors = new int[height][width];
	for (int i = 0; i < lis.colors.length; i++) {
	for (int j = 0; j < lis.colors[i].length; j++) {
	lis.colors[i][j] = dis.readInt();
		}
	}
}}

文件的保存与打开  和将截取的图片保存与paint  二者的写法相似

 

package com.iteye.com;
/**
*界面的主类,监听器.文件
*/
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import javax.swing.ButtonGroup;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JRadioButton;

/**
 * 画图板的界面类
 * 
 * @author
 * 
 */
public class DrawUI extends JFrame {

	String path = "F:\\abc\\a.img";
	JPanel center;

	// 单选按钮组
	ButtonGroup group = new ButtonGroup();
	DrawListener lis;

	public static void main(String args[]) {
		DrawUI du = new DrawUI();
		du.initUI();

	}

	/**
	 * 初始化窗体的方法
	 */
	public void initUI() {
		this.setTitle("画图板");
		this.setSize(600, 400);
		// 设置点击关闭按钮的时候退出程序
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		// 设置窗体的布局为边框布局
		BorderLayout layout = new BorderLayout();
		this.setLayout(layout);

		JMenuBar bar = createJMenuBar();
		this.setJMenuBar(bar);

		JPanel left = this.cerateLeft();
		JPanel center = this.createCenter();
		JPanel bottom = this.createBottom();

		this.add(left, BorderLayout.WEST);
		this.add(center, BorderLayout.CENTER);
		this.add(bottom, BorderLayout.SOUTH);

		this.setVisible(true);

		// 创建监听器对象
		lis = new DrawListener(group);
		// 给center加上监听器
		center.addMouseListener(lis);

	}

	/**
	 * 创建菜单条的方法
	 * 
	 * @return
	 */
	public JMenuBar createJMenuBar() {
		JMenuBar bar = new JMenuBar();
		JMenu menu = new JMenu("文件");
		JMenuItem saveItem = new JMenuItem("保存");
		saveItem.setActionCommand("save");
		JMenuItem openItem = new JMenuItem("打开");
		openItem.setActionCommand("open");
		menu.add(saveItem);
		menu.add(openItem);

		bar.add(menu);

		// 给菜单选项添加动作监听器
		ActionListener alis = new MyListener();
		saveItem.addActionListener(alis);
		openItem.addActionListener(alis);

		return bar;
	}

	public JPanel cerateLeft() {
		// 创建三个JPanel
		JPanel left = new JPanel();
		// 设置背景颜色
		left.setBackground(new Color(215, 215, 215));
		// 设置大小
		Dimension dim = new Dimension(80, 100);
		left.setPreferredSize(dim);

		// 在左边添加形状选择按钮
		String[] items = { "直线", "矩形", "椭圆" };
		String[] commands = { "line", "rect", "oval" };
		for (int i = 0; i < items.length; i++) {
			JRadioButton btn = new JRadioButton(items[i]);
			// 设置按钮的动作命令
			btn.setActionCommand(commands[i]);
			// 分为同一个组
			group.add(btn);
			if (i == 0) {// 设置第一个被选中
				btn.setSelected(true);
			}
			left.add(btn);

		}
		return left;

	}

	public JPanel createCenter() {
		// center需要在改变的时候重新绘制数据，所以要创建MyPanel类的对象
		center = new MyPanel();
		center.setBackground(Color.WHITE);
		return center;
	}

	public JPanel createBottom() {
		JPanel bottom = new JPanel();
		bottom.setBackground(new Color(215, 215, 215));
		bottom.setPreferredSize(new Dimension(100, 80));
		return bottom;
	}

	// 内部类
	class MyPanel extends JPanel {
		// 重写绘制JPanel的方法
		// JPanel发生改变的时候，此方法会自动调用
		// 在这个时候可以将需要的数据重新绘制在JPanel上
		public void paint(Graphics g) {
			super.paint(g);
			// 如果监听器存在，就获得保存图像数据的二维数组
			if (lis != null) {
				int[][] colors = lis.colors;
				// 如果二维数组存在，证明至少绘制过一次图像
				if (colors != null) {
					// 遍历二维数组
					for (int i = 0; i < colors.length; i++) {
						for (int j = 0; j < colors[i].length; j++) {
							// 得到点的颜色
							Color c = new Color(colors[i][j]);
							// 绘制一个点
							g.setColor(c);
							g.drawLine(j, i, j, i);

						}
					}
				}
			}

		}
	}

	// 动作监听器
	class MyListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			// 获得动作命令
			String command = e.getActionCommand();
			System.out.println(command);
			if (command.equals("save")) {
				try {
					// 将内存中的形状队列保存到文件中
					File file = new File(path);
					FileOutputStream fos = new FileOutputStream(file);

					DataOutputStream dos = new DataOutputStream(fos);
					if (lis != null) {
						int[][] colors = lis.colors;
						// 如果二维数组存在，证明至少绘制过一次图像
						if (colors != null) {
							// 先写出二维数组的大小
							dos.writeInt(lis.colors.length);// 高度
							dos.writeInt(lis.colors[0].length);// 宽度
							for (int i = 0; i < lis.colors.length; i++) {
								for (int j = 0; j < lis.colors[i].length; j++) {
									int color = lis.colors[i][j];
									dos.writeInt(color);

								}
							}
							dos.flush();
							fos.close();

						}
					}

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

			}
			if (command.equals("open")) {
				try {
					// 建立文件输入流
					File file = new File(path);
					FileInputStream fis = new FileInputStream(file);

					DataInputStream dis = new DataInputStream(fis);
					// 读取高度和t宽度
					int height = dis.readInt();
					int width = dis.readInt();
					// 定义数组来存放读取的数据
					lis.colors = new int[height][width];
					for (int i = 0; i < lis.colors.length; i++) {
						for (int j = 0; j < lis.colors[i].length; j++) {
							lis.colors[i][j] = dis.readInt();
						}
					}

					fis.close();
					//刷新界面，将数据绘制在界面上
					center.repaint();
					
				} catch (Exception ef) {
					ef.printStackTrace();
				}
			}

		}
	}
}

 

package com.iteye.com;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;

import javax.swing.ButtonGroup;
import javax.swing.JPanel;

/**
 * 画图板的监听器，继承了鼠标适配器抽象类
 * 鼠标适配器抽象类实现了MouseLIstener,MouseMotionListener,MouseWheelListener 只需要重写要是用到的方法
 * 
 * @autho
 */
public class DrawListener extends MouseAdapter {

	private int x1, y1, x2, y2;
	private Color c = Color.RED;
	private Graphics g;
	private ButtonGroup group;
	private String command;// 动作命令，作为要绘制的形状类型 line直线 rect矩形 oval椭圆
	JPanel center;
	int[][] colors;

	public DrawListener(ButtonGroup group) {
		this.group = group;
	}

	/**
	 * MouseEvent :鼠标事件对象，可以得到触发事件的对象
	 */
	public void mousePressed(MouseEvent e) {
		// 获得事件源对象:鼠标在那个组件上触发事件，这个对象必须要是添加了监听器的
		// 在本例中是给Center添加的监听器，事件源一定是Center
		center = (JPanel) e.getSource();
		// 只需要绘制在center上，所以需要从Center上取画布
		// 获得center组件在屏幕上占据的区域
		g = center.getGraphics();

		// 获得要绘制的形状
		// 得到按钮组中被选中的按钮的动作命令
		command = group.getSelection().getActionCommand();

		x1 = e.getX();
		y1 = e.getY();
	}

	public void mouseReleased(MouseEvent e) {
		x2 = e.getX();
		y2 = e.getY();
		if (command.equals("line")) {
			// 画直线
			g.drawLine(x1, y1, x2, y2);
		} else if (command.equals("rect")) {
			// 画矩形
			g.drawRect(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x1 - x2),
					Math.abs(y1 - y2));

		} else if (command.equals("oval")) {
			// 绘制椭圆
			g.drawOval(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x1 - x2),
					Math.abs(y1 - y2));
		}

		// 绘制完一个图形，就截取一次屏幕
		try {
			Robot robot = new Robot();
			// 定义要截取的矩形区域,
			// 由于要把center中的数据全部保存，
			// 所以矩形区域就是center在屏幕上占据的区域
			// 获得center左上角的点相对于屏幕的坐标
			Point point = center.getLocationOnScreen();
			// 获得center的宽度和高度
			Dimension dim = center.getSize();

			Rectangle rect = new Rectangle(point, dim);
			// 调用截取屏幕的方法
			BufferedImage img = robot.createScreenCapture(rect);

			// System.out.println("left-top:"+point.x+" "+point.y);
			// System.out.println("dimension:"+dim.width+" "+dim.height);

			// 根据图像大小定义一个二维数组，用来保存图像中的点
			// 图像坐标和数组下标要注意区分
			colors = new int[img.getHeight()][img.getWidth()];
			// 每种颜色都是有ARGB四个子节组成，每种颜色都可以用int表示
			for (int i = 0; i < colors.length; i++) {
				for (int j = 0; j < colors[i].length; j++) {
					// 将图像每个坐标点的颜色放到数组对应的下标位置
					colors[i][j] = img.getRGB(j, i);
				}
			}

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

	}
}

 

 

  二:   对象流保存(在JAVASE里面写过,就不再贴出来了)
   分析

1,将绘制的图形的基本属性定义成一个抽象类,每个图形都去继承它

2,使用队列来保存绘制的图像

3,在paint方法中遍历队列,将遍历出来的队列个数绘制出来(此处是绘制,不是添加到队列中  很容易搞错的);

4,对象流的打开与保存
    打开;
      先读取个数;
      遍历个数并转换成对象,再添加到队列中

    保存:
      先写图形的个数
      遍历队列中的个数--->将个数写出去
       

 

 JAVA随机存储流(RandomAccessFile)的应用      

JAVA核心技术I 对RandomAccessFile有描述,所以才决定学习一下这个类的使用,不看不知道,原来这个类有点高大上..........;

     RandomAccessFile类的实例支持对随机访问文件的读取和写入。随机访问文件的行为类似存储在文件系统中的一个大型 byte 数组。存在指向该隐含数组的光标或索引，称为文件指针；输入操作从文件指针开始读取字节，并随着对字节的读取而前移此文件指针。如果随机访问文件以读取/写入模式创建，则输出操作也可用；输出操作从文件指针开始写入字节，并随着对字节的写入而前移此文件指针。写入隐含数组的当前末尾之后的输出操作导致该数组扩展。

 

该文件指针可以通过 getFilePointer 方法读取，并通过 seek 方法设置。

RandomAccessFile实现了数据输入输出流的接口;可以随机存储硬盘的文件,但是来自网络的文件就不行

    RandomAccessFile的工作方式是，把DataInputStream和DataOutputStream结合起来，再加上它自己的一些方法，比如定位用的getFilePointer( )，在文件里移动用的seek( )，以及判断文件大小的length( )、skipBytes()跳过多少字节数。此外，它的构造函数还要一个表示以只读方式("r")，还是以读写方式("rw")打开文件

 

 

 

1, 第一个疑问;随机存储流在读写文件时如何定位

 

代码如下;

package 随机存储流;

import java.io.FileNotFoundException;
import java.io.RandomAccessFile;

/**
 * 随机存储流的测试,随机存储流不会删除前面的,会在后面添加
 * 
 * @author Administrator
 * 
 */
public class DemoRandomIO {

	public static void main(String[] args) {

		try {
			//实例化随机存储流,不需要创建文件的路径
			RandomAccessFile Raf = new RandomAccessFile("file", "rw");
			//创建一个字符串数组并初始化
			String[] name = new String[3];
			name[0] = "JAVA";
			name[1] = "android";
			name[2] = "C++";
			//遍历数组
			for(int i = 0;i<name.length;i++){
				//使用随机流将数组写出去
				Raf.writeUTF(name[i]);	
			}
			
			//添加元素
			Raf.seek(Raf.length());
			Raf.writeUTF("SSH");
			
			//使用seek将Raf.length()执行数组的第一个
			Raf.seek(0);
			
			//遍历使用偏移量来遍历,每移动一下就打印出数据
			while(Raf.getFilePointer()<Raf.length()){
				System.out.println(Raf.readUTF());
			}
					
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

 

运行结果;

JAVA
android
C++

 

 

2,++++++++随机存储流实现文件的复制

package 随机存储流;

import java.io.FileNotFoundException;
import java.io.RandomAccessFile;

/**
 * 随机存储流的测试,
 * 
 * @author Administrator
 * 
 */
public class DemoRandomIO {

	public static void main(String[] args) {

		try {
			//实例化随机存储流,不需要创建文件的路径
			RandomAccessFile Raf = new RandomAccessFile("file", "rw");
			//创建一个字符串数组并初始化
			String[] name = new String[3];
			name[0] = "JAVA";
			name[1] = "android";
			name[2] = "C++";
			//遍历数组
			for(int i = 0;i<name.length;i++){
				//使用随机流将数组写出去
				Raf.writeUTF(name[i]);	
			}
			
			//添加元素
			Raf.seek(Raf.length());
			Raf.writeUTF("SSH");
			
			//使用seek将Raf.length()执行数组的第一个
			Raf.seek(0);
			
//			//遍历
//			while(Raf.getFilePointer()<Raf.length()){
//				System.out.println(Raf.readUTF());
//			}
			System.out.println(Raf.readUTF());
			System.out.println(Raf.readUTF());
			System.out.println(Raf.readUTF());
			
			//文件复制
			System.out.println("开始复制.......");
			Raf.seek(0);//将文件指向开始的地方
			//定义复制的文件
			RandomAccessFile fileCopy = new RandomAccessFile("fileCopy", "rw");
			//获取Raf文件长度
			int len  = (int)Raf.length();
			//根据文件的长度创建字节数组
			byte[] by = new byte[len];
			//将Raf的文件内容读到数组中
			Raf.readFully(by);
			//将写到InRaf文件中
			fileCopy.write(by);
			System.out.println("复制完毕.....");
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

 

 运行结果:

 

JAVA
android
C++
开始复制.......
复制完毕.....

 

怎么知道filecopy文件是否已经真的全部复制Raf文件中的数据,遍历filecopy文件中的数据

 

                         fileCopy.seek(0);
			System.out.println("复制的;"+fileCopy.readUTF());
			System.out.println("复制的;"+fileCopy.readUTF());
			System.out.println("复制的;"+fileCopy.readUTF());
			

 运行结果;

复制的;JAVA
复制的;android
复制的;C++

 

 

3,+++++实现多线程同时下载,将文件内容分割成几小块下载,代码如下

 

package 随机存储流;
/**
 * 随机数据存储流多线程下载文件的简单实现,主窗口
 */
import java.io.File;
import java.io.FileNotFoundException;
import java.io.RandomAccessFile;

public class DemoTest {
	public static void main(String[] args) {
		
		try {
			// 实例化随机存储流,创建文件的路径
			File file = new File("F:Raf.txt");
			RandomAccessFile Raf = new RandomAccessFile("file", "rw");
			//设置文件的大小
			Raf.setLength(22*3);
			Raf.close();
			// 创建一个字符串数组并初始化
			String[] name = new String[3];
			name[0] = "JAVA";
			name[1] = "android";
			name[2] = "C++";
			
			//使用多线程来下载
			for(int i = 0;i<name.length;i++){
				DemoTestThread th = new DemoTestThread(1024*i,name[i].getBytes());
				th.start();
			}
			System.out.println("下载完毕...");

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

 

package 随机存储流;

import java.io.FileNotFoundException;
import java.io.RandomAccessFile;

/**
 * 创建线程
 * 
 * @author Administrator
 * 
 */
public class DemoTestThread extends Thread {
	// 创建线程需要文件大小和文件内容
	private int len;
	private byte[] con;
	private boolean islive = true;
    //创建构造方法
	public DemoTestThread(int len, byte[] con) {
		this.len = len;
		this.con = con;
	}

	@Override
	public void run() {
		while(islive){
		try {
			RandomAccessFile Raf = new RandomAccessFile("F:Raf.txt", "rw");
		     Raf.seek(len);
		     Raf.write(con);
		     Thread.sleep(50);
		} catch (Exception e) {
			islive =false;
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	}
}

 

 运行结果:

创建的文件

 

 文件中的内容