JAVA IO 专题

首先看一下常用的几种编码方式

public class EncodeDemo
{
	public static void main(String[] agrs)throws IOException
	{
		String s="中国ABC";
		byte[] byte1=s.getBytes(); //默认采用项目的UTF-8编码
		byte[] byte2=s.getBytes("GBK");//显示指定编码方式为GBK
		byte[] byte3=s.getBytes("UTF-16be");
 		for(byte b:byte1)
		{
			/**
			 * 把字节转换成int以十六进制的方式显示
			 * 默认采用项目的编码，此处使用UTF-8，得到的结果为e4 b8 ad e5 9b bd 41 42 43 
			 *可见采用utf-8编码，中文占用三个字节，英文占用一个字节
			 */
			System.out.print(Integer.toHexString(b & 0xff)+" ");
		}
 		System.out.println();
 		for(byte b:byte2)
		{
			/**
			 * 把字节转换成int以十六进制的方式显示，高位三个字节补0
			 * 显示指定编码方式为GBK，，得到的结果为d6 d0 b9 fa 41 42 43
			 * 可见采用GBK编码，中文占用三个字节，英文占用一个字节
			 */
			System.out.print(Integer.toHexString(b & 0xff)+" ");
		}
 		System.out.println();
 		for(byte b:byte3)
		{
			/**
			 * java是双字节编码utf-16be
			 * 把字节转换成int以十六进制的方式显示，高位三个字节补0
			 * 显示指定编码方式为UTF-16be，得到的结果为4e 2d 56 fd 0 41 0 42 0 43
			 * 可见采用UTF-16be编码，中文占用两个字节，英文也占用两个字节
			 */
			System.out.print(Integer.toHexString(b & 0xff)+" ");
		}
 		System.out.println();
 		/*
 		 * 字节数组转换成字符串，必须与之前的转换采用相同的编码方式，不然会出现乱码
 		 */
 		String s1 = new String(byte1); 
 		System.out.println(s1); //中国ABC,采用默认的项目编码格式
 		String s2 = new String(byte2);
 		System.out.println(s2);//�й�  出现乱码，因为byte2用的是GBK编码，转换成字符串时用得默认的UTF-8
 		String s3 = new String(byte2,"GBK");
 		System.out.println(s3);//中国ABC ，显示指定GBK编码方式，便不会出现乱码
	}
	
}

通过这个例子可以看出，常用的编码方式有UTF-8，汉字编码站三个字节，英文字母编码占用1个字节； ＧＢＫ编码，中文占用两个字节，英文字母占用一个字节；java 是双字节UTF-16be编码，这种编码方式中文和英文都占用两个字节，在字符串与字节进行转换时，默认采用项目指定的编码方式，还要注意双向转换时，编码方式要相同，不然会出现乱码。

File类的使用：

java.io.File类用于表示文件或目录，它只用于表示文件或目录的信息（名称，大小等），不能用于文件内容的访问

public class FileDemo {
	public static void main(String[] args)
	{
		/*
		 * 了解几种常用的构造函数
		 */
		File file = new File("F:\\开心");//注意：路径要使用双斜杠或者反斜杠
		System.out.println(file);
		File file2 = new File("F:\\开心","开心1.txt");
		File file3 = new File(file2,"开心2.txt");
		if(!file.exists())
		{
			/*
			 * 如果目录不存在，则创建目录，mkdirs()可用于创建多级目录
			 * file.createNewFile()用于创建文件
			 */
			file.mkdir(); 
		}
		else
		{
			file.delete();
		}
		/*
		 * File类的几种常用API
		 */
		System.out.println(file.isFile());
		System.out.println(file.isDirectory());
		System.out.println(file); //打印文件的路径
		System.out.println(file.getAbsolutePath());//同样打印文件的完整路径
		System.out.println(file.getName());//打印文件或目录的名字
		System.out.println(file.getParent());//打印文件或目录的父目录
		System.out.println(file.getParentFile());
	}

}

