黑马程序员--Java面向对象——File类
2014-06-26 15:07
330 查看
面向对象
File类
1、用来将文件或者文件夹封装成对象
2、方便对文件与文件夹进行操作
3、File对象可以作为参数传递给流的构造函数。
4、了解File类中的常用方法。
File
import java.io.File;
public class Test{
public staticvoid main(String...args){
/*
将1.Java封装成 File 对象.
可以将已有的和未出现的文件或者文件夹封装成对象。
*/
File f1 = new File("C:\\1.Java");
File f2 = new File("C:\\","1.Java");
File f3 = new File("C:","1.Java");
File f4 = new File("C:"+File.separator+"1.Java");
sop(f1);
sop(f2);
sop(f3);
sop(f4);
}
public staticvoid sop(Object obj){
System.out.println(obj);
}
}
IO流(File对象功能-创建和删除)
File类
import java.io.File;
import java.io.IOException;
public class Test{
public staticvoid main(String...args) throws Exception {
File f = new File("C:\\文件夹\\1.Java");
File f1 = new File("C:\\文件夹");
//创建一个目录。
f1.mkdir();
//创建一个文件夹,如果传入文件名中还有文件夹,会自动创建根文件夹和子文件夹。
f.mkdirs();
/*
调用文件的创建方法,如果该文件的目录不存在,那么将报异常,
如果该文件存在的话,就不创建文件,如果不存在就创建该文件。
*/
f.createNewFile();
/*
休息4秒种
*/
Thread.sleep(4000);
/*
创建了一个文件,如果虚拟机退出,那么该文件将自动删除。
*/
f.deleteOnExit();
}
public staticvoid sop(Object obj){
System.out.println(obj);
}
}
IO流(File对象功能-判断)
import java.io.File;
import java.io.IOException;
public class Test{
public staticvoid main(String...args)throws IOException{
File f = new File("C:\\1.Java");
//是否是可执行文件
sop(f.canExecute());
//文件是否存在
sop(f.exists());
//是否是一个文件
sop(f.isFile());
//是否是一个目录
sop(f.isDirectory());
//是否是隐藏文件
sop(f.isHidden());
}
public staticvoid sop(Object obj){
System.out.println(obj);
}
}
IO流(File对象功能-获取)
import java.io.File;
public classTest{
public staticvoid main(String...args){
File f1 = new File("C:\\1.Java");
File f2 = new File("C:\\2.java");
f2.renameTo(f1);
}
}
import java.io.File;
public classTest{
public staticvoid main(String...args){
File[] file = File.listRoots();
for(File f : file){
System.out.println(f);
}
File f = new File("G:\\");
String[] name = f.list();
for(String fileName : name){
System.out.println(fileName);
}
}
}
IO流(列出目录下所有内容-递归)
/*
列出指定目录下文件或者文件夹,包含子目录中的内容。
也就是列出指定目录下所有内容
因为目录中还有目录,只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现还是目录的话,还可以在此调用本功能
也就是函数自身调用自身,
这种表现形式,或者编程手法,成为递归。
递归要注意:
1、制条件
2、要注意递归次数,避免内存溢出
*/
import java.io.File;
public class Test{
public staticvoid main(String...args){
File f =new File("C:\\");
dir(f);
toBin(6);
}
/*
public staticvoid toBin(int num){
while(num>0){
num = num/2;
sop(num%2);
}
}
*/
public staticvoid toBin(int num){
if(num>0){
toBin(num/2);
sop(num%2);
}
}
public staticvoid dir(File dir){
sop(dir);
File[] files = dir.listFiles();
for(File f
: files){
if(!f.isHidden()){
if(f.isDirectory())
dir(f);
else
sop(f);
}
}
}
public staticvoid sop(Objectobj){
System.out.println(obj);
}
}
IO流(列出目录下所有内容-带层次)
/*
列出指定目录下文件或者文件夹,包含子目录中的内容。
也就是列出指定目录下所有内容
因为目录中还有目录,只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现还是目录的话,还可以在此调用本功能
也就是函数自身调用自身,
这种表现形式,或者编程手法,成为递归
递归要注意:
1、制条件
2、要注意递归次数,避免内存溢出
*/
import java.io.File;
public class Test{
public staticvoid main(String...args){
File dir = new File("D:\\Demo");
dir(dir,0);
}
public static String getLevel(int level){
StringBuilder sb
= new StringBuilder();
for(int x=0;x<level;x++){
sb.append(" ");
}
return sb.toString();
}
public staticvoid dir(File dir,int level){
sop(getLevel(level)+dir);
level++;
File[] files
= dir.listFiles();
for(Filefile:files){
if(!file.isHidden()){
if(file.isDirectory())
dir(file,level);
else
sop(getLevel(level+1)+file);
}
}
}
public staticvoid sop(Object obj){
System.out.println(obj);
}
}
IO流(删除带内容的目录)
import java.io.File;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.util.List;
import java.util.ArrayList;
public class Test{
public staticvoid main(String...args){
File dir = new File("G:\\Java");
List<File>
list = new ArrayList<File>();
dir(dir,list);
writeToFile(list,"C:\\1.Java",0);
}
public staticvoid writeToFile(List<File>
list,String fileName,int level){
BufferedWriter bufw
= null;
try{
bufw = new BufferedWriter(new FileWriter(fileName));
String filePath
= null;
for(File file:list){
if(!file.isDirectory())
filePath = getLevel(level+1)+file.getAbsolutePath();
else
filePath = getLevel(level)+file.getAbsolutePath();
bufw.write(getLevel(level)+filePath);
bufw.newLine();
bufw.flush();
}
}
catch (Exception e){
throw new RuntimeException("写入失败")
;
}
finally{
if(bufw!=null)
try{
bufw.close();
}
catch (Exception e){
sop("写入关闭失败");
}
}
}
public static String getLevel(int level){
StringBuilder sb
= new StringBuilder();
for(int x=0;x<level;x++){
sb.append("");
}
return sb.toString();
}
public staticvoid dir(File dir,List<File>
list){
File[] files
= dir.listFiles();
if(dir.exists()){
for(File file:files)
if(!file.isHidden())
if(file.isDirectory()){
list.add(file);
dir(file,list);
}
else
list.add(file);
}
else
sop("目录不存在");
}
public staticvoid sop(Object obj){
System.out.println(obj);
}
}
IO流(Properties简述)
Properties 是 Hashtable 的子类
也就是说它具备Map集合的特点,而且它里面存储的键值对都是字符串
是集合中和IO技术相结合的集合容器
该对象特点:可以用于键值对形式的配置文件。
那么在加载数据时候,需要数据有固定格式:键=值
IO流(Properties存取)
import java.util.Properties;
import java.util.Set;
public class Test{
public staticvoid main(String...args){
Propertiesprop
= System.getProperties();
Set<String>
names = prop.stringPropertyNames();
for(String name
: names){
sop(name+"::"+prop.getProperty(name));
}
}
public staticvoid sop(Object obj){
System.out.println(obj);
}
}
IO流(Properties存取配置文件)
IO流(Properties练习)
/*
演示,如何将流中的数据存储到集合中
想要将 info.properties 中的键值对数据存到集合中进行操作。
思路:
1、用一个流和info.txt文件关联
2、读取一行数据。将改行数据用"="进行切割。
3、等号左边作为键,右边作为值,存入到Properties集合中即可
*/
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
public class Test{
public
staticvoid main(String...args)throws IOException{
Properties prop
= new Properties();
BufferedReader bufr
= new BufferedReader(new FileReader("C:\\info.Properties"));
prop.load(bufr);
sop(prop);
for(String line=null;(line
= bufr.readLine())!=null;){
String[]
map = line.split("=");
prop.setProperty(map[0],map[1]);
}
String one
= prop.getProperty("111");
sop(one);
bufr.close();
}
public
staticvoid sop(Objectobj){
System.out.println(obj);
}
}
IO流(PrintWriter)
打印流
PrintWriter 与 PrintStream。可以直接操作输入流和文件。
/*
打印流
该流提供了打印方法,可以将各种数据烈性的数据都原样打印。
字节打印流
PrintStream
构造函数可以接受的参数类型
1、file对象。
2、字符串路径。String
3、字节输出流 OutpuStream
字符打印流
PrintWriter
构造函数可以接受的参数类型
1、file对象。
2、字符串路径。String
3、字节输出流 OutpuStream
4、字符输出流 Writer
*/
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.FileWriter;
public class Test{
public staticvoid main(String...args)throws IOException{
BufferedReader bufr =new BufferedReader(new InputStreamReader(System.in));
PrintWriter out =new PrintWriter(new FileWriter("C:\\1.Java"),true);
for(String line = null;(line=bufr.readLine())!=null;){
if("over".equals(line))
break;
out.println(line);
/*
由于PrintWriter加入一个参数,true表示自动刷新,所以这里就不用刷新。
out.flush();
*/
}
bufr.close();
out.close();
}
}
IO流(合并流)
序列流、
SequenceInputStream。对多个流进行合并
import java.util.Vector;
import java.io.FileInputStream;
import java.io.SequenceInputStream;
import java.io.IOException;
import java.io.FileOutputStream;
import java.util.Enumeration;
public class Test{
public staticvoid main(String...args)throws IOException{
Vector<FileInputStream>
v = new Vector<FileInputStream>();
v.add(new FileInputStream("C:\\1.Java"));
v.add(new FileInputStream("C:\\2.Java"));
v.add(new FileInputStream("C:\\3.Java"));
Enumeration <FileInputStream>en
= v.elements();
SequenceInputStream sis
= new SequenceInputStream(en);
FileOutputStream fos =new FileOutputStream("C:\\4.Java");
byte[] buf =new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
sis.close();
fos.close();
}
}
IO流(切割文件)
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Enumeration;
import java.io.SequenceInputStream;
public class Test{
public staticvoid main(String...args)throws IOException{
splitFile();
merge();
}
public staticvoid splitFile()throws IOException{
FileInputStream fis =new FileInputStream("C:\\Dj - 赶着马车去北京.mp3");
FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];
int len = 0;
int count= 1;
while((len=fis.read(buf))!=-1){
fos = new FileOutputStream("D:\\Dj - 赶着马车去北京"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
public staticvoid merge()throws IOException{
ArrayList<FileInputStream>al = new ArrayList<FileInputStream>();
for(int x=1;x<=3;x++){
al.add(new FileInputStream("D:\\Dj - 赶着马车去北京"+x+".part"));
}
final Iterator<FileInputStream>it = al.iterator();
Enumeration<FileInputStream>en =new Enumeration<FileInputStream>(){
publicboolean hasMoreElements(){
return it.hasNext();
}
public FileInputStream nextElement(){
return it.next();
}
};
SequenceInputStream sis =new SequenceInputStream(en);
FileOutputStream fos =new FileOutputStream("E:\\Dj - 赶着马车去北京.mp3");
byte[] buf = new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}
File类
1、用来将文件或者文件夹封装成对象
2、方便对文件与文件夹进行操作
3、File对象可以作为参数传递给流的构造函数。
4、了解File类中的常用方法。
File
staticString | separator 与系统有关的默认名称分隔符,为了方便,它被表示为一个字符串。 |
public class Test{
public staticvoid main(String...args){
/*
将1.Java封装成 File 对象.
可以将已有的和未出现的文件或者文件夹封装成对象。
*/
File f1 = new File("C:\\1.Java");
File f2 = new File("C:\\","1.Java");
File f3 = new File("C:","1.Java");
File f4 = new File("C:"+File.separator+"1.Java");
sop(f1);
sop(f2);
sop(f3);
sop(f4);
}
public staticvoid sop(Object obj){
System.out.println(obj);
}
}
IO流(File对象功能-创建和删除)
File类
boolean | createNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件。 |
boolean | mkdir() 创建此抽象路径名指定的目录。 |
boolean | mkdirs() 创建此抽象路径名指定的目录,包括所有必需但不存在的父目录。 |
boolean | delete() 删除此抽象路径名表示的文件或目录。 |
void | deleteOnExit() 在虚拟机终止时,请求删除此抽象路径名表示的文件或目录。 |
import java.io.IOException;
public class Test{
public staticvoid main(String...args) throws Exception {
File f = new File("C:\\文件夹\\1.Java");
File f1 = new File("C:\\文件夹");
//创建一个目录。
f1.mkdir();
//创建一个文件夹,如果传入文件名中还有文件夹,会自动创建根文件夹和子文件夹。
f.mkdirs();
/*
调用文件的创建方法,如果该文件的目录不存在,那么将报异常,
如果该文件存在的话,就不创建文件,如果不存在就创建该文件。
*/
f.createNewFile();
/*
休息4秒种
*/
Thread.sleep(4000);
/*
创建了一个文件,如果虚拟机退出,那么该文件将自动删除。
*/
f.deleteOnExit();
}
public staticvoid sop(Object obj){
System.out.println(obj);
}
}
IO流(File对象功能-判断)
boolean | exists() 测试此抽象路径名表示的文件或目录是否存在。 |
boolean | isAbsolute() 测试此抽象路径名是否为绝对路径名。 |
boolean | isDirectory() 测试此抽象路径名表示的文件是否是一个目录。 |
boolean | isFile() 测试此抽象路径名表示的文件是否是一个标准文件。 |
boolean | isHidden() 测试此抽象路径名指定的文件是否是一个隐藏文件。 |
import java.io.IOException;
public class Test{
public staticvoid main(String...args)throws IOException{
File f = new File("C:\\1.Java");
//是否是可执行文件
sop(f.canExecute());
//文件是否存在
sop(f.exists());
//是否是一个文件
sop(f.isFile());
//是否是一个目录
sop(f.isDirectory());
//是否是隐藏文件
sop(f.isHidden());
}
public staticvoid sop(Object obj){
System.out.println(obj);
}
}
IO流(File对象功能-获取)
File | getAbsoluteFile() 返回此抽象路径名的绝对路径名形式。 |
String | getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。 |
File | getCanonicalFile() 返回此抽象路径名的规范形式。 |
String | getCanonicalPath() 返回此抽象路径名的规范路径名字符串。 |
long | getFreeSpace() 返回此抽象路径名指定的分区中未分配的字节数。 |
String | getName() 返回由此抽象路径名表示的文件或目录的名称。 |
String | getParent() 返回此抽象路径名父目录的路径名字符串;如果此路径名没有指定父目录,则返回 null。 |
File | getParentFile() 返回此抽象路径名父目录的抽象路径名;如果此路径名没有指定父目录,则返回 null。 |
String | getPath() 将此抽象路径名转换为一个路径名字符串。 |
boolean | renameTo(File dest) 重新命名此抽象路径名表示的文件。 |
public classTest{
public staticvoid main(String...args){
File f1 = new File("C:\\1.Java");
File f2 = new File("C:\\2.java");
f2.renameTo(f1);
}
}
staticFile[] | listRoots() 列出可用的文件系统根。 |
String[] | list() 返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中的文件和目录。 |
public classTest{
public staticvoid main(String...args){
File[] file = File.listRoots();
for(File f : file){
System.out.println(f);
}
File f = new File("G:\\");
String[] name = f.list();
for(String fileName : name){
System.out.println(fileName);
}
}
}
IO流(列出目录下所有内容-递归)
/*
列出指定目录下文件或者文件夹,包含子目录中的内容。
也就是列出指定目录下所有内容
因为目录中还有目录,只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现还是目录的话,还可以在此调用本功能
也就是函数自身调用自身,
这种表现形式,或者编程手法,成为递归。
递归要注意:
1、制条件
2、要注意递归次数,避免内存溢出
*/
import java.io.File;
public class Test{
public staticvoid main(String...args){
File f =new File("C:\\");
dir(f);
toBin(6);
}
/*
public staticvoid toBin(int num){
while(num>0){
num = num/2;
sop(num%2);
}
}
*/
public staticvoid toBin(int num){
if(num>0){
toBin(num/2);
sop(num%2);
}
}
public staticvoid dir(File dir){
sop(dir);
File[] files = dir.listFiles();
for(File f
: files){
if(!f.isHidden()){
if(f.isDirectory())
dir(f);
else
sop(f);
}
}
}
public staticvoid sop(Objectobj){
System.out.println(obj);
}
}
IO流(列出目录下所有内容-带层次)
/*
列出指定目录下文件或者文件夹,包含子目录中的内容。
也就是列出指定目录下所有内容
因为目录中还有目录,只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现还是目录的话,还可以在此调用本功能
也就是函数自身调用自身,
这种表现形式,或者编程手法,成为递归
递归要注意:
1、制条件
2、要注意递归次数,避免内存溢出
*/
import java.io.File;
public class Test{
public staticvoid main(String...args){
File dir = new File("D:\\Demo");
dir(dir,0);
}
public static String getLevel(int level){
StringBuilder sb
= new StringBuilder();
for(int x=0;x<level;x++){
sb.append(" ");
}
return sb.toString();
}
public staticvoid dir(File dir,int level){
sop(getLevel(level)+dir);
level++;
File[] files
= dir.listFiles();
for(Filefile:files){
if(!file.isHidden()){
if(file.isDirectory())
dir(file,level);
else
sop(getLevel(level+1)+file);
}
}
}
public staticvoid sop(Object obj){
System.out.println(obj);
}
}
IO流(删除带内容的目录)
import java.io.File;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.util.List;
import java.util.ArrayList;
public class Test{
public staticvoid main(String...args){
File dir = new File("G:\\Java");
List<File>
list = new ArrayList<File>();
dir(dir,list);
writeToFile(list,"C:\\1.Java",0);
}
public staticvoid writeToFile(List<File>
list,String fileName,int level){
BufferedWriter bufw
= null;
try{
bufw = new BufferedWriter(new FileWriter(fileName));
String filePath
= null;
for(File file:list){
if(!file.isDirectory())
filePath = getLevel(level+1)+file.getAbsolutePath();
else
filePath = getLevel(level)+file.getAbsolutePath();
bufw.write(getLevel(level)+filePath);
bufw.newLine();
bufw.flush();
}
}
catch (Exception e){
throw new RuntimeException("写入失败")
;
}
finally{
if(bufw!=null)
try{
bufw.close();
}
catch (Exception e){
sop("写入关闭失败");
}
}
}
public static String getLevel(int level){
StringBuilder sb
= new StringBuilder();
for(int x=0;x<level;x++){
sb.append("");
}
return sb.toString();
}
public staticvoid dir(File dir,List<File>
list){
File[] files
= dir.listFiles();
if(dir.exists()){
for(File file:files)
if(!file.isHidden())
if(file.isDirectory()){
list.add(file);
dir(file,list);
}
else
list.add(file);
}
else
sop("目录不存在");
}
public staticvoid sop(Object obj){
System.out.println(obj);
}
}
IO流(Properties简述)
Properties 是 Hashtable 的子类
也就是说它具备Map集合的特点,而且它里面存储的键值对都是字符串
是集合中和IO技术相结合的集合容器
该对象特点:可以用于键值对形式的配置文件。
那么在加载数据时候,需要数据有固定格式:键=值
IO流(Properties存取)
import java.util.Properties;
import java.util.Set;
public class Test{
public staticvoid main(String...args){
Propertiesprop
= System.getProperties();
Set<String>
names = prop.stringPropertyNames();
for(String name
: names){
sop(name+"::"+prop.getProperty(name));
}
}
public staticvoid sop(Object obj){
System.out.println(obj);
}
}
IO流(Properties存取配置文件)
String | getProperty(String key) 用指定的键在此属性列表中搜索属性。 |
String | getProperty(String key,String defaultValue) 用指定的键在属性列表中搜索属性。 |
void | list(PrintStream out) 将属性列表输出到指定的输出流。 |
void | list(PrintWriter out) 将属性列表输出到指定的输出流。 |
void | load(InputStream inStream) 从输入流中读取属性列表(键和元素对)。 |
void | load(Reader reader) 按简单的面向行的格式从输入字符流中读取属性列表(键和元素对)。 |
Object | setProperty(String key,String value) 调用 Hashtable 的方法 put。 |
void | store(OutputStream out,String comments) 以适合使用 load(InputStream)方法加载到 Properties表中的格式,将此 Properties表中的属性列表(键和元素对)写入输出流。 |
void | store(Writer writer,String comments) 以适合使用 load(Reader)方法的格式,将此 Properties表中的属性列表(键和元素对)写入输出字符。 |
/*
演示,如何将流中的数据存储到集合中
想要将 info.properties 中的键值对数据存到集合中进行操作。
思路:
1、用一个流和info.txt文件关联
2、读取一行数据。将改行数据用"="进行切割。
3、等号左边作为键,右边作为值,存入到Properties集合中即可
*/
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
public class Test{
public
staticvoid main(String...args)throws IOException{
Properties prop
= new Properties();
BufferedReader bufr
= new BufferedReader(new FileReader("C:\\info.Properties"));
prop.load(bufr);
sop(prop);
for(String line=null;(line
= bufr.readLine())!=null;){
String[]
map = line.split("=");
prop.setProperty(map[0],map[1]);
}
String one
= prop.getProperty("111");
sop(one);
bufr.close();
}
public
staticvoid sop(Objectobj){
System.out.println(obj);
}
}
IO流(PrintWriter)
打印流
PrintWriter 与 PrintStream。可以直接操作输入流和文件。
/*
打印流
该流提供了打印方法,可以将各种数据烈性的数据都原样打印。
字节打印流
PrintStream
构造函数可以接受的参数类型
1、file对象。
2、字符串路径。String
3、字节输出流 OutpuStream
字符打印流
PrintWriter
构造函数可以接受的参数类型
1、file对象。
2、字符串路径。String
3、字节输出流 OutpuStream
4、字符输出流 Writer
*/
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.FileWriter;
public class Test{
public staticvoid main(String...args)throws IOException{
BufferedReader bufr =new BufferedReader(new InputStreamReader(System.in));
PrintWriter out =new PrintWriter(new FileWriter("C:\\1.Java"),true);
for(String line = null;(line=bufr.readLine())!=null;){
if("over".equals(line))
break;
out.println(line);
/*
由于PrintWriter加入一个参数,true表示自动刷新,所以这里就不用刷新。
out.flush();
*/
}
bufr.close();
out.close();
}
}
IO流(合并流)
序列流、
SequenceInputStream。对多个流进行合并
import java.util.Vector;
import java.io.FileInputStream;
import java.io.SequenceInputStream;
import java.io.IOException;
import java.io.FileOutputStream;
import java.util.Enumeration;
public class Test{
public staticvoid main(String...args)throws IOException{
Vector<FileInputStream>
v = new Vector<FileInputStream>();
v.add(new FileInputStream("C:\\1.Java"));
v.add(new FileInputStream("C:\\2.Java"));
v.add(new FileInputStream("C:\\3.Java"));
Enumeration <FileInputStream>en
= v.elements();
SequenceInputStream sis
= new SequenceInputStream(en);
FileOutputStream fos =new FileOutputStream("C:\\4.Java");
byte[] buf =new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
sis.close();
fos.close();
}
}
IO流(切割文件)
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Enumeration;
import java.io.SequenceInputStream;
public class Test{
public staticvoid main(String...args)throws IOException{
splitFile();
merge();
}
public staticvoid splitFile()throws IOException{
FileInputStream fis =new FileInputStream("C:\\Dj - 赶着马车去北京.mp3");
FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];
int len = 0;
int count= 1;
while((len=fis.read(buf))!=-1){
fos = new FileOutputStream("D:\\Dj - 赶着马车去北京"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
public staticvoid merge()throws IOException{
ArrayList<FileInputStream>al = new ArrayList<FileInputStream>();
for(int x=1;x<=3;x++){
al.add(new FileInputStream("D:\\Dj - 赶着马车去北京"+x+".part"));
}
final Iterator<FileInputStream>it = al.iterator();
Enumeration<FileInputStream>en =new Enumeration<FileInputStream>(){
publicboolean hasMoreElements(){
return it.hasNext();
}
public FileInputStream nextElement(){
return it.next();
}
};
SequenceInputStream sis =new SequenceInputStream(en);
FileOutputStream fos =new FileOutputStream("E:\\Dj - 赶着马车去北京.mp3");
byte[] buf = new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}
相关文章推荐
- 黑马程序员Java培训、Android培训-Java 学习过程记录_面向对象下2
- java中File类的简单使用-黑马程序员
- 黑马程序员---Java基础--09天(面向对象之四异常)
- 黑马程序员_java学习日记_面向对象
- 黑马程序员-Java语言基础–面向对象 第8天
- 黑马程序员-java基础 file类
- 黑马程序员Java培训、Android培训-Java 学习过程记录_面向对象上2
- 黑马程序员---Java基础--07天(面向对象之三)
- 黑马程序员-----笔记整理(java基础五-------面向对象--多态)
- 黑马程序员学习笔记四——Java 面向对象 特点之 继承
- 黑马程序员Java培训和Android培训:面向对象
- 黑马程序员——Java基础之面向对象(2)——第八篇
- 黑马程序员——Java基础之面向对象(1)——第七篇
- 黑马程序员---Java基础--08天(面向对象之三多态)
- 黑马程序员:java课程要点-面向对象
- 黑马程序员Java培训、Android培训-Java 学习过程记录_面向对象下3
- 黑马程序员——Java基础之面向对象——第六篇
- 黑马程序员——Java基础之面向对象(4)——第十篇
- 黑马程序员-Java语言基础 –面向对象 第6天
- 黑马程序员—4、JAVA基础&面向对象