File类：
File类常见操作：
1，创建。
boolean createNewFile()):
和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
2，删除。
3，判断。
文件是否存在.
isFile(): 是否文件
isDirectory();是否目录
isHidden(); 是否隐藏
isAbsolute(); 是否绝对（是否绝对路径）
4，获取信息。
getName();
getPath();
getParent(); 获取父目录，若无父目录，则返回null
getAbsolutePath() 获取绝对路径
long lastModified() 获取最后修改时间
long length() 获取文件长度
File.separator：当前系统的目录分隔符，windows为"/"
package tan;
import java.io.File;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
// consMethod();
// method_1();
// method_2();
// method_3();
// method_4();
method_5();
}
//剪切重命名
public static void method_5() {
File f1 = new File("c:\\Test.java");
File f2 = new File("d:\\hahah.java");
sop("rename:" + f2.renameTo(f1));
}
public static void method_4() {
File f = new File("file.txt");
sop("path:" + f.getPath());
sop("abspath:" + f.getAbsolutePath());
sop("parent:" + f.getParent());// 该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。
// 如果相对路径中有上一层目录那么该目录就是返回结果。
}
public static void method_3() throws IOException {
File f = new File("c:\\ttt\\file2.txt");
// f.createNewFile();
// f.mkdir();
// 记住在判断文件对象是否是文件或者目录时，必须要先判断该文件对象封装的内容是否存在。
// 通过exists判断。
sop("dir:" + f.isDirectory());
sop("file:" + f.isFile());
sop("绝对路径？"+f.isAbsolute());
}
//判断以及创建文件夹
public static void method_2(){
File f=new File("file.txt");
sop("exists:"+f.exists()); //是否存在
sop("execute:"+f.canExecute());//是否可执行
// 创建文件夹
File dir = new File("abc\\tk\\a\\a\\dd\\ee\\qq\\aaa");
sop("mkdir:" + dir.mkdirs());//创建多级文件夹，若是dir.mkdir()则只能创建一级文件夹
}
//创建File文件，删除文件
public static void method_1() throws IOException {
File f = new File("file.txt");
sop("create:"+f.createNewFile());
// sop("delete:"+f.delete());
}
//1、创建file对象共同的方法
public static void consMethod(){
File f1=new File("a.txt");
File f2=new File("c:\\abc","a.txt");
File d=new File("c:\\abc");
File f3=new File(d,"c.txt");
sop("f1:"+f1);
sop("f2:"+f2);
sop("f3:"+f3);
File f4=new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
}
public static void sop(Object obj){
System.out.println(obj);
}
}列出指定目录下的文件
package tan;
import java.io.*;
class FileDemo2 {
public static void main(String[] args) {
// listRootsDemo();
listDemo();
// listDemo_2();
}
//列出C盘目录下的所有文件
public static void listDemo_3() {
File dir = new File("c:\\");
File[] files = dir.listFiles();
for (File f : files) {
System.out.println(f.getName() + "::" + f.length());
}
}
//列出所有以.exe结尾的文件
public static void listDemo_2() {
File dir = new File("d:\\kuGou");
String[] arr = dir.list(new FilenameFilter() {//文件名过滤
public boolean accept(File dir, String name) {
return name.endsWith(".exe");
}
});
System.out.println("len:" + arr.length);
for (String name : arr) {
System.out.println(name);
}
}
// 调用list方法的file对象必须是封装了一个目录。该目录还必须存在。（类似于DOS中DIR）
public static void listDemo() {
File f = new File("c:\\");
String[] names = f.list();
for (String name : names) {
System.out.println(name);
}
}
//列出硬盘盘符
public static void listRootsDemo() {
File[] files = File.listRoots();//列出硬盘盘符（C、D、E、F、G）
for (File f : files) {
System.out.println(f);
}
}
}
递归遍历多级目录文件
列出指定目录下文件或者文件夹，包含子目录中的内容。也就是列出指定目录下所有内容。
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可，在列出过程中出现的还是目录的话，还可以再次调用本功能。也就是函数自身调用自身。这种表现形式，或者编程手法，称为递归。
递归要注意：
1，限定条件。
2，要注意递归的次数。尽量避免内存溢出。
package tan;
import java.io.File;
public class ShowDir {
public static void main(String[] args) {
File dir=new File("d:\\WWW");
showDir(dir,0);//从0级目录开始遍历
}
//加目录层级
public static String getLevel(int level){
StringBuilder sb=new StringBuilder();
sb.append("|--");
for(int x=0;x<level;x++){
// sb.append("|--");
sb.insert(0, "| ");
}
return sb.toString();
}
//列出指定目录下文件或者文件夹，包含子目录中的内容。也就是列出指定目录下所有内容。
public static void showDir(File dir,int level) {
System.out.println(dir);
level++;
File[] files = dir.listFiles();
for (int x = 0; x < files.length; x++) {
if (files[x].isDirectory()) {
showDir(files[x],level);
}else{
System.out.println(getLevel(level)+files[x]);
}
}
}
}toBin方法图解：
删除一个带内容的目录
package tan;
/*
删除一个带内容的目录。
删除原理：
在window中，删除目录从里面往外删除的。
既然是从里往外删除。就需要用到递归。
*/
import java.io.*;
class RemoveDir {
public static void main(String[] args) {
File dir = new File("c:\\testDir");
removeDir(dir);
}
//注意：java删除是不走回收站的
public static void removeDir(File dir) {
File[] files = dir.listFiles();
for (int x = 0; x < files.length; x++) {
//java不能访问隐藏文件，所以遍历的时候最好判断下(!files[x].isHidden())&&files[x].isDirectory()
if (files[x].isDirectory())
removeDir(files[x]);
else //遍历删除目录内部文件
System.out.println(files[x].toString() + ":-file-:"
+ files[x].delete());
}
//文件被删除完就开始删除文件夹
System.out.println(dir + "::dir::" + dir.delete());
}
}
获取目录下的所有java文件
/*
练习
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中,建立一个java文件列表文件。
思路：
1，对指定的目录进行递归。
2，获取递归过程所以的java文件的路径。
3，将这些路径存储到集合中。
4，将集合中的数据写入到一个文件中。
*/
package tan;
import java.io.*;
import java.util.*;
class JavaFileList {
public static void main(String[] args) throws IOException {
File dir = new File("G:\\#学习视频#\\#黑马程序员自学教程#\\java基础\\毕向东_Java基础源代码\\day20");
List<File> list = new ArrayList<File>();
fileToList(dir, list);
// System.out.println(list.size());
File file = new File(dir, "javalist.txt");
writeToFile(list, file.toString());
//file.toString();表示G:\\#学习视频#\\#黑马程序员自学教程#\\java基础\\毕向东_Java基础源代码\\day20\\javalist.txt
}
//将.java文件存入到list集合中
public static void fileToList(File dir, List<File> list) {
File[] files = dir.listFiles();
for (File file : files) {
if (file.isDirectory())
fileToList(file, list);
else {
if (file.getName().endsWith(".java"))
list.add(file);
}
}
}
//传入参数为：list集合，java列表文件(javalist.txt)
public static void writeToFile(List<File> list, String javaListFile)throws IOException {
BufferedWriter bufw = null;
try {
//向javalist.txt文件中写入文本列表
bufw = new BufferedWriter(new FileWriter(javaListFile));
//遍历列表
for (File f : list) {
//获取每一个文件的绝对路径
String path = f.getAbsolutePath();
bufw.write(path);
bufw.newLine();//换行
bufw.flush();
}
} catch (IOException e) {
throw e;
} finally {
try {
if (bufw != null)
bufw.close();
} catch (IOException e) {
throw e;
}
}
}
}Properties属性
Properties是HashTable的子类，也就是说它具备Map集合的特点，而且它里边存储的键值对都是字符串，它是集合中和IO技术相结合的集合容器。该对象的特点：可以用于键值对形式的配置文件。在加载数据时，需要数据有固定格式：键=值。
Properties存储配置信息的局限：比如存入复制的内容，比如一个Person的属性，这时用XML比较方便且容易区分，java中提供了Document类与之对应，用于取出XML中的信息，但是因为操作比较麻烦，于是有人开发了新的具DOM4J（dom for java）。
/*
Properties是hashtalbe的子类。
也就说他具备map集合的特点，而且它里边存储的键值对都是字符串。
是集合和IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件。
在加载数据时，需要数据有固定格式：键=值；
*/
package tan;
import java.io.*;
import java.util.*;
public class PropertiesDemo {
public static void main(String[] args) throws IOException {
// setAndGet();
// method_01();
loadDemo();
}
//1、设置和获取元素。
public static void setAndGet(){
Properties prop=new Properties();
prop.setProperty("tzq", "22");
prop.setProperty("tan", "22");
prop.setProperty("xiao", "22");
System.out.println(prop);
//演示getProperty
String value=prop.getProperty("tan");
System.out.println(value);
//修改属性值
prop.setProperty("tan", "23");
//返回所有的键和值
Set<String>names=prop.stringPropertyNames();
for(String s:names){
System.out.println(s+":"+prop.getProperty(s));
}
}
// 2、演示，如何将流中的数据存储到集合中。
// 想要将info.txt中键值数据存到集合中进行操作。
/*思路：
* 1，用一个流和info.txt文件关联。
* 2，读取一行数据，将该行数据用"="进行切割。
* 3，等号左边作为键，右边作为值。存入到Properties集合中即可。
*/
public static void method_01() throws IOException{
BufferedReader bufr=new BufferedReader(new FileReader("info.txt"));
String line=null;
Properties prop=new Properties();
while((line=bufr.readLine())!=null){
String []arr=line.split("=");
prop.setProperty(arr[0], arr[1]);
// System.out.println(arr[0]+"..."+arr[1]);
}
bufr.close();
System.out.println(prop);
}
//3、以上方法中每次都需要从硬盘中读取数据往里存写这个方法比较麻烦，因此可以选择load方法
//void load(InputStream inStream) 从输入流中读取属性列表（键和值）早期都是加载字节流从
//从1.6版本之后开始使用字符流
public static void loadDemo() throws IOException{
//创建properties集合
Properties prop=new Properties();
//关联文件
FileInputStream fis=new FileInputStream("info.txt");
//将流中的数据加载进集合
prop.load(fis);
//练习：修改数据
prop.setProperty("tan", "26");//改变的是内存
FileOutputStream fos=new FileOutputStream("info.txt");
prop.store(fos, "xiaoqiang");
// System.out.println(prop);
prop.list(System.out);//列出集合目录
fos.close();
fis.close();
}
}<strong><span style="color:#ff0000;">
</span></strong>练习：记录应用程序运行次数
/*DEMO
用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示。
很容易想到的是:计数器。
可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。
可是随着该应用程序的退出，该计数器也在内存中消失了。
下一次在启动该程序，又重新开始从0计数。
这样不是我们想要的。
程序即使结束，该计数器的值也存在。
下次程序启动在会先加载该计数器的值并加1后在重新存储起来。
所以要建立一个配置文件。用于记录该软件的使用次数。
该配置文件使用键值对的形式。
这样便于阅读数据，并操作数据。
键值对数据是map集合。
数据是以文件形式存储，使用io技术。
那么map+io -->properties.
配置文件可以实现应用程序数据的共享。
*/
package tan;
import java.io.*;
import java.util.*;
class RunCount {
public static void main(String[] args) throws IOException {
Properties prop = new Properties();
File file = new File("count.ini");//为防止文件不存在而发生的异常，用File对象
if (!file.exists())
file.createNewFile();
FileInputStream fis = new FileInputStream(file);
prop.load(fis);//加载到Properties
int count = 0;
String value = prop.getProperty("time");//获取对应time键的值
if (value != null) {
count = Integer.parseInt(value);//将字符串转为Int类型
if (count >= 5) {
System.out.println("您好，使用次数已到，请付费后使用!");
return;
}
}
count++;
prop.setProperty("time", count + "");//内存存储，转为字符串
FileOutputStream fos = new FileOutputStream(file);
prop.store(fos, "注释信息");//物理存储
fos.close();
fis.close();
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
