常见的流对象有几种？什么是字节流，什么是文件，什么是字符流?

File文件，字节输入流，字节输入流，字符输入流，字节输出流的详解

File文件概述
1.File类型：用于表示一个文件或者是文件夹的路径的对象(抽象路径名)
2.路径：用于描述文件或者是文件夹的所在路径的所在的字符串
3.路径分类:绝对路径和相对路径
4.绝对路径:从跟目录开始的路径，称为绝对路径，在window中盘符路径就是跟目录，在Linu目录中从根目录开始的路径就是绝对路径
5.相对路径：相对于某个路径而言的路径，相对于不同的路径，同样的相对路径，表达的是不同的路径
File文件的构造方法:
1.File(String path) 把字符的路径，封装成一个File对象
2.File(String parent,String child) 将父级路径和子级路径封装成File对象，其实就是描述的就是父级路径和子级路径封装的一个路经
3.File(File parent,String child) 将父级File对象和字级路径封装成一个File对象，其实就是在描述父级路径和资级路径封装的路径

public class FileDemo01 {
     public static void main(String[] args) {
    	 //将一个字符串串封装成一个file文件对象
	     File file = new File("x");
	     System.out.println(file);
	     
	     //将一个父级路径和子级路径封装成一个file文件，其实 就是描述的是父级和子级拼接后的路径
	     File file2 = new File("x/y","z");
	     System.out.println(file2);
	     
	     //将父级File对象和字节路径封装成一个file对象,其实就是父级路径和子级路径的拼接后的路径
	     File file3 = new File("x/y/z");
	     file3 = new File("x/y/z","aaa.txt"); 
	     System.out.println(file3);
	     
	 }
}

File类型的创建方法和删除方法
1.boolean createNewFile() 创建当前的File对象所描述的路径的文件
2.boolean mkdir() 创建当前对象的所描述的路径的文件夹(如果父级路径不存在，那么就会自动创建父级路径)
3.boolean mkirs() 创建当前的File对象所描述的路径的文件夹
4.delete():删除调用者所描述的文件或者文件夹
备注：delete在删除文件夹的时候，只能删除空的文件夹，delete不能走回收站

       //创建一个文件
		File file = new File("x/y/a.txt");
		file.createNewFile();
		//创建一个文件夹
		File nFile = new File("k");
		nFile.mkdir();
		//创建多级文键夹
		File nFile2 =new File("a/b/c/n");
		nFile2.mkdirs();
		//删除
		nFile.delete();

File类型的重名功能
1.renameTo(File dest)
调用者是当前的文件或者文件夹的路径对象
参数列表是变化后的文件或者是文件夹的路径对象
2.注意事项：
如果在同一个文件夹下，修改路径就是 重命名
如果不在同一个文件夹下，修改路径就是剪切

      //重命名方法,实现数据的重名称,如果在不同的目录下相同的文件就是剪切
	   File file = new File("x/y/a.txt");
	   File file2 = new File("a/b/c/d/a.txt");
	   file.renameTo(file2);
	   //调用者是当前的文件夹或者是目录，被调用者是变化之后的文件夹或者路径对象,如果在相同的目录下就是重命名
	   File file3 = new File("a/b/c/d/f.txt");
	   file2.renameTo(file3);

File文件的判断功能和获取功能
1.exists();判断当前调用者File文件，是否存在
2.isFile();判断当前调用者是否是文件
3.isDiretory():判断当前文件是不是文件夹
4.getAbsolutepath():获取当前File对象的绝对路径
5.getPath()：获取的就是在构造方法中封装的路径
6.String[] String:获取当前文件夹中的所有的文件和文件夹的名称，到数组中
7.File[] listFiles():获取当前文件夹的所有的文件和文件夹的File对象在File对象数组中

File file = new File("a");
System.out.println(file.exists());       //判断文件是否存在
System.out.println(file.isFile());       //判断当前调用者是不是文件
System.out.println(file.isDirectory());  //判读当前的调用者是不是文件夹
//获取最底层的文件的名称
File file = new File("a/b/c/d/f.txt");
//打印构造方法的路径
System.out.println(file.getName());
//打印文件的路径
System.out.println(file.getParent());
//打印文件的绝对路径
System.out.println(file.getAbsolutePath());

通过控制台输入一个字符串，判断是否是指定的文件夹下，所有的大于20M的以.wmv的文件的绝对路径？

package cn.ujiuye.file;
import java.io.File;
import java.util.Scanner;
/**
 * @author liugang
 *
 */
public class FileTest {
	public static void main(String[] args) {
		@SuppressWarnings("resource")
		Scanner sc = new Scanner(System.in);
		while (true) {
			System.out.println("请输入你要查询的路径:");
			String src = sc.next();
			if (src.equals("d:/aaa")) {
				File file = new File(src);
				File[] listFiles = file.listFiles();
				//判断该文件夹下所有的大于.20M的所有的文件的绝对路径
				if (listFiles != null) {
					for (File file2 : listFiles) {
						if (file2.isFile() &&file2.getName().endsWith(".wmv") &&file.length() > 20 * 1024 * 1024) {
							System.out.println(file2.getAbsolutePath());
						}
					}
					break;
				}
			} else {
				System.out.println("您当前输入的路径不对,请重新输入");
			}
		}

	}
}

