Java面向对象——File类
面向对象
File类
1、用来将文件或者文件夹封装成对象
2、方便对文件与文件夹进行操作
3、File对象可以作为参数传递给流的构造函数。
4、了解File类中的常用方法。
File
static Stringseparator
与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
import java.io.File;
public class Test{
public static void 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 static void sop(Object obj){
System.out.println(obj);
}
}
IO流(File对象功能-创建和删除)
File类
booleancreateNewFile()
当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
booleanmkdir()
创建此抽象路径名指定的目录。booleanmkdirs()
创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
booleandelete()
删除此抽象路径名表示的文件或目录。voiddeleteOnExit()
在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。import java.io.File;
import java.io.IOException;
public class Test{
public static void 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 static void sop(Object obj){
System.out.println(obj);
}
}
IO流(File对象功能-判断)
booleanexists()
测试此抽象路径名表示的文件或目录是否存在。
booleanisAbsolute()
测试此抽象路径名是否为绝对路径名。booleanisDirectory()
测试此抽象路径名表示的文件是否是一个目录。booleanisFile()
测试此抽象路径名表示的文件是否是一个标准文件。booleanisHidden()
测试此抽象路径名指定的文件是否是一个隐藏文件。import java.io.File;
import java.io.IOException;
public class Test{
public static void 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 static void sop(Object obj){
System.out.println(obj);
}
}
IO流(File对象功能-获取)
FilegetAbsoluteFile()
返回此抽象路径名的绝对路径名形式。StringgetAbsolutePath()
返回此抽象路径名的绝对路径名字符串。FilegetCanonicalFile()
返回此抽象路径名的规范形式。StringgetCanonicalPath()
返回此抽象路径名的规范路径名字符串。longgetFreeSpace()
返回此抽象路径名指定的分区中未分配的字节数。StringgetName()
返回由此抽象路径名表示的文件或目录的名称。StringgetParent()
返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null。FilegetParentFile()
返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回null。StringgetPath()
将此抽象路径名转换为一个路径名字符串。
booleanrenameTo(File dest)
重新命名此抽象路径名表示的文件。import java.io.File;
public classTest{
public static void main(String...args){
File f1 = new File("C:\\1.Java");
File f2 = new File("C:\\2.java");
f2.renameTo(f1);
}
}
static File[]listRoots()
列出可用的文件系统根。
String[]list()
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
import java.io.File;
public classTest{
public static void 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 static void main(String...args){
File f =new File("C:\\");
dir(f);
toBin(6);
}
/*
public static void toBin(int num){
while(num>0){
num = num/2;
sop(num%2);
}
}
*/
public static void toBin(int num){
if(num>0){
toBin(num/2);
sop(num%2);
}
}
public static void 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 static void sop(Objectobj){
System.out.println(obj);
}
}
IO流(列出目录下所有内容-带层次)
/*
列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现还是目录的话，还可以在此调用本功能
也就是函数自身调用自身，
这种表现形式，或者编程手法，成为递归
递归要注意：
1、制条件
2、要注意递归次数，避免内存溢出
*/import java.io.File;
public class Test{
public static void 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 static void 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 static void 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 static void 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 static void 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 static void 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 static void 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 static void main(String...args){
Propertiesprop = System.getProperties();
Set<String> names = prop.stringPropertyNames();
for(String name : names){
sop(name+"::"+prop.getProperty(name));
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
IO流(Properties存取配置文件)
StringgetProperty(String key)
用指定的键在此属性列表中搜索属性。StringgetProperty(String key,String defaultValue)
用指定的键在属性列表中搜索属性。voidlist(PrintStream out)
将属性列表输出到指定的输出流。voidlist(PrintWriter out)
将属性列表输出到指定的输出流。voidload(InputStream inStream)
从输入流中读取属性列表（键和元素对）。voidload(Reader reader)
按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
ObjectsetProperty(String key,String value)
调用 Hashtable 的方法put。voidstore(OutputStream out,String comments)
以适合使用load(InputStream)方法加载到Properties表中的格式，将此Properties表中的属性列表（键和元素对）写入输出流。voidstore(Writer writer,String comments)
以适合使用load(Reader)方法的格式，将此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 static void 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 static void 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 static void 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流(合并流)
序列流、
import java.util.Vector;SequenceInputStream。对多个流进行合并
import java.io.FileInputStream;
import java.io.SequenceInputStream;
import java.io.IOException;
import java.io.FileOutputStream;
import java.util.Enumeration;
public class Test{
public static void 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 static void main(String...args)throws IOException{
splitFile();
merge();
}
public static void 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 static void 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>(){
public boolean 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();
}
}
---------------------- 沐木开发笔记 TuoZou.com、. 期待与您交流！ ----------------------
1990
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
