File类的使用

java.io.File类：文件和文件目录路径的抽象表示型事，与平台无关
File能新建、删除、重命名文件和目录，但File不能访问文件内容本身，如果需要访问文件内容本身，则需要输入/输出流
想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的目录或文件
File对象可以作为参数传递给流的构造器

关于路径分隔符：
路径中每级目录之间用一个路径分隔符隔开。路径分隔符和系统有关：windows和Dos系统默认使用""来表示 unix和URL使用"/"来表示，Java程序支持跨平台运行，因此路径分隔符要慎用，为了解决这个隐患File类提供了一个常量public static final String separator。根据操作系统，动态的提供分隔符

如何创建File类的实例：
常用的构造器：
public File(String pathname):以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。绝对路径：是一个固定的路径，从盘符开始 相对路径：是相对于某个位置开始
public File(String parent,String child):以parent为父路径，child为子路径创建File对象
public File(File parent,String child):根据一个父File对象和子文件路径创建File对象

//构造器1
File file1 = new File("hello.text");//相对于当前module的路径
File file2 = new File("D:\\h3.txt");//绝对路径

//构造器2：
File file3 = new File("D:\\project","javaSenior");

//构造器四：
File file4 = new File(file3,"hi.text");

常用的方法：
File类的获取功能
public String getAbsolutePath():获取绝对路径
public String getPath():获取路径
public String getName():获取名称
public String getParent():获取上层文件目录路径。若无，返回null
public long length():获取文件长度（即：字节数）。不能获取目录的长度。
public long lastModified():获取最后一次修改时间，毫秒值
以下两个方法适用于文件目录：
public String[] list()：获取指定目录下的所有文件或者文件目录的名称数组
public File[] listFiles():获取指定目录下的所有文件或者文件目录的File数组
File重命名功能：
public boolean renameTo(File dest):把文件重命名为指定的文件路径
比如：file1.renameTo(file2)为例：要想保证返回true，需要file1在硬盘是存在的，且file2不能再硬盘中存在
File类的判断功能
public boolean isDirectory():判断是否是文件目录
public boolean isFile():判断是否是文件
public boolean exists():判断是否存在
public boolean canRead():判断是否刻度
public boolean canWrite():判断是否可写
public boolean isHidden():判断是否隐藏
File类的创建功能
public boolean createNewFile():创建文件。若文件存在，则不创建，返回false
public boolean mkdir():创建文件目录，如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
public boolean mkdirs():创建文件目录。如果上层文件目录不存在，一并创建
注意事项：如果你创建文件或者文件目录没有写盘符路径，那么，默认再项目路径下
File类的删除功能：
public boolean delete():删除文件或者文件夹
删除注意事项：java中的删除不走回收站。要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。

IO流

I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
Java程序中，对于数据的输入/输出操作以"流（stream)"的方式进行。
Java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据
输入input:读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中
输出output:将程序（内存）数据输出到磁盘、光盘等存储设备中。
按照操作单位不同分为：字节流（8bit),字符流(16bit)
按照数据流的流向不同分为：输入流、输出流
按流的角色的不同分为：节点流(直接操作一个File)，处理流(作用在节点流之上)

Java的IO流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的
由这四个类派生出来的子类名称都是以其父类名作为子类名后缀

读入操作

示例：

@Test
public void testFileReader throws IOException(){
	try{
	//main方法中创建相当于在当前工程下，test中创建，相当于当前模块下
	//1.实例化File对象，指明要操作的文件
	File file = new File("hello.txt")
	//2.提供具体的流读入的文件一定要存在，否则就会报FileNotFoundException
	FileReader fr = new FileReader(file);
	//3.数据的读入
	//read():返回读入的一个字符。如果达到文件末尾，返回-1
	int data = fr.read();
	while(data!=-1){
		System.out.println((char)data);
		data=fr.read();
	}
	}catch(IOException){
		e.printStackTrace();
	}finally{
	//4.流的关闭操作
	try{
		if(fr!=null){
			fr.close();
		}
	}catch(IOException e){
		e.printStackTrace();
	}
	}
}