IO概述
站在内存的角度上，从其他的设备进入内存的，都是输入，从内存到其他的设备的都是输出，I/O就是用于设备之间的进行传递的数据交互的对象的所属的类型。
字节流
可以直接操作字节信息的流对象，根据流对象，可以分成字节输入流和字节输出流，顶层父类分别是:InputStream和OuputStream

InputStream
1.字节输入流的顶层父类
2.常用的方法：
int read(): 从当前的字节流获取一个字节
int read(byte[] arr):将arr.length个字节，读取到arr中
InputStream是一个抽象类，不能直接创建对象，只能由子类创建对象
read():一次读取一个字节，返回值类型是int类型，原因是要把返回的字节的前面加上24个0.无论读取到的是负数还是整数，都会是变成整数，只要是从文件中读取的数据，都是整数，如果返回值是-1，说明不是从文件中读取的数据，而是专门为方法准备的文件末尾的标记，说明：虽然每次都调用了该方法，但是返回的却不同，因为文件的指针不断的向后移。

       //创建字节输入流对象,将输入流从磁盘的文件中读取到计算机的内存中
		FileInputStream fis = new FileInputStream("a.txt");
		//读取的字节
		int ins;
		while((ins = fis.read())!=-1) {
			System.out.println((char)ins);
		}
		//关闭流
		fis.close();

 public class FileInPutStreamDemo03 {
	public static void main(String[] args) throws IOException {
		//创建字节输入流对象,将输入流从磁盘的文件中读取到计算机的内存中
		FileInputStream fis = new FileInputStream("a.txt");
		byte[] arr = new byte[2];
		//显然将你读取到的数据写到文件中去
		int len =fis.read(arr);
		System.out.println(Arrays.toString(arr) + ">>>" +new String(arr,0,len)+">>>"+len);
		
		len =fis.read(arr);
		System.out.println(Arrays.toString(arr) + ">>>" +new String(arr,0,len)+">>>"+len);
		
		fis.close();
	}
}

OutputStrea字节输出流
1.字节输出流的顶层父类
2.常用方法：
write(int b) :将一个字节信息写到指定的设备中
write(byte[] arr):将一个字节的所有的信息，写到指定的设备中
write(byte[] arr,int offsert,int len):将一个字节数组从arr中的offert索引开始，共len字节写到指定的设备中
3.字节输出流
FileOutputStream(File f) 将f的描述的路径封装成字节输出流对象
FileOutputStream(String path):将path描述的文件路径封装成字节输出流对象，使用字节输出流写入数据，关联到文件中

package cn.ujiuye.inputOut;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author liugang
 *
 */
public class FileOutStreamDemo06 {
    public static void main(String[] args) throws IOException {
    	//创建一个文件输出流对象
		FileOutputStream fis = new FileOutputStream("y.txt");
		//声明一个数组
		byte[] arr = {100,101,102};
		//fis.write(arr);
		//将数组指定的元素填到指定的位置
		fis.write(arr,0,2);
		fis.close();
	}
}

package cn.ujiuye.inputOut;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author liugang
    *    一个一个的拷贝
 */
public class FileOutStreamDemo05 {
    public static void main(String[] args) throws IOException {
    	//创建一个文件输入流对象
    	FileInputStream fis = new FileInputStream("y.txt");
    	//创建一个文件输出流对象
		FileOutputStream fos = new FileOutputStream("y.copy.txt");
		int read;
		while((read = fis.read())!=-1){
			fos.write(read);
		}
		//关闭字节
		fos.close();
		fis.close();
		
	}
}

高效缓存流
1.BufferedInputStream和BufferOutputStream
2.是包装类型：本身不具备读写的功能，只是在具体的流对象的基础上，对其进行加强，例如FileInputStream和FileOutputStream，原本的效率较低，加强之后，就效率较高。

package cn.ujiuye.inputOut;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author liugang
    *    一个一个的拷贝
 */
public class BufferedOutStreamInputStream {
    public static void main(String[] args) throws IOException {
    	
    	long start = System.currentTimeMillis();
    	//创建一个文件输入流对象
    	FileInputStream fis = new FileInputStream("aa.avi");
    	//创建一个文件输出流对象
		FileOutputStream fos = new FileOutputStream("bb.avi");
		//加强版的输入流和输出流  高效缓存流
		BufferedInputStream in = new BufferedInputStream(fis);
		BufferedOutputStream out =  new BufferedOutputStream(fos);
		//从文件中读取数据
		int read;
		while((read = in.read())!=-1) {
			//把数据从内存中写到文件中去
			out.write(read);
		}
		//关闭字节
		in.close();
		out.close();
		long end = System.currentTimeMillis();
		System.out.println(end - start);
	}
}

