一、关于IO

1.IO简介

    所谓IO，也就是Input（读、输入）与Output（写、输出）的缩写
    java.io包提供了用于系统的输入和输出，通过数据流，序列化和文件系统。

    IO流分为字节流与字符流

2.File

  概述:java.io.File类是 文件 和目录(文件夹)路径名的抽象表示形式，在java中，不管是文件还是文件夹都是叫做File对象

          File类保存文件或目录的各种元数据信息，包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名，判断指定文件是否存在、

    获得当前目录中的文件列表，创建、删除文件和目录等方法。

  根据一个路径得到File对象：File file = new File("E:\\demo\\a.txt");

 创建目录：

    File类中有两个方法可以用来创建文件夹：

    a.mkdir( )方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还

     不存在，该文件夹不能被创建。

    b.mkdirs()方法创建一个文件夹和它的所有父文件夹。

3.递归

  例子:利用File以及递归算法得到某个路径下所有的文件并打印

package com.zking.io;

import java.io.File;

public class Recursion {
	public static void main(String[] args) {
		   File f=new File("D:\\桌面文件\\桌面\\测试文件夹");//右键属性查看路径
		   read(f);
	}
	
	public static void read(File f){
		   if(f.isDirectory()){//如果是文件夹
			     //列出该文件夹下所有的文件
			     File fs[]=f.listFiles();
			     if(fs.length>0){//有子目录或者子文件
			    	   for (File file : fs) {
						    if(file.isDirectory()){
						    	  read(file);
						    }else{
						    	  System.out.println(file.getAbsolutePath());
						    }
					   }
			     }else{//没有子目录或者子文件
			    	   System.out.println(f.getAbsolutePath());
			     }
		   }else{//如果是文件
			     System.out.println(f.getAbsolutePath());
		   }
	}
	
	
}

4.使用字符流(FileReader、BufferedWriter)和字节流(FileInputStream)读写数据（例子）

   在程序中一个字符等于两个字节，那么java提供了Reader(字符输入流)、Writer(字符输出流)两个专门操作字符流的类。

   字节流与字符流的区别

   字节流和字符流使用是非常相似的，那么除了操作代码的不同之外，还有哪些不同呢？

  字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的 

  字节流在操作文件时，即使不关闭资源（close方法），文件也能输出，但是如果字符流不使用close方法的话，则不会输出任何内容，

    说明字符流用的是缓冲区，并且可以使用flush方法强制进行刷新缓冲区，这时才能在不close的情况下输出内容

/**
 * 需求：
 * 指定一个文件：
 * 	如果这个文件存在，则读取这个文件中的内容
 *      如果这个文件不存在，则写内容到这个文件中
 * 用字节流
 *
 */