以上介绍FIle类创建对象的几种方式以及常用API

包装对对文件或目录的几种常用操作，如过滤，遍历等

/<span style="font-family: Arial, Helvetica, sans-serif;">/包装File的一些常用操作，如过滤，遍历</span>

public class FileUtil
{
	/*
	 * 遍历目录下的所有文件和目录
	 */
	public static void listDirectory(File dir)throws IOException
	{
		if(!dir.exists())
		{
			throw new IllegalArgumentException("目录"+dir+"不存在");
		}
		if(!dir.isDirectory())
		{
			throw new IllegalArgumentException(dir+"不是目录");
		}
		/*
		String[] fileNames = dir.list(); //返回字符串数组，直接子的名称，不包含子目录下的内容
		for (String string : fileNames)
		{
			System.out.println(string);
		}*/
		File[] files = dir.listFiles();
		if(files!=null && files.length>0)
		{
			for (File file : files)
			{
				System.out.println(file);
				if(file.isDirectory()) //递归遍历
				{
					listDirectory(file);
				}
			}
		}
	} 
}

RandomAccessFile类：提供了对文件内容的访问，既可以读文件，也可以写文件。它提供对文件的随机访问，可以访问文件的任意位置

1>文件模式

    java文件，在硬盘上是byte byte byte...存储的，是数据的集合

2>打开文件

     打开文件有两种模式 “rw” 读写操作  “r”  只读操作

     RandomAccessFile  raf = new  RandomAccessFile  (file , "wr")，RandomAccessFile的随机访问是依靠文件指针实现的，打开文      件的默认指针位置prointer=0，即在文件的开头。读写操作会伴随着指针位置的移动。

3>写方法 

    raf.write(int), ----->只写一个字节，同时指针只想下一个位置，准备再次进行写操作

4>读方法

    raf.read()---->只写一个字节

5>文件读写完成后一定要关闭，不然会发生意想不到的错误

public class RandomAccessFileDemo {

	public static void main(String[] args)throws IOException
	{
		File file = new File("demo");
		if(!file.exists())
		{
			file.createNewFile();
		}
		RandomAccessFile raf = new RandomAccessFile(file, "rw");
		System.out.println(raf.getFilePointer()); //获取文件指针的位置,0
		raf.write('A');//只写入一个字节
		System.out.println(raf.getFilePointer()); //1
		int i = 0x7fffffff;//最大的整数
		//用write方法，每次只能写一个字节，写一个int需要写4次
		raf.write(i>>24);
		raf.write(i>>16);
		raf.write(i>>8);
		raf.write(i);
		//也可以直接写一个int,时机底层也是进行四次写操作
		raf.writeInt(i);
		System.out.println(raf.getFilePointer());
		String s="中国";
		byte[] byte1 = s.getBytes("gbk");
		raf.write(byte1);
		System.out.println(raf.length()); //文件的长度 13
		
		//读文件必须把文件指针移到文件的开始，也可以移到指定的位置进行读取
		raf.seek(0);
		byte[] buf = new byte[(int) raf.length()];
		raf.read(buf) ;//批量读取
		System.out.println(Arrays.toString(buf));
		//以十六进制的方式输出
		for (byte b : buf)
		{
			System.out.print(Integer.toHexString(b&0xff)+" ");
		}
		raf.close();
	}
}

I O流（输入流，输出流）

字节流：

1>

InputStream 抽象了应用程序读取数据的方式，读到程序中为输入

OutputStream  抽象了应用程序写出数据的方式

2>

EOF =End 读到-1就读到了文件的结尾

3>输入流基本方法

int b = in.read(); 读取一个字节填充到int低八位

in.read(byte[] buf)  ; 批量读取字节到字节数组中

in.read(byte[] buf , int start ,int size)

4>输出流基本方法

out.write(int b) // 写出int b 的低八位到流

out.write(byte[] b) ; 写出字节数组中的全部字节

out.write(byte[] b , int start ,int size) //从下表start开始，写出size个字节