字符流
使用字符流处理字符的问题：
1.使用字节流写字符
可以使用，但是要先把字符串转化成字节数组，再储存在文件中，比较麻烦
2,使用字节流读取字符
如果是纯文本可以一次读取一个字节
如果是存中文，可以一次读取两个字节（GBK）
如果是中英文混砸，每次不知道读取多少字节，因此无论字节数组准备多大都会出现乱码
解决方法：
在GBK编码中，如果是一个英文，那么读取的字节是正数，如果读取的是正数，那么就可以断定是英文字符，就读取一个字节转化为字符即可。
在GBK编码，如果是一个中文，那么就一定读取的是第一个字节是负数，如果读取的是一个负数，就说明读取到的就是一个中文，两个字节一起转化为字符。
字符流的使用
1.顶级顶层父类：Reader Writer
2.常用方法：
Reader:
read():读取一个字符，返回值如果是-1，表达到达文件的末尾
read(char[] arr):将一堆字符储存在一个字符数组中
Writer:
writer(int c):写出一个字符
write(String str):写出一个字符串
write(将一个字符数组的所有的内容写出)
write(char[] arr,int offset,int len):将字符数组的一部分写到目标中
3.抽象类不能直接创建子类。需要具体的子类来创建
4.使用FileReader和FileWriter可以作为创建对象的类型

public class FileReaderDemo01 {
    public static void main(String[] args) throws IOException {
		//加载字符输入流对象
    	FileReader reader = new FileReader("a.txt");
		//循环遍历，实现数据的读取操作，每次内部会根据其数据的特点会分配空间
    	int b;
		while((b = reader.read()) != -1) {
			System.out.println(b + "::" +(char)b);
		}
		reader.close();
	}

public class WriterDemo02 {
    public static void main(String[] args) throws IOException {
		//字符输出流
    	FileWriter wr = new FileWriter("a.txt",true);
		//直接写入你想写入的对象
    	wr.write("你好你好呀");
		wr.write("谢女士,请问你还好吗？");
		wr.write("加油");
		wr.write("love");
		wr.close();
	}
}

public class WriterDemo03 {
    public static void main(String[] args) throws IOException {
		//字符输入流
    	FileReader fr = new FileReader("a.txt");
    	//字符输出流
    	FileWriter wr = new FileWriter("a_copy.txt");
    	
    	//循环遍历数据实现复制操作
    	int b;
    	while((b = fr.read())!= -1) {
    		wr.write(b);
    	}
    	//关闭流对象
    	fr.close();
    	wr.close();
	
	}
}

字符流的拷贝
1.使字符输入流读取信息，使用的字符流出流写出信息，完成文件的使用字符流拷贝
2.字符流拷贝的必要性：
没有必要使用字符流来进行拷贝，因为字符流会先将字节信息转化为字符，读取到内存中，最后还有把字符信息转化为字节信息，写到另外的一个文件中，中间做了两个没有意义的相反的操作，浪费了时间.
应用场景：
1.如果是在读取到字符以后，需要人为的阅读和修改这个字符，那么就使用字符流
2.如果只是简单的将信息进行转移或者是拷贝，就不需要转成字符了

public class FileReaderDemo03 {
    public static void main(String[] args) throws IOException {
		//创建字符输入流和字节输出流
    	FileReader fr = new FileReader("a.txt");
		FileWriter fw = new FileWriter("a_capy1.txt");
		//创建数组,一次读入一组字符，加快读的效率
		char[] chs = new char[1024*8];
		int b;
		while((b = fr.read(chs))!=-1) {
			fw.write(chs,0,b);
		}
		fr.close();
		fw.close();
	}
}

字符流不能操作非纯文本文件：因为当字符流读取到一个字节的时候，需要查询编码表是不是非纯文本，如果是，就有可能读取的字符无法转化成对应的字符，因为这个字节信息在编码表中没有对应的字符，就只能使用英文的？来代替，这一步就是对内容进行篡改,字符信息，后面再转化就不可能正确了.

高效缓存字符流和高效缓存字节流基本上类似，就不多介绍了，下面举个例题来介绍一下：将文件夹中的第一行转化成最后一行，第二行转化成倒数第二行？

package cn.ujiuye.writerreader;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * @author liugang
 *
 */
public class BufferReadWriterTest {
    public static void main(String[] args) throws IOException {
    	//定义一个缓存字符输入流
		BufferedReader br = new BufferedReader(new FileReader("x.txt"));
		//定义一个集合
		List<String> list = new ArrayList<String>();
		//集合遍历
		String line;
		while((line = br.readLine())!=null) { //一行一行的读入数据，便于反转时读出方便
			list.add(line);
		}
		br.close();
		//定义一个字符输出流
		BufferedWriter bw = new BufferedWriter(new FileWriter("x_copyfan.txt"));
		//遍历集合倒序输出
		for(int i = list.size()-1;i >= 0;i--) {
			bw.write(list.get(i));
			bw.newLine();              //换行操作
		}
		bw.close();
	}
}