java的IO流

import java.io.File;
import java.io.RandomAccessFile;
import java.io.IOException;
import java.util.Arrays;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.DataOutputStream;
import java.io.DataInputStream;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;


public class FileOperation{
	
	public static void main(String[] args) throws IOException,ClassNotFoundException{
		//randomAccessFile();
		//randomAccessFile2();
		//fileInputStream();
		//fileOutputStream();
		//dataOutputStream();
		//dataInputStream();
		//bufferedInputStream(); 
		//batchBufferInputStream();
		//inputStreamReader();
		//bufferedReader();
		//objectOutputStream();
		ioException(true);
	}
	
	/**
		手动抛出异常
	*/
	public static void ioException(boolean flag) throws IOException{
		if(flag){
			throw new IOException("手动的创建一个IO异常");
		}
	}
	
	/**
		对象的序列化，反序列化
		就是讲object对象转换为byte序列的过程，反之就叫反序列化
		关键字：
			transient :修饰的object的属性不会被序列化
	*/
	
	public static void objectOutputStream() throws IOException,ClassNotFoundException{
		//序列化
		Friend friend = new Friend("李青",19,"男");
		ObjectOutputStream oos = new ObjectOutputStream(
			new FileOutputStream("D:\\java\\txt\\javaSE\\File\\IOFile\\李青.dat"));
			
		oos.writeObject(friend);
		oos.flush();
		oos.close();
		System.out.println(friend);
		
		//反序列化
		ObjectInputStream ois = new ObjectInputStream(
			new FileInputStream("D:\\java\\txt\\javaSE\\File\\IOFile\\李青.dat"));
		Friend f = (Friend) ois.readObject();
		ois.close();
		System.out.println(f);	
		
	}
	
	/**
		字符流的过滤器 BufferedReader/BufferedWriter
		readLine() ---> 一次读一行
		write() ------> 一次写一行
	*/
	public static void bufferedReader()  throws IOException{
		//输入流
		BufferedReader br = new BufferedReader(
			new InputStreamReader(
				new FileInputStream("D:\\java\\txt\\javaSE\\File\\IOFile\\刀客传奇.txt")));
		//输出流
		BufferedWriter bw = new BufferedWriter(
			new OutputStreamWriter(
				new FileOutputStream("D:\\java\\txt\\javaSE\\File\\IOFile\\新刀客传奇.txt")));
		//读写操作
		String line;
		while((line = br.readLine()) != null){
			System.out.println(line); //一次读一行并不能识别换行
			bw.write(line);
			bw.newLine(); //换行
			bw.flush();
		}
		br.close();
		bw.close();
		
	}
	
	
	/**
		字符流	Reader/Writer	-操作的是文本文件
		java的文本（char）是16位无符号整数，是字符的unicode编码
		文件是 byte byte byte ……的数据序列
		文本文件是文本（char）序列按照某种编码方案（utf-8/utf-16be）序列化为byte的存储
		字符流对字符的处理，一次处理一个字符，字符的底层仍然是基本的字节序列
		InputStreamReader 完成byte流解析为char流，按照编码解析
		OutputStreamWriter 提供char流到byte流，按照编码处理
	*/
	
		public static void inputStreamReader() throws IOException{
			FileInputStream fis = new FileInputStream("D:\\java\\txt\\javaSE\\File\\IOFile\\HelloWorld.txt");
			//默认是GBK 编码
			InputStreamReader isr = new InputStreamReader(fis,"utf-8");
			int b ;
			while((b = isr.read()) != -1){
				System.out.print((char)b);
			}
			isr.close();
		}
	
	/**
		bufferedInputStream/bufferedOutputStream
		这两个流类为IO提供了带缓存区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，
		缓冲区的容量装满后，执行写入/读取 操作，这种模式提高了IO的性能，
	*/
	
	/*批量缓冲*/
	public static void batchBufferInputStream() throws IOException{
		
		byte[] bytes = new byte[1 * 1024];
		FileOutputStream fos = new FileOutputStream("D:\\java\\txt\\javaSE\\File\\IOFile\\药典2.txt");
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		FileInputStream fis = new FileInputStream("D:\\java\\txt\\javaSE\\File\\IOFile\\2010版药典电子版.exe");
		BufferedInputStream bis = new BufferedInputStream(fis);
		int length;
		long start = System.currentTimeMillis();
		while((length = bis.read(bytes,0,bytes.length))!= -1){
			bos.write(bytes,0,length);
			bos.flush();
		}
		bis.close();
		bos.close();
		long end = System.currentTimeMillis();
		System.out.println("批量缓冲的毫秒数："+(end - start)); //74
		
	}
	