5>具体实现类  

FileInputStream --->具体实现了在文件中读取数据

/*
 * 读取指定文件内容，以十六进制输出到控制台
 * 每读取10个字节换行,
 * 单字节读取，不适合大文件，效率很低
 */
public class IOUtil
{
	public static void printHex(String filename)throws IOException
	{
		FileInputStream fis = new FileInputStream(filename);
		int b;
		int i=1;
		while((b=fis.read())!=-1) //每次只读取一个字节
		{
			if(b<=0xf)
				System.out.print("0"); //如果只有第四位，则在前面补零
			System.out.print(Integer.toHexString(b)+" ");
			if(i++%10 == 0)
			{
				System.out.println();
			}
		}
		fis.close();
	}
	/*
	 * 批量读取，大区大文件时效率很高
	 * 常用的文件读取方式
	 */
	public static void printHexByByteArray(String filename)throws IOException
	{
		FileInputStream fis = new FileInputStream(filename);
		byte[] buffer = new byte[10*1024];
		/*
		 * 从fis中批量读取字节，放入到buf中，从第0个位置开始放，最多放buffer.length个字节
		 * 返回的是读取字节的个数
		 * 为了防止一次读不完一个文件，所以用到while循环，读到文件结尾为止
		 */
		int n;
		while((n=fis.read(buffer, 0, buffer.length))!=-1)
		{
			int k=1;
			for (int i=0;i<n;i++)
			{
				if(buffer[i]<=0xf)
					System.out.print("0");
				System.out.print(Integer.toHexString(buffer[i]&0xff)+" ");
				if(k++%10 == 0)
					System.out.println();
			}
		}
		System.out.println();
		fis.close();
	}
	/*
	 * 文件的copy
	 */
	public static void  copyFile(File srcFile,File destFile)throws IOException
	{
		if(!srcFile.exists())
			throw new IllegalArgumentException("原文件"+srcFile+"不存在");
		if(!srcFile.isFile())
			throw new IllegalArgumentException(srcFile+"不是文件");
		FileInputStream in = new FileInputStream(srcFile);
		FileOutputStream out = new FileOutputStream(destFile);
		byte[] buf = new byte[10*1024];
		int n;
		while((n=in.read(buf, 0, buf.length))!=-1)
		{
			out.write(buf, 0, n);
		}
	}

FileOutputStream --->继承了OutputStream，具体实现了向文件中写入byte数据的方法

public class FileOutputStreamDemo1 {
	public static void main(String[] args)throws IOException
	{
		//如果文件不存在，则创建该文件，如果该文件存在，则删除后再重新创建
		FileOutputStream fos = new FileOutputStream("demo.dat",true);
		/*
		 * 如果文件不存在，则创建该文件，如果文件存在，则以追加的方式向文件中写数据
		 * FileOutputStream fos = new FileOutputStream("demo.dat","true");
		 */
		fos.write('A');  //写一个字节
		String s = "中国";
		byte[] b = s.getBytes();
		fos.write(b); //写一个字节数组
		fos.close();
	}
	public static void  copyFile(File srcFile,File destFile)throws IOException
	{
		if(!srcFile.exists())
			throw new IllegalArgumentException("原文件"+srcFile+"不存在");
		if(!srcFile.isFile())
			throw new IllegalArgumentException(srcFile+"不是文件");
		FileInputStream in = new FileInputStream(srcFile);
		FileOutputStream out = new FileOutputStream(destFile);
		byte[] buf = new byte[10*1024];
		int n;
		while((n=in.read(buf, 0, buf.length))!=-1)
		{
			out.write(buf, 0, n);
		}
	}
}

DataInputStrean 和 DataOutputStrean  采用装饰模式，底层包装一个字节的读取操作

