Java——File类和Properties类

File类

File类是对文件和文件目录进行抽象的类，从而简化对文件的直接操作。
创建File对象时，可以对已存在或未存在的文件和目录名进行封装，许多对文件进行操作的流对象的构造函数都可以传入File对象。

构造方法：
相对路径：
File f = new File("a.txt");
绝对路径：
File d= new File("c:\\abc");

目录加文件名：
File f2=newFile("c:\\abc","b.txt");

常用方法：
1、创建：
boolean createNewFile() //创建新文件，返回true，如果文件已存在，则不作操作并返回false，区别于流的创建（流对象创建文件，已存在会覆盖）
boolean mkdir() //创建一级文件夹
boolean mkdirs() //创建多级文件夹
2、删除：
boolean delete() //删除文件 成功删除则返回true
boolean deleteOnExit() //在程序退出时删除文件
3、判断：
boolean canExecute();//是否是可执行文件

boolean exists();//文件是否存在

boolean isFile();//是否是文件

boolean isDirectory();//是否是文件夹

boolean isHidden();//是否是隐藏文件

boolean isAbsolute();//文件是否是绝对路径
注意：在判断文件对象是否是文件或者目录时，必须先用exists()判断该文件对象是否存在。
4、获取属性：
String getName() //获取文件名

String getPath() //获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）

String getParent() //获取文件父目录。返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。如果相对路径中有上一层目录，那么该目录就是返回结果。

String getAbsolutePath() //获取文件的绝对路径

long lastModified() //返回文件最后一次被修改的时间

long length() //返回文件长度

其他方法：
String[] list() //列出当前目录下所有文件。

String[] list(FilenameFilter filter) //返回一个路径名数组，获取目录中满足指定过滤器的文件或目录。

File[] listFiles() //列出当前目录下所有文件，将路径下的文件封装成File对象并返回

File[] listFiles(FilenameFilter filter) //加入过滤器

文件过滤器的使用方法是：复写filter对象的accept(File file, String name)方法，已此方法来决定是否返回true，否则过滤掉。
示例：

import java.io.*;