//对read()操作升级：使用read()重载的方法
@Test
public void testFileRead2(){
	try{
	//1.File的实例化
		File  file = new File("hello.txt");
		//2.FileReader流的实例化
		FileReader fr = new FileReader(file);
		//3.读入的操作
		//read(char[] cbuf):返回每次读入cbuf数组中字符的个数。如果达到文件末尾返回-1
		char[] cbuf = new char[5];
		int len;
		while((len=fr.read(cbuf))!=-1){
		//错误的写法
			//for(int i=0;i<cbuf.lenth;i++){
			//	System.out.pringln(cbuf[i]);
			//}
		//方式一：
			for(int i=0;i<len;i++){
				System.out.pringln(cbuf[i]);
			}
		//方式二：
		//错误的
		//String str = new String(cbuf);
		//System.out.print(str);
		//正确的
		String str = new String(cbuf,0,len);
		System.out.print(str);
		}
	}catch(IOException e){
		e.printStackTrace();
	}finally{
		try{
			if(fr!=null){
			//4.资源的关闭
			fr.close();
			}
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}

写出操作

从内存中写出数据到硬盘中
说明：
1.输出操作，对应的File可以不存在的。如果不存在，在输出的过程中，会自动创建文件。如果存在：根据构造器来判断
2.

//1.提供File类的对象，指明写出到的文件
File file = new File("hello1.txt");

//2.提供FileWriter，用于数据的写出,true表示不会对原有文件覆盖，false表示会对原有文件覆盖
FileWriter fw = new FileWriter(file,true);

//3.写出的操作
fw.write("I have a dream!");
fw.write("you need to have a dream!");

//4.流资源的关闭操作
fw.close();

文件的读写操作

//不能用字符流来处理文件

@Test
public void testFileReaderFileWriter(){
	FileWriter fw =null;
	try{
		//1.创建File的对象，指明读入和写出的文件
		File scrFile = new File("hello.txt");
		File dest = new File("hello2.txt");
		//2.创建输入流和输出流的对象
		FileRead fr = new FileRead(srcFile);
		FileWriter fw = new FileWriter(destFile);
		//3.数据的读入和写出的操作
		char[] cbuf = new char[5];
		int len;//记录每次读入到cbuf数组中的数据的个数
		while((len=fr.read(cbuf))!=-1){
			//每次写出len个字符
			fw.write(cbuf,0,len);
		}
	}catch (IOException e){
		e.printStackTrace();0
	}finally{
			try{
				if(fw!=null){
					fw.close();
				}
			}catch(IOException e){
				e.printStackTrace();
			}

			try{
				if(fr!=null){
					fr.close();
				}
			}catch(IOException e){
				e.printStackTrace();
			}
	}
}

测试FileInputStream和FileOutputStream的使用
1.对于文本文件（.txt,.java,.c,cpp)，使用字符流处理，对于非文本文件(.jpg,.mp3,.mp4...)，使用字节流处理

	@Test
	public void testFileInputStream(){
	FileInputStream fis =null;
		try{
			//1.造文件
			File file = new FIle("hello.txt");
			//2.造流
			FileInputStream fis = new FileInputStream(file);
			//3.读数据
			byte[] buffer = new byte[5];
			int len;//记录每次读取的字节个数
			while((len = fis.read(buffer))!=-1){
				String str = new String(buffer,0,len);
				System.out.print(str);
			}
		}catch(IOException e){
			e.printStackTrace();
		}finally{
			//4.关闭资源
			try{
				if(fis!=null){
					fis.close();
				}
			}catch(IOException e){
				e.printStackTrace();
			}
		}
	}

@Test
public void testFileInputOutputStream(){
	FileInputStream fis = null;
	FileOutputStream fos = null;
	try{
			//实现对图片的复制
		File srcFile = new File("图片.jpg");
		File destFile = new File("图片2.jpg");

		//
		fis = new FileInputStream(srcFile);
		fos = new FileOutputStream(destFile);

		//复制的过程
		byte[] buffer = new byte[5];
		int len;
		while((len = fis.read(buffer)!=-1){
			fos.write(buffer,0,len);
		}
	
	}catch(IOException e){
		e.printStackTrace();
	}finally{
		if(fos!=null){
			try{
				fos.close();
			}catch(IOException e){
				e.printStackTrace();
			}
		}
				if(fis!=null){
			try{
				fis.close();
			}catch(IOException e){
				e.printStackTrace();
			}
		}
	}
}

处理流之一：缓冲流的使用

作用：提高流的读取和写入的速度
提高读写速度的原因：内部提供了一个缓冲区
处理流，就是"套接"在以由的流的基础上

//实现非文本文件的复制
@Test
public void BufferStreamTest(){
	BufferedInputStream bis = null;
	BufferedOutputStream bos = null;
	try{
		//1.造文件
		File srcFile = new File("tupian.jpg");
		File destFile = new File("图片1.jpg");
		//2.造流
		FileInputStream fis = new FileInputStream(srcFile);
		FileOutputStream fos = new FileOutputStream(destFile);
		//造缓冲流
		BufferedInputStream bis = new BufferedInputStream(fis);
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		//3.复制的细节：读取、写入
		byte[] bufer = new byte[10];
		int len;
		while((len=bis.read(buffer)!=-1){
			bos.write(buffer,0,len);
			bos.flush();//刷新缓存区
		}
	}catch(IOException e){
		e.printStackTrac();
	}finally{
			//4.资源关闭
	//要求：先关闭外层的流，再关闭内层的流
	//说明：外层关闭的同时内层流也会自动关闭，内层流我们可以省略
	if(bos!=null){
		try{
			bos.close();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
	if(bis!=null){
		try{
			bis.close();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
	//fos.close();
	//fis.close();
	}
}

//使用BufferedReader  
@Test
public void testBufferedReaderBufferWriter(){
	BufferedReader br  = null;
	BufferedWriter bw = null;
	try{
	//创建文件和对应的流
		 br = new BufferedReader(new FileReader(new File("文本文件.txt")));
		 //br = new BufferedReader("文本文件.txt")
		 bw  = new BufferedWriter(new FileWriter(new File("文本文件1.txt")));
		 //bw = new BufferedWriter("文本文件1.txt")
		//读写操作方式一
		//char[] cbuf = new char[1024];
		//int len;
		//while((len=br.read(cbuf)!=-1){
			//bw.write(cbuf,0,len);
			//bw.flush();
		//}
		//方式二：
		String data;
		while((data = br.readLine())!=null){
		//方法一：
			//bw.write(data+"\n");//data中不包含换行符
		//方法二：
			bw.write(dta);
			bw.newLine();
		}
	}catch(IOEexcption e){
		e.printStackTrace();
	}finally{
		//关闭资源
		if(bw!=null){
			try{
				bw.close();
			}catch(IOException e){
				e.printStackTrace();
			}
		}
		if(br!=null){
			try{
				br.close();
			}catch(IOException e){
				e.printStackTrace();
			}
		}
	}

处理流之二：转换流

转换流提供了在字节流和字符流之间的转换
Java API提供了两个转换流：（属于字符流）

InputStreamRreader:将InputStream转换为Reader
OutputStreamWrite:将Writer转换为OutputStream

解码：字节、字节数组 ---->字符数组、字符串
编码：字符数组、字符串 ---->字节、字节数组

字节流中的数据都是字符时，转换字符操作更高效

很多时候我们使用转换流来处理文件乱码问题，实现编码和解码功能。

@Test
public void test1() throw IOException{
	FileInputStream fis = new FileInputStream("abc.txt");
	InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
	//InputStreamReader isr = new InputStreamReader(fis，"UTF-8");//指明字符集
	char[] cbuf = new char[20];
	int len;
	while((len=isr.read(cbuf)!=-1){
		String str = new String(cbuf,0,len);
		System.out.print(str);
	}
	
	
	isr.close();
}

@Test
public void test2(){
	try{
		//utf-8读 gbk写
		File file = new File("dbcp.txt");
		File file2 = new File("dbcp_gbk.txt");
		FileInputStream fis = new FileInputStream(file1);
		FileOutputStream fos = new FileOutputStream(file2);
		InputStreamReader isr = new InputStreamReader(fis,"utf-8");
		OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

		//读写过程
		char[] cbuf = new char[20];
		int len;
		while((len=isr.read(cbuf)!=-1){
		osw.write(cbuf,0,len);
		}

	}catch(IOException e){
		e.printStackTrace();
	}finally{
	isr.close();
	osw.close();
	}
}

字符集

编码表的由来
计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。这就是编码表。

常见的编码表
ASCII: 美国标准信息交换码 √用一个字节的7位可以表示。
SO8859-1:拉丁码表。欧洲码表用一个字节的8位表示。
GB2312:中国的中文编码表。最多两个字节编码所有字符
GBK:中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
Unicode: 国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
UTF-8:变长的编码方式，可用1-4个字节来表示一个字符。

Unicode不完美，这里就有三个问题，一个是，我们已经知道，英文字母只用个字节表示就够了，第二个问题是如何才能区别Unicode和ASCII? 计算机怎么知道两个字节表示一个符号，而不是分别表示两个符号呢?第三个，如果和GBK等双字节编码方式一样，用最高位是1或0表示两个字节和一个字节，就少了很多值无法用于表示字符，不够表示所有字符。Unicode在很长一段时间内无法推广，直到互联网的出现。
面向传输的众多 UTF (UCS Transfer Format) 标准出现了，顾名思义，UTF8就是每次8个位传输数据，而UTF-16就是每次16个位。这是为传输而设计的编码，并使编码无国界，这样就可以显示全世界上所有文化的字符了。
Unicode只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的Unicode编码是UTF-8和UTF-16。

关于其他流

1.标准的输入、输出流
System.in:标注的输入流，默认从键盘输入
System.out:标注的输出流，默认从控制台输出
System类的setIn()/setOut()方式会从新指定输入和输出的流。

//标准的输入、输出流
InputStreamReader isr = new InputStreamReader(System.in);
BuffferedReader br = new BufferedReader(isr);

while(true){
	String data = br.readLine();
	if(data.equalsIgnoreCase("e")||data.equalsIgnoreCase("exit")){
		System.out.println("程序结束");
		break;
		String upperCase = data.toUpperCaser();
		System.out.println(upperCase);
	}
br.close();
}

2.打印流:PrintStream和PrintWriter
提供了一系列重载的print()和print()方法，用于多种数据类型的输出
PrintStream和PrintWriter的输出不会抛出IOException异常
PrintStream和PrintWriter有自动flush功能
PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。
在需要写入字符而不是写入字节的情况下，应当使用PrintWriter类
System.out返回的是PrintStream的实例

PrintStream ps= null
try{
FileOutputStream fos = new FileOutputStream(new File( pathname: "D:\\I0\\text.txt"));// 创建打印输出流，设置为自动刷新模式( 写入换行符或字节、‘\n’时都会刷新输出缓冲区)
ps = new PrintStream(fos, true);
if (ps != nu11) {// 把标准输出流(控制台输出)改成文件
System.setOut(ps);
}
for(int i = ; i <= 255; i++) {
	// 输出ASCII字符
	System.out.print((char) i);
	if (i % 50 == 0) {
	// 每5个数据一行
	System.out.println();
	// 换行
	}
}catch (FileNotFoundException e) {
	e.printstackTrace();
}finally {
	if (ps != null)
	ps.close();
}

3.数据流
用于操作基本数据类型和String的数据
用于读取或写出基本数据类型的变量或字符串
读取不同类型的数据的舒徐曜宇当前写入文件时，保存的数据顺序一致。
DataInputStream 和 DataOutputStream

DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeUTF("rhy");
dos.writeInt(23);
dos.flush();
dos.close();

DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
String name =dis.readUTF();
int age = dis.readInt();
dis.close();

4.对象流
用于存储和读取基本数据类型的数据和对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

序列化：用ObjectOutputStream类保存基本数据或对象的机制
反序列化：用ObjectInputStream类读取基本类型数据或对象的机制

ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量。

对象的序列化

对象的序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取这种二进制流，就可以恢复成原来的Java对象。
序列化地好处在于可将任何实现了Serializable接口地对象转化为字节数据，使其保存和传输时可悲还原
序列化是RMI(Remote Method Invoke-远程方法调用)过程地参数和返回值都必须实现地机制，而RMI是JavaEE的基础。因此序列化机制是JavaEE平台的基础。
如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则会抛出NotSerializableException异常。 Serializable 和 Externalizable。当前类提供一个全局常量：serialVersionUID,除此之外，要保证内部所有属性也必须是可序列化的。（默认情况下，基本数据类型也是可序列化的。）

//序列化过程：将内存中给你的Java对象保存到磁盘中或通过网络传输出去
//使用ObjectOutputStream实现
@Test
public void testObjectOutputStream(){
	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("objct.txt"));
	oos.writeObject(new String("我爱北京天安门"));
	oos.flush();
	oos.close();
}

//反序列化：将磁盘文件中的对象还原为内存中的一个Java对象
@Test void testObjectInputStream(){
	ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Object.txt));
	Object obj = ois.readObject();
	String str  = (String)obj;
	ois.close();
}

对象的序列化：
凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：
private static final long serialVersionUID;
serialVersionUID用来表命类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
如果类没有显式定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID可能发生变化。故建议，显式声明。
简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常(InvalidCastException)

随机存取文件流

RandomAccessFile声明在java.io包下，但直接继承于java.lang.Object类。并且它实现了DataInput、DataOutput这两个接口，也就意味着这个类既可以读也可以写。
RandomAccessFile类支持“随机访问”的方式，程序可以直接跳到文件的任意地方来读、写文件。支持只访问文件的部分内容，可以向已存在的文件后追加内容
RandomAccessFile对象包含一个记录指针，用以标示当前读写处的位置。
RandomAccessFile类对象可以只有移动记录指针：
long getFilePointer():获取文件记录指针的当前位置 void seek(long pos):将文件记录指针定位到pos位置。

构造器：
public RandomAccessFile(File file,String mode);
public RandomAccessFile(String name,String mode);

创建RandomAccessFile类实例需要指定一个mode参数，该参数指定RandomAccessFile的访问模式：
r:以只读方式打开
rw:打开以便读取和写入
rwd:打开以便读取和写入；同步文件内容的更新
rws:打开以便读取和写入；同步文件内容和元数据的更新。

如果模式为只读r。则不会创建文件，而是会读取一个已经存在的文件，如果读取的文件不存在则会出现异常。如果模式为rw读写。如果文件不存在则会去创建文件，如果存在则不会创建

//RandomAccessFile的使用:
@Test
public void test1(){
	RandomAccessFile raf1  = new RandomAccessFile(new File("图片.jpg"),"r");
	RandomAccessFile raf2  = new RandomAccessFile(new File("图片1.jpg"),"rw");
	byte[] buffer = new byte[1024];
	int len;
	while((len=(raf1.read(buffer))!=-1){
		raf2.write(buffer,0,len);
	}
	raf1.close();
	raf2.close();
}

//使用RandomAccessFile实现数据的插入操作
@Test
public void test3() throws IOException(){
	RandomAccessFile raf1  = new RandomAccessFile("hello.txt","rw");
	raf1.seek(3);//将指针调到角标为3的位置
	//保存指针3后面的所有数据到StringBuilder中
	StringBuilder builder = new StringBuilder((int)new File("hello.txt").length());
	byte[] buffer =  new byte[20];
	int len;
	while((len = raf1.read(buffer)!=-1){
		builder.append(new String(buffer,0,len));
	}
	//调回指针
	raf.seek(3);
	raf1.write("xyz".getBytes());
	//将StringBuilder中的数据写入到文件中
	raf1.write(builder.toString().getBytes());
	raf1.close();
}

我们可以用RandomAccessFile这个类，来实现一个多线程断点下载的功能用过下载工具的朋友们都知道，下载前都会建立两个临时文件，一个是与被下载文件大小相同的空文件，另一个是记录文件指针的位置文件，每次暂停的时候，都会保存上一次的指针，然后断点下载的时候，会继续从上一次的地方下载，从而实现断点下载或上传的功能，有兴趣的朋友们可以自己实现下。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.util.concurrent.atomic.AtomicInteger;

public class DownloadThread extends Thread {

    private final int pieceLength;
    private final String savePath;
    private final RandomAccessFile downloadFile;
    private final AtomicInteger downloaded;
    private final int totalSize;
    private final int downloadIdx;
    private final FileOutputStream targetFile;

    public DownloadThread(int pieceLength, String savePath, int totalSize, int downloadIdx, FileOutputStream targetFile) {
        this.pieceLength = pieceLength;
        this.savePath = savePath;
        this.downloaded = new AtomicInteger(0);
        this.totalSize = totalSize;
        this.downloadIdx = downloadIdx;
        this.targetFile = targetFile;
    }

    @Override
    public void run() {
        try {
            // 构造一个新的文件对象
            FileChannel fileChannel = new RandomAccessFile(downloadFile, "rw").getChannel();
            MapMode mapMode = MapMode.READ_WRITE;
            fileChannel.setMapMode(mapMode);
            // 从文件末尾开始
            fileChannel.position(downloaded.get() * pieceLength);
            // 下载一个块
            fileChannel.transferTo(0, pieceLength, targetFile);
            // 判断是否下载完毕
            if (downloaded.incrementAndGet() == totalSize) {
                // 关闭文件，释放资源
                fileChannel.close();
                targetFile.close();
                System.out.println("下载完成：" + savePath);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        String savePath = "D:/test.txt.part1";
        int totalSize = 5 * 1024 * 1024;
        int downloadIdx = 1;
        int pieceLength = 1024;
        FileOutputStream targetFile = new FileOutputStream(savePath);
        for (int i = 0; i < totalSize; i += pieceLength) {
            try {
                DownloadThread t = new DownloadThread(pieceLength, savePath, totalSize, downloadIdx, targetFile);
                t.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

java NIO概述

Java NIO(New IO,Non-Blocking IO)是从Java 1.4版本开始引入的一套新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的(IO是面向对象流的)、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。
Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。

|-----java.nio.channels.Channel
	|-----FileChannel:处理本地文件
	|-----SocketChannel:TCP网络编程的服务器端的Channel
	|-----ServerSocketChannel:TCP网络编程中发送端和接收端的Channel
	|-----DatagramChannel:UDP网络编程中发送端和接收端的Channel

Path、Paths和Files核心API
早期的Java只提供了一个File类来访问文件系统，但File类的功能比较有限，所提供的方法性能也不高。而且，大多数方法在出错时仅返回事变，并不会提供异常信息
NIO.2为了弥补这种不足，引入了Path接口，代表一个平台无关的平台路径，描述了目录结构中文件的位置。Path可以看成是File类的升级版本，实际应用的资源也可以不存在。
在以前IO操作都是这样写的：

import java.io.File;
File file - new File("index.html");

但在java7中，我们可以这样写

import java.nio.file.Path;
import java.nio.file.Paths;
Path path = Paths.get("index.html");

同时，NIO.2在java.nio.file包还提供了Files、Paths工具类，Files包含了大量的静态的工具方法来操作文件；paths则包含了两个返回Path静态工厂的方法
Paths类提供了静态get()来获取Paht对象：
static Path get(String first,String...name):用于将多个字符串连接成路径
static Path get(URI uri):返回指定uri对应的Path路径

Path常用方法：
String toString():返回调用Path对象的字符串表示形式
boolean startsWith(String path):判断是否以path路径开始
boolean endsWith(String path):判断是否以path路径结束
boolean isAbsolute():判断是否是绝对路径
Path getParent():返回Path对象包含整个路径，不包含Path对象指定的文件路径
Path getRoot():返回调用Path对象的恩路径
Path getFileName():返回与调用Path对象关联的文件名
int getNameCount():返回Path根目录后面元素的数量
Path getName(int idx):返回指定索引位置idx的路径名称
Path toAbsolutePath():作为绝对路径返回Path对象
Path resolve(Path p):合并两个路径，返回合并后的路径对应的Path对象
File toFile():将Path转化为File类的对象

Files类：
java.nio.file.Files 用于操作文件或目录的工具类
Files常用方法：
Path copy(Path scr,Path dest,CopyOption ... how):文件的复制
Path createDirectory(Path path,FIleAttribute<?> ...attr):创建一个目录
Path createFile(Path path,FIleAttribute<?> ...arr):创建一个文件
void delete(Path path):删除一个文件/目录，如果不存在，执行报错
void deleteIfExists(Path path):Path对应的文件/目录如果存在，执行删除
Path move(Path src,Path dest,CopyOption...how):将src移动到dest位置
long size(Path path):返回path指定文件的大小。

使用第三方jar包：org.apache.commons.io.FileUtils

File srcFile = new File("text.txt");
File destFile = new File("text1.txt");
FileUtils copyFile(srcFile,destFile);