	/*单字节缓冲*/
	public static void bufferedInputStream() throws IOException{
		FileOutputStream fos = new FileOutputStream("D:\\java\\txt\\javaSE\\File\\IOFile\\药典1.txt");
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		FileInputStream fis = new FileInputStream("D:\\java\\txt\\javaSE\\File\\IOFile\\2010版药典电子版.exe");
		BufferedInputStream bis = new BufferedInputStream(fis);
		int a;
		long start = System.currentTimeMillis();
		while((a = bis.read())!= -1){
			bos.write(a);
			/**
				当buffered容量到达上限时，会触发真正的磁盘写入。而另一种触发磁盘写入的办法就是调用flush()了
			*/
			bos.flush();
		}
		bis.close();
		bos.close();
		long end = System.currentTimeMillis();
		System.out.println("单字节缓冲的毫秒数："+(end - start)); //41322
	}
	
	/**
		DataInputStream/DataOutputStream
		对流的功能的扩展，可以更加方便的读取int、long、char 等类型的数据
	*/
	public static void dataInputStream() throws IOException{
		FileInputStream fis = new FileInputStream("D:\\java\\txt\\javaSE\\File\\HelloIO.txt");
		DataInputStream dis = new DataInputStream(fis);
		int a = dis.readInt();
		String b = dis.readUTF();
		String c = dis.readUTF();
		System.out.println(a+","+b+","+c);
		dis.close();
	}
	
	public static void dataOutputStream() throws IOException{
		FileOutputStream fos = new FileOutputStream("D:\\java\\txt\\javaSE\\File\\HelloIO.txt");
		DataOutputStream dos = new DataOutputStream(fos);
		dos.writeInt(666);
		dos.writeUTF("a");
		dos.writeUTF("居安思危");
		
		dos.close();
	}
	
	
	/**
	IO流基础：
		输入流 和 输出流
		一个从外界进入到程序方向，通常我们读取外界数据时，成为输入
		inputStream 和 outputStream 是所有输入流输出流的父接口
		inputStream 抽象了应用程序读取数据的方式
		outputStream 抽象了应用程序写出数据的方式
	*/
	public static void fileInputStream() throws IOException{
		FileInputStream fis = new FileInputStream("D:\\java\\txt\\javaSE\\File\\HelloJava.txt");
		int b = 0;
		while((b = fis.read()) != -1){
			System.out.print((char)b+"  ");
		}
		System.out.println();
		System.out.println("---------------------------------------------");
		fis = new FileInputStream(new File("D:\\java\\txt\\javaSE\\File\\HelloWorld.txt"));
		byte[] bytes = new byte[60];
		/**从fis中读取字节，放入bytes中，返回的是读到的字节个数 
		int a = fis.read(bytes);
		System.out.println(a);
		*/
		int a = 0;
		while((a = fis.read(bytes)) != -1){
			System.out.println(new String(bytes,"gbk"));
		}
		fis.close();
	}
	
	public static void fileOutputStream() throws IOException{
		/**
			如果改文件不存在则直接创建，如果存在就删除在创建【在构造函数后面添加true参数就不会删除文件】
			
		*/
		FileOutputStream fos = new FileOutputStream("D:\\java\\txt\\javaSE\\File\\HelloIO.txt");
		FileInputStream fis = new FileInputStream(new File("D:\\java\\txt\\javaSE\\File\\HelloWorld.txt"));
		byte[] bytes = new byte[82];
		while(fis.read(bytes) != -1){
			fos.write(bytes);
		}
		fis.close();
		fos.close();
	}
	
	
	
	
	//文件随机访问类 ，可以访问文件的任意位置，访问包括读和写的操作。基于指针操作。
	
	public static void randomAccessFile2() throws IOException{
		File fileRead = new File("D:\\java\\txt\\javaSE\\File\\HelloWorld.txt");
		File fileWrite = new File("D:\\java\\txt\\javaSE\\File\\HelloJava.txt");
		RandomAccessFile read = null;
		RandomAccessFile write = null;	
		read = new RandomAccessFile(fileRead,"rw");
		write = new RandomAccessFile(fileWrite,"rw");
		byte[] bytes = "路人借问遥招手".getBytes("gbk");
		write.write(bytes);
		write.seek(0);
		byte[] buf = new byte[(int)fileWrite.length()];
		write.read(buf);
		read.write(buf);
		System.out.println(new String(buf));
		read.close();
		write.close();
	}
	
	
	public static void randomAccessFile() throws IOException{
		File fileRead = new File("D:\\java\\txt\\javaSE\\File\\HelloWorld.txt");
		File fileWrite = new File("D:\\java\\txt\\javaSE\\File\\HelloJava.txt");
		
		RandomAccessFile read = null;
		RandomAccessFile write = null;
			System.out.println(fileRead.exists()+"\t"+fileRead.length());	
			read = new RandomAccessFile(fileRead,"rw");
			/**
			System.out.println(read.getFilePointer());	//获取指针位置
			read.write('人'); //一个字符占两个字节（16），而write只能写入一个字节，会把后8为写进去
			System.out.println(read.getFilePointer());
			read.write('p');
			*/
			System.out.println(read.getFilePointer());
			
			int i = 0x7fffffff; //java最大的整数
			System.out.println("java最大的整数:"+i);
			read.write(i>>>24);
			read.write(i>>>16);
			read.write(i>>>8);
			read.write(i);
			System.out.println(read.getFilePointer());
			
			byte[] bytes = "独钓罕见雪".getBytes("gbk");
			read.write(bytes);
			System.out.println(read.getFilePointer());
			
			//读文件，必须把指针移到头部
			read.seek(0);
			read.writeInt(12);
			//一次性读取
			byte[] buf = new byte[(int)read.length()];
			read.read(buf);
			String str = new String(buf);
			System.out.println(str);
			
			read.close();
	}
	
	
	
	
	
	
	
}

 

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.io.FileFilter;
public class fileDemo{
	