                out.writeInt(10);
		out.writeInt(-10);
		out.writeLong(10l);
		out.writeDouble(1.11);
		out.writeUTF("中国");
		out.writeChars("中国人");

DataInputStrean中有与之对应的read操作

带缓冲的字节流

BufferedInputStream 和BufferedOutputStream，为IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式，提高了IO的性能

public static void  copyFileBuffer(File srcFile,File destFile)throws IOException
	{
		if(!srcFile.exists())
			throw new IllegalArgumentException("原文件"+srcFile+"不存在");
		if(!srcFile.isFile())
			throw new IllegalArgumentException(srcFile+"不是文件");
		BufferedInputStream in = new BufferedInputStream(new FileInputStream(srcFile));
		BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(destFile));
		int n;
		while((n=in.read())!=-1)
		{
			out.write(n);
			out.flush();//必须写
		}
		in.close();
		out.close();
	}

还可以自己写一个copyFileByByte（）,经过比较，在进行较大的文件的copy工作时，自己创建byte[] 数组批量读取时，速度最快，带缓冲区的方式次之，当然可以想到，单个字节拷贝方式最慢。

字符流

1>认识文本和文本文件

java文本（char） 是16位无符号整数，是字符的Unicode编码（双字节编码）

文件是byte byte byte 。。 的序列集合

文本文件是文本按照一定的编码方式序列化为byte的存储方式

2>字符流（Reader Writer）

字符流的底层仍然是基本的字节序列

字符流的基本实现  ---->操作文本文本文件

   InputStreamReader -->完成byte流 解析为 char流 ，按照编码解析 

   OutputStreamWrite -->完成char流到byte流的解析，同样按照编码解析

public class FIRandFOW 
{

	public static void main(String[] args)throws IOException
	{
		FileInputStream in = new FileInputStream("C:\\unintall.log");
		/*
		 * 可以指定编码方式,自动识别换行
		 */
		InputStreamReader reader = new InputStreamReader(in,"GBk");
		FileOutputStream out = new FileOutputStream("C:\\unintall1.log");
		OutputStreamWriter writer = new OutputStreamWriter(out,"GBk");
		int a;
		/* 单个字符读取
		while((a = reader.read())!=-1)
		{
			System.out.print((char)a);
		}*/
		//批量读取
		char[] buffer = new char[8*1024];
		while((a=reader.read(buffer,0,buffer.length))!=-1)
		{
			writer.write(buffer, 0, a);
			writer.flush();//要加上刷新,才能及时将字符数组中的内容输出到文件
			String s = new String(buffer,0,a);
			System.out.println(s);
		}
	}
}

FileReader 和 FileWriter

同 InputStreamReader  和 OutputStreamWriter读取字符和字符数组方式一样，只是创建对象的方式不同

DataInputStrean
FileReader read = new FileReader(file);
FileWriter write = new FileWriter(file);  构造函数的参数是File对象

注：这种字符流操作存在一些缺陷，我们看到在构造方法中没办法指定编码方式，所以，读取文件的编码必须和文件的编码相同，不然会出现乱码

字符流的过滤器

BufferedReader 和 BufferedWriter PrintWriter
优点是能以行为单位进行文件的读取

public class BufferReaderWriter
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader reader = new BufferedReader(
				new InputStreamReader(new FileInputStream("C:\\unintall.log"),"GBK"));
	    //BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("C:\\unintall1.log")));
	    PrintWriter pwriter = new PrintWriter("C:\\unintall1.log");
	    String line;
	    /*
	    while((line = reader.readLine()) != null)
	    {
	    	writer.write(line);//不识别换行
	    	writer.newLine();//手动换行
	    	writer.flush();
	    	System.out.println(line);
	    }*/
	    /*
	     * 由于BufferedWriter创建对象比较复杂，并且不识别换行，所以用PrintWriter替代
	     */
	    while((line = reader.readLine()) != null)
	    {
	    	pwriter.println(line); //用该方法进行换行
	    	pwriter.flush();
	    	System.out.println(line);
	    }
	}

}

以上就是javaIO的基本类以及常用的操作，我们完全可以参照这篇文章对API中的其他IO类进行扩展学习

DataInputStrean