public class TestFileByStream {
	public static void main(String[] args) {
		File file=new File("C:\\Users\\Administrator.USER-20170515AI\\Desktop\\test.txt");
		//判断 该文件是否存在
		if(!file.exists()){//不存在：创建文件 写内容
			System.out.println("该文件不存在,正在创建...");
			//创建文件
			try {
				boolean b=file.createNewFile();
				if(b){
					System.out.println("创建成功了...");
					//写内容(字节流 )
					FileOutputStream fos=new FileOutputStream(file);
					fos.write("这是txt文件的内容".getBytes());
					fos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			//file.mkdir();//创建文件夹
		}else{//存在：读取内容
			System.out.println("该文件存在,文件内容如下：");
			//读
			try {
				FileInputStream fis=new FileInputStream(file);
				byte b[]=new byte[1024];
				int len=0;
				while((len=fis.read(b))!=-1){
					//将字节数组转成字符串
					String s=new String(b, 0, len);
					System.out.println(s);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
	}
}

/**
 * 需求：
 * 指定一个文件：
 * 判断:如果这个文件存在，则读取这个文件中的内容
 *     如果这个文件不存在，则写内容到这个文件中
 * 字符流
 */
public class TestFile {
	   public static void main(String[] args) {
		      File file=new File("test1.txt");//如果没有指定目录,则文件会在项目的跟目录下
			  //判断 该文件是否存在
			  if(!file.exists()){//不存在：创建文件 写内容
					System.out.println("该文件不存在,正在创建...");
					//创建文件
					try {
						boolean b=file.createNewFile();
						if(b){
							System.out.println("创建成功了...");
							//写内容
							FileWriter fw=new FileWriter(file);
							fw.write("文件test1.txt的内容");
							fw.close();
						}
					} catch (IOException e) {
						e.printStackTrace();
					}
					//file.mkdir();//创建文件夹
			   }else{//存在：读取内容
					System.out.println("该文件存在,文件内容如下：");
					//读
					try {
						FileReader fr=new FileReader(file);
						char cbuf[]=new char[1024];
						int len=0;
						while((len=fr.read(cbuf))!=-1){
							//字符数组转成字符串
							String s=new String(cbuf, 0, len);
							System.out.println(s);
						}
					} catch (FileNotFoundException e) {
						e.printStackTrace();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
	}
}

5.缓冲流

     BufferedReader:缓冲字符输入流  读

  BufferedWriter:缓冲字符输出流  写

6.装换流(字节流转成字符流)

/**
 * 转换流
 * 实现文件复制
 * 1.来一个文件（字节流）
 * 2.读文件
 * 3.写文件
 * @author Administrator
 *
 */
public class TestCopyChange {
	public static void main(String[] args) {
		File file=new File("test.txt");
		File fileOut=new File("C:\\Users\\Administrator\\Desktop\\a");
		try {
			//获取字节文件输入流
			FileInputStream fis=new FileInputStream(file);
			//使用字符缓冲输入流
			BufferedReader br=new BufferedReader(new InputStreamReader(fis));
			String s=br.readLine();
			System.out.println(s);
			
			//打印流
			PrintWriter pw=new PrintWriter(file);
			pw.write("新内容");
			pw.close();
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

7.文件复制(例子)

/**
 * 实现文件复制
 * 1.来一个文件（字节流）
 * 2.读文件
 * 3.写文件
 * @author Administrator
 *
 */
public class TestCopy {
	public static void main(String[] args) {
		File file=new File("视频1.webm");
		File fileOut=new File("C:\\Users\\Administrator\\Desktop\\a");
		try {
			//文件字节输入流(读)
			FileInputStream fis=new FileInputStream(file);
			//文件字节缓冲输入流
			BufferedInputStream bis=new BufferedInputStream(fis,10);
			
			//文件字节输出流(写)
			FileOutputStream fos=new FileOutputStream(fileOut+"\\"+file.getName());
			//文件字节缓冲输出流
			BufferedOutputStream bos=new BufferedOutputStream(fos);
			int len=0;
			byte[] b=new byte[1024];
			//获取系统时间
			long before=System.currentTimeMillis();
			//没有使用缓冲流
//			while((len=fis.read(b))!=-1){
//				//写
//				fos.write(b, 0, len);
//			}
			
			//使用缓冲流
			while((len=bis.read(b))!=-1){
				bos.write(b, 0, len);
			}
			bos.close();
			bis.close();
			long after=System.currentTimeMillis();
			System.out.println("复制OK:"+(after-before));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

8.序列化和反序列化（例子）

//将一个学生对象 序列化 以及 反序列化
public class Temp {
	public static void main(String[] args) throws Exception{
		   /**
		    * 序列化
		    */
            //1.实例化对象	
		    Student stu=new Student(1,"admin","女");

            //2.创建文件保存对象
//		    File f=new File("E:\\test1\\d.txt");
//		    f.createNewFile();//创建文件
//          /**写**/
//	        FileOutputStream fos=new FileOutputStream(f);
//          BufferedOutputStream bos=new BufferedOutputStream(fos);
//          ObjectOutputStream oos=new ObjectOutputStream(bos);
//		    oos.writeObject(stu);//保存到文件
//		    oos.close();//关闭流
//		    bos.close();
//		    fos.close();
//		    System.out.println("保存完毕");
		
		
		   /**
		    * 反序列化:把硬盘的对象读到内存中
		    */
		    File f=new File("E:\\test1\\d.txt");
            /**读**/
	        FileInputStream fis=new FileInputStream(f);
            BufferedInputStream bis=new BufferedInputStream(fis);
            ObjectInputStream ois=new ObjectInputStream(bis);	
		    Object o=ois.readObject();
		    Student s=(Student)o;
		    System.out.println(s);
		    ois.close();//关闭流
		    bis.close();
		    fis.close();
		
		
	}	
}

序列化是将对象状态转换为可保持或传输的格式的过程。
反序列化是将流转换为对象，这两个过程结合起来，可以轻松地存储和传输数据。

序列化：将一个对象从内存当中 转换到介质（存在硬盘上的介质）

反序列化：将对象从介质转换为内存里面的对象的过程称为反序列化

最后，这些知识可以了解下（如有时间，以后会补充）

a.随机文件读写(多线程下载与断点下载)

b.开源库

如果有错误的地方，欢迎大家指出。