--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------
File类
概述：文件和目录路径名的抽象表示形式，该类的出现时对文件系统中的文件以及文件夹进行对象的封装，可以通过对象的思想来操作文件以及文件夹
创建方式：
File(String filename)//将一个字符串路径封装成Filed对象，该路径可以存在也可以不存在
示例：File f=new File("d:\\mytxt\\1.txt")
File(String parent,String child)//将一个字符串文件目录和文件名，封装成File对象
示例 File f=new File("d:\\mytxt"，"1.txt ")
File(File parent,String child)//将一个File对象和文件名字符串封装成对象
示例 File d=new File("d:\\mytxt")
File f=new File(d,"1.txt ")
特殊字段：File.separator 跨平台的目录分割符
示例：File f=new File("d: "+File.separator+ "mytxt "+File.separator+ "1.txt")
常见方法
创建
boolean creatNewFile()：如果要创建的文件已经存在，则不创建
boolean mikdir()：创建文件夹
boolean mikdirs()：创建多级文件夹
删除
boolean delete()：可用来删除文件或者文件夹
注意：对于文件夹只能删除空文件夹，对于非空文件夹，不可以直接删除，需要先删除文件夹里的内容再删除文件夹
void deleteOnExit()：系统退出时执行删除动作
判断
boolean canExecute()：判断是否为可执行文件
boolean exists()：判断文件是否存在
boolean isFile()：判断是否是文件
boolean isDirectory()：判断是否是文件夹
boolean isAbsolute();//文件是否是绝对路径
boolean isHidden();//是否是隐藏文件，在获取硬盘文件或者文件夹时，对于系统目录中的文件，java是无法访问的，所以在遍历时，可用于避免遍历隐藏文件
获取
String getName();//获取文件名
String getPath()//获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）
String getParent();//获取文件父目录。返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。如果相对路径中有上一层目录，那么该目录就是返回结果。String getAbsolutePath();//获取文件的绝对路径
long lastModified();//返回文件最后一次被修改的时间long length();//返回文件长度static File[] listRoots();//列出可用的文件系统根目录，即系统盘符
String[] list();//列出当前目录下所有文件，包括隐藏。调用list方法的file对象必须是封装了一个目录。该目录必须存在
String[]list(FilenameFilter filter);//返回一个字符串数组，获取目录中满足指定过滤器的文件或目录。FilenameFilter：文件名过滤器，是一个接口，其中包含一个方法，
accept(Filedir,String name)，返回的是boolean型，对不符合条件的文件过滤掉。
File[] listFiles();//返回一个抽象路径名数组，获取当前文件夹下的所有文件和文件夹
File[] ListFiles(FilenameFilterfilter);//返回抽象路径名数组，获取目录中满足指定过滤器的文件或目录。
重命名
renameTo(File file)
File f1=new File("d:\\mytxt\\1.txt")
File f2=new File("d:\\mytxt\\2.txt")
f1. renameTo(f2)//将f1中封装的文件名更改为f2中的文件名
获取一个目录下的所有.java文件
代码示例
import java.io.*;
class FileDemo
{
public static void main(String[] args)
{
File dir=new File("e:\\java \\day20");
//传入FilenameFilter匿名内部类子类对象，并复写accept方法
String[] javaFile=dir.list(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
return name.endsWith(".java");//判断文件名是否是以.java结尾
}
});
System.out.println("len:"+javaFile.length);
for (String s : javaFile )
{
System.out.println(s);
}
}
}
递归
概述：当方法内部还需要使用方法内容时，就出现了方法自身调用自身，这种编程手法叫做递归，可以参考电影《盗梦空间》中的多重梦境
注意
要限定条件来结束，避免死循环
注意递归的次数，避免内存溢出
练习使用递归方法列出所有文件
import java.io.*;
public class FileDemo2
{
public static void main(String[] args)
{
File dir = new File("e:\\demodir");
listAll(dir,0);
}
public static void listAll(File dir,int level) {
System.out.println(getSpace(level)+dir.getName());
//获取指定目录下当前的所有文件夹或者文件对象
level++;
File[] files = dir.listFiles();
for(int x=0; x<files.length; x++){
if(files[x].isDirectory()){
listAll(files[x],level);
}
else
System.out.println(getSpace(level)+files[x].getName());
}
}
private static String getSpace(int level) {
StringBuilder sb = new StringBuilder();
sb.append("|--");
for(int x=0; x<level; x++){
sb.insert(0,"| ");
}
return sb.toString();
}
}
练习，删除带目录的文件夹
代码示例
import java.io.*;
public class FileDemo3
{
public static void main(String[] args)
{
File dir=new File("e:\\java\\day22");
}
public static void removeDir(File dir)
{
File[] files = dir.listFile();
for(int i = 0;i<files.length;i++)
{
if(files[i].isDirectory&&!files[i].isHidden())
removeDir(files[i]);//如果是文件夹则继续调用函数
else
//如果是文件则删除。注意删除的时候打印删除的结果，防止误删或者重删的情况
System.out.println(files[i].toString()+"::"+files[i].delete());
}
System.out.println (dir+"::"+dir.delete());
}
}
练习-将文件中所有的.java文件的绝对路径存储到一个文本文件中
代码示例
import java.io.*;
public class Test
{
public static void main(String[] args) throws IOException
File dir = new File("e:\\java0331");
FilenameFilter filter = new FilenameFilter()
{
public boolean accept(File dir, String name)
{
return name.endsWith(".java");
}
};
List<File> list = new ArrayList<File>();
getFiles(dir,filter,list);
File destFile = new File(dir,"javalist.txt");
write2File(list,destFile);
public static void getFiles(File dir,FilenameFilter filter,List<File> list){
File[] files = dir.listFiles();
for(File file : files){
if(file.isDirectory()){
getFiles(file,filter,list);
}else{
//对遍历到的文件进行过滤器的过滤。将符合条件File对象，存储到List集合中。
if(filter.accept(dir, file.getName())){
list.add(file);
}
}
}
}
public static void write2File(List<File> list,File destFile)throws IOException{
BufferedWriter bufw = null;
try {
bufw = new BufferedWriter(new FileWriter(destFile));
for(File file : list){
bufw.write(file.getAbsolutePath());
bufw.newLine();
bufw.flush();
}
} /*catch(IOException e){
throw new RuntimeException("写入失败");
}*/finally{
if(bufw!=null)
try {
bufw.close();
} catch (IOException e) {
throw new RuntimeException("关闭失败");
}
}
}
}Properties类
概述：该类是hashtable的子类，该类型不需要泛型，因为该类中存放的键值对都是String类型。是集合中与io技术相结合的类。
常用方法
存入键值对
setProperty(key,value)
通过键获取值
getProperty(key)
获取属性列表
propertyNames()
Set<String> stringPropertyNames()//Jdk1.6之后获取元素所有键元素
返回属性列表，并通过打印流，输出到指定的目的地
list(PrintStream)
list(PrintWriter)
将流中的规则数据加载进集合，
load(InputStream)
load(Reader)
将属性列表写入输出流中
store(OutputStream,String comment)
store(Writer,String comment)
代码演示
class PropertiesDemo
{
public static void main(String[] args)
{
Properties prop = new Properties();
prop.setProperty("张三","25");
prop.setProperty("李四","27");
prop.setProperty("王五","20");
String value = prop.getProperty("张三");
Systrm.out.println(value);
Set<String> keys = prop.stringPropertyName();
for(String key : keys)
{
System.out.println(key+"="+prop.getPropety(key));
}
}
}
小练习，记录程序使用次数，如果次数已到，则提示用户注册
代码示例
public class PropertiesTest
{
public static void main(String[] args) throws IOException
{
getCount()；
}
public static void getCount() throws IOException{
//将配置文件封装成File对象。
File confile = new File("count.properties");
if(!confile.exists()){
confile.createNewFile();
}
FileInputStream fis = new FileInputStream(confile);
Properties prop = new Properties();
prop.load(fis);
//从集合中通过键获取次数。
String value = prop.getProperty("time");
//定义计数器。记录获取到的次数。
int count =0;
if(value!=null){
count = Integer.parseInt(value);
if(count>=5){
// System.out.println("使用次数已到，请注册，给钱！");
// return;
throw new RuntimeException("使用次数已到，请注册，给钱！");
}
}
count++;
//将改变后的次数重新存储到集合中。
prop.setProperty("time", count+"");
FileOutputStream fos = new FileOutputStream(confile);
prop.store(fos, "");
fos.close();
fis.close();
}
}
打印流
概述：打印流中包含了PrintWriter和PrintStream，该流中没有对应的输入流
特点：该流提供了打印方法，可将各种类型数据都原样打印
PrintWriter
字符打印流
该构造函数可以接收四种类型的值
字符串路径
File对象
接收这两种类型参数时，还可以指定编码表
OutputStram
Writer
接收这两种类型参数时，可以指定自动刷新，传入true即可，
代码示例
public class PrintWriterDemo
{
public static void main(String[] args) throws IOException
{
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(new FileWriter("out.txt"),true);
String line = null;
while((line=bufr.readLine())!=null){
if("over".equals(line))
break;
out.println(line.toUpperCase());
}
out.close();
bufr.close();
}
}
序列流
概述：序列流又称合并流，可以将多个读取流合并成一个流，可以实现文件的合并等功能
原理：其实就是将每一个读取流对象存储到一个集合中，读取其中的数据，以最后一个流对象的结尾作为该流的结尾
构造函数
SequenceInputStream(InputStream in1,InputStream in2)
将两个读取流合并成一个流
SequenceInputStream(Enumeration<? Extends InputStream> en)
将多个流存入集合后可实现多个流合并
练习文件切割
代码示例
class SplitFileDemo
{
public static void main(String[] args) throws Exception
{
File file = new File("c:\\1.mp3");
splitFile (file);
}
private static void splitFile (File file) throws IOException
{
// 用读取流关联源文件。
FileInputStream fis = new FileInputStream(file);
// 定义一个1M的缓冲区。
byte[] buf = new byte[1024*1024];
// 创建目的。
FileOutputStream fos = null;
int len = 0;
int count = 1;
Properties prop = new Properties();
File dir = new File("c:\\partfiles");
if (!dir.exists())
dir.mkdirs();
while ((len = fis.read(buf)) != -1) {
fos = new FileOutputStream(new File(dir, (count++) + ".part"));
fos.write(buf, 0, len);
fos.close();
}
//将被切割文件的信息保存到prop集合中。
prop.setProperty("partcount", count+"");
prop.setProperty("filename", file.getName());
fos = new FileOutputStream(new File(dir,count+".properties"));
//将prop集合中的数据存储到文件中。
prop.store(fos, "save file info");
fos.close();
fis.close();
}
public static void splitFile(File file) throws IOException {
// 用读取流关联源文件。
FileInputStream fis = new FileInputStream(file);
// 定义一个1M的缓冲区。
byte[] buf = new byte[1024*1024];
// 创建目的。
FileOutputStream fos = null;
int len = 0;
int count = 1;
File dir = new File("c:\\2.mp3 ");
if (!dir.exists())
dir. creatNewFile();
while ((len = fis.read(buf)) != -1) {
fos = new FileOutputStream(new File(dir, (count++) + ".part"));
fos.write(buf, 0, len);
}
fos.close();
fis.close();
}
}
练习-合并多个读取流
代码示例
import java.util.*;
import java.io.*;
class SequenceInputStreamDemo
{
public static void main(String[] args)throws IOException
{
ArrayList<InputStream> al=new ArrayList<InputStream>();//创建ArrayList集合，并添加相关流对象
al.add(new FileInputStream("1.txt"));
al.add(new FileInputStream("2.txt"));
al.add(new FileInputStream("3.txt"));
Iterator<InputStream>=al.iterator()；
Enumeration<InputStream> en=new Enumeration<InputStream>()
{
public boolean hasMoreElements()
{
return it.hasNext();
}
public InputStream nextElement()
{
return it.next();
}
}//创建枚举子类对象
SequenceInputStream sis=new SequenceInputStream(en);//合并流
FileOutputStream fos=new FileOutputStream("4.txt");//关联写入文件
//反复读写操作
byte[] buf=new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
//关流
fos.close();
sis.close();
}
--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