	public static void main(String [] args){
		//fileMethod();
		//fileApi();
		//fileApiTwo();
		//fileFilter();
		//System.out.println(fibonacci(53));
	}
	
	//使用递归实现 斐波那契数列： 1 1 2 3 5 8 13 21 34 ...输入 n,就输出到第n个斐波那契数
	public static int fibonacci(int num){
		if(num <= 0){return 0;}
		if(num == 1 || num == 2){
			return 1;
		}else{
			return fibonacci(num - 1) + fibonacci(num - 2);
		}
	}
	
	
	//FileFilter 文件过滤
	public static void fileFilter(){
		File file = new File("D:\\java\\txt\\javaSE\\File");
		File [] files = file.listFiles(new FileFilter(){
			public boolean accept (File file){
				return file.getName().equals("fileDemo.java");
			}
		});
		System.out.println(Arrays.toString(files));
	}
	
	public static void fileApiTwo(){
		String parentDirectory = "D:\\java\\txt\\javaSE\\File";
		//mkdir() 和 mkdirs() 都是创建目录，mkdir只能创建一级目录，而mkdirs可以创建多级目录
		File file = new File(parentDirectory+File.separator+"Directory");
			if(!file.exists()){
				file.mkdir();
				System.out.println("文件是否创建成功："+file.exists());
			}
		//手动在文件里面创建3个文件 one.txt two.txt three.txt
		// File [] listFiles() 返回路径名字所有的子目录及子文件。
		File [] files = file.listFiles();
		System.out.println(Arrays.toString(files));
		
		//好了，把他们全部删除.注意，文件夹里面有文件时，不能直接删除
		delAllDirectory(file);
	}
	
	//删除所有文件的递归方法
	public static void  delAllDirectory(File path){
		if(!path.exists() || !path.isDirectory() ){
			return ;
		}
		File[] files = path.listFiles();
		if(null != files){
			for(File f : files){
				if(f.isDirectory()){
					delAllDirectory(f);
				}
				f.delete();
			}
			path.delete();
		}
	}
	
	
	/**
		File  文件操作对象
				通常只用于表示文件的信息（大小、名称等），不能对文件的内容进行访问。
	*/
	public static void fileApi(){
		String parentDirectory = "D:\\java\\txt\\javaSE\\File";
		File file = new File(parentDirectory+File.separator+"HelloWorld.txt");
		System.out.println(file);
		//File(fileName)	获取文件（目录）对象，如果不存在时返回FALSE，大小为0
		System.out.println("文件是否存在："+file.exists());
		System.out.println("文件大小："+file.length());
		
		file = new File(parentDirectory,"HelloJava.txt");
		//文件不存在时，创建
		try{
			if(!file.exists()){
				file.createNewFile();
			}
		}catch(IOException e){
			e.printStackTrace();
		}
		System.out.println("文件创建后是否存在："+file.exists());
		System.out.println("文件大小："+file.length());
		//文件存在时，删除
			if(file.exists()){
				file.delete();
			}	
		System.out.println("文件删除后是否存在："+file.exists());
		System.out.println("文件大小："+file.length());
		
	}
	
	public static void fileMethod(){
		String parentDirectory = "D:\\java\\txt\\javaSE\\File";
		File file = new File(parentDirectory);
		ystem.out.println(file.exists());
		System.out.println();
		System.out.println(file.getName());
		System.out.println(file.canWrite());//是否可写
		System.out.println(file.canRead());//是否可读
		System.out.println(file.getAbsolutePath());//获取绝对路径
		System.out.println(file.length());//文件字节大小
		System.out.println(new Date(file.lastModified()));//最后修改时间
		System.out.println(file.getParentFile());//上级目录
		System.out.println(file.isHidden());//是否隐藏文件
		System.out.println(file.isAbsolute());//判断是否绝对路径
	}
	
}