class FileDemo2
{
public static void main(String[] args)
{
//listRootsDemo();
//listDemo();
File dir = new File("E:\\my\\app\\eclipse\\heimaPractice");
File[] files = dir.listFiles();
for(File f : files)
{
print(f.getName()+ " : " + f.length());
}

}

public static void filenameFileter()
{
File dir = new File("E:\\my\\app\\eclipse\\heimaPractice");
String[] lists = dir.list(new FilenameFilter()
{
public boolean accept(File dir, String name)
{
return name.endsWith(".java");
}
});

print("len: " + lists.length);
for(String s : lists)
{
print(s);
}
}

练习一：打印一个指定目录下所以文件列表
思想：用递归方式将每一个文件夹视为根目录，如果有子文件夹，则对子文件夹进行相同的操作，直到遍历所以文件。
递归退出条件：File对象不是目录，也就是isDirectory()返回false
代码：

import java.io.File;

class FileDemo3
{
public static void main(String[] args)
{
File dir = new File("E:\\my\\app\\c-cpp");
showList(dir, 0);
}

public static String getLevel(int level)
{
StringBuilder sb = new StringBuilder();
for(int i = 0; i < level; i++)
{
sb.append("  ");
}

return sb.toString();
}

public static void showList(File dir, int level)
{
print(getLevel(level) + dir);
level ++;
File[] files = dir.listFiles();
for(int i = 0; i < files.length; i++)
{

if(files[i].isDirectory())
showList(files[i], level);
else
print(getLevel(level) + files[i]);
}
}

public static void print(Object obj)
{
System.out.println(obj);
}
}

练习二：删除指定目录下的所有文件。
思想：类似遍历所以文件，同样用递归的方法，遍历到文件而不是文件夹时，将其删除，如果是目录则对其进行递归，如果目录为空则将文件夹删除。
递归退出条件：File对象不是目录，也就是isDirectory()返回false，并在每次目录递归后删除当前目录。
代码：

import java.io.File;
//删除指定目录下的所有文件和文件夹
class RemoveDir
{
public static void main(String[] args)
{
removeDir(new File("removeDir"));
//System.out.println(new File("removeDir").delete());
}

public static void removeDir(File dir)
{
File[] files = dir.listFiles();
for(int i = 0; i < files.length; i++)
{
if(files[i].isDirectory())
{
removeDir(files[i]);
}else
{
System.out.println((files[i].toString() +"::"+ files[i].delete()));
}
}
System.out.println(dir.toString() +"::" + dir.delete());
}
}

[b]Properties类[/b]
Properties类是对“属性 = 值”这种储存形式进行封装的类，所以它是HashTable类的子类，储存的元素是键值对，键和值都是字符串。

常用方法：
1、设置
Object setProperty(String key,String value) //设置键值

2、获取
String getProperty(String key) //通过键值获取属性值

Set<String> stringPropertiesName() //获取属性名的set集合
3、存储
void load(InputStream is) //从指定字节输入流获取键值对信息
void load(Reader r) //从指定字符输入流获取键值对信息
4、输出
void list(PrintStream ps) //将键值对信息从打印流输出
void store(OutpurStream os, String comments) //将键值对信息储存进指定输出流，comments是附加信息
void store(Writer w, String comments) //功能同上

示例：将一个存储键值对的文本信息读出，存入Properties对象。

import java.io.*;
import java.util.*;

class PropertiesDemo
{
public static void main(String[] args)
{
//setAndGet();
File list = new File("list.txt");
Properties prop = new Properties();
valueToList(list, prop);
}

//将txt文本中的键值数据，放到集合中操作
public static void valueToList(File list, Properties prop)throws IOException
{
String pair = null;
BufferedReader bufr = new BufferedReader(new FileReader(list));
while((pair = bufr.readLine()) != null)
{
int cutPos =  pair.indexOf('=');
String key = pair.substring(0, cutPos);
String value = pair.substring(cutPos + 1);
prop.setProperty(key, value);
}
bufr.close();
}

练习：将程序运行次数存入配置文件，每运行一次加一，运行到五次后提示“注册”。

import java.util.*;
import java.io.*;

//记录程序运行次数，如果次数已到 则出现注册提示
class PropertiesTest
{
public static void main(String[] args)throws IOException
{
RunCount();
}

public static void RunCount()throws IOException
{
Properties prop = new Properties();
File file = new File("count.ini");
if(! file.exists())
{
file.createNewFile();
}

FileInputStream fis = new FileInputStream(file);

prop.load(fis);//load方法可以直接将文本按格式读出，并存入Properties数组
int count = 0;
String value = prop.getProperty("time");
if(value != null)
{
count = Integer.parseInt(value);
if(count >= 5)
{
System.out.println("please register");
fis.close();
return ;
}
}
count ++;

prop.setProperty("time", count + "");

FileOutputStream fos = new FileOutputStream(file);
prop.store(fos, "");

fos.close();
fis.close();
}
}

打印流类

打印流的目的是方便打印，特有方法是println，print，printf。printf可以接受format参数，从而按照指定格式打印。
打印流包括Printstream和PrintWriter，分别是打印字节流和打印字符流。
应用示例：

import java.io.*;

class  PrintStreamDemo
{
public static void main(String[] args) throws IOException
{
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));

PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);//自动刷新

String line = null;

while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
out.println(line.toUpperCase());
}
out.close();
bufr.close();

}
}

SequenceInputStream类

SequenceInputStream可以将几个流合按顺序操作，好像将他们合成一个流。构造函数中可以传入两个或多个输入流，如果传入多个，则传入的是一个

Enumeration对象，也就是Vector的迭代器。
示例：

import java.io.*;
import java.util.*;

class SequenceInputStreamDemo
{
public static void main(String[] args)throws IOException
{
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("1.txt"));
v.add(new FileInputStream("2.txt"));
v.add(new FileInputStream("3.txt"));

Enumeration<FileInputStream> en = v.elements();
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();
}
}

分割文件：将一个文件分为大小相同的几份。

import java.io.*;
import java.util.*;

class SplitFileDemo
{
public static void main(String[] args)throws IOException
{
File f = new File("test.mp3");
splitFile(f);
}

public static void splitFile(File file)throws IOException
{
FileInputStream fis = new FileInputStream(file);
int count = 0;
byte[] buf = new byte[1024*1024*2];
int len = 0;
FileOutputStream fos = null;

while((len = fis.read(buf)) != -1)
{
fos = new FileOutputStream("test" + count++ + ".part");

fos.write(buf, 0, len);
fos.close();
}
fis.close();
}
}