黑马程序员_十六 【File类】【Properties类】

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------

1 File 类概述

我们硬盘上数据最常见的方式就是以文件存在的，为了方便操作这些文件，Java就在IO包中提供了File类对文件本身进行封装.

1、File类：文件和目录路径的抽象表现形式
2、特点：
1）用来将文件或文件夹封装成对象
2）方便于对文件与文件夹的属性信息进行操作
3）File对象可以作为多数传递给流的构造函数

File的作用：
|----Sop file文件会出现什么？相对路径呢，输出什么？
|----跨平台目录分隔符方法是？
|----创建文件检测方法是？返回值？如果文件已存在怎么操作？返回什么？和输出流的创建有什么区别？
|----如何删除创建的file文件？
|----如何在退出的时候删除文件？
|----测试文件能不能运行的方法？存不存在的方法？
|----流操作对象，文件存在才能操作，不存在就抛出异常，所以要先判断。这就是把文件封装成对象的好处。
|----如何创建文件夹？
|----如何创建多级目录？
|----如何判断目录和文件是否存在？判断时需要注意什么？
|----如何判断隐藏文件？
|----如何判断是否为绝对路径名？文件不存在能判断吗？
|----如何获取绝对路径和相对路径？
|----如何获取名字？
|----GetParent()?返回绝对路径下的父目录。如果获取相对路径，就返回null。本质上是返回当前文件夹的上一层目录。
|----如何获取长度？
|----lastModified()呢？
|----返回绝对路径最后一次被修改的时间的方法？返回值是什么？
|----Avalibale和length的区别？
|----如何给文件改名字？如何移动文件？
|----listRoots()怎么使用？什么作用？
|----List（）什么作用？怎么使用？返回值？如果对象为文件，返回什么？调用的对象必须有什么特点？空文件夹返回什么呢？如何利用此函数的构造函数过滤一些文件？
|----如何获得某目录下当前文件名（包含隐藏文件）？
|----如何获取一个文件内部全部的文件名？
|----如何获取文件夹全部文件名和大小？
|----递归的原理？
|----递归的什么为什么有内存溢出状态？（调用的方法太多，栈内存放不下了）
|----递归要注意什么？
File的构造方法
File(String pathname):根据指定路径名创建文件对象
File file1=new File(“d:\\a.txt”);
File(String parent,String child):根据指定的父目录和子路径创建文件对象
File file2=new File(“d:\\”,”a.txt”);
File(File parent,String child):根据指定的父目录对象和子路径创建文件对象
File file3=new File(“d:\\”);
File file4=new File(file3,”a.txt”);
File类作用：
方便对文件和文件夹属性信息进行操作
注意：流对象也可以操作对象，但是流对象不能操作文件夹。所以file类弥补了流的不足。流只能操作数据！而想操作被流封装成文件的那个信息只能用file对象。
示例演示代码：
importjava.io.*;
class FileDemo
{
public static void main(String[] args)
{
consMethod();
}
public static void consMethod()
{//将a.txt封装成file对象，可以将已有的和未出现的文件或者文件夹封装成对象
File f1 = newFile("a.txt");//创建一个f的File对象，并且封装成a.txt，因为file类中有个构造函数是这样的File(Stringpathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。没有目录就是默认当前目录。
//在指定目录下创建创建文件。
File f2 = new File("c:\\abc","b.txt");//在c盘c:\\abc中建立b.txt。如果上条指令写成c:\\abc\\a.txt，结果一样的。两种指令的区别就是这个传入的是2个参数。譬如后面不是一个文件，而是一个参数str（这个str可以是个对象）
//File的第三种构造函数，File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
File d = new File("c:\\abc");//创建一个file对象，赋值是abc文件夹
File f3 = new File(d,"c.txt");//创建一个c.txt，调用file构造函数，在d目录中创建。
sop("f1"+f1);//输出为f1a.txt，相对路径
sop("f2"+f2);
sop("f3"+f3);//输出为f3c:\abc\c.txt，sop打印的都是封装路径。结论是sop打印的是file文件中的路径，封装成什么路径，就会有什么路径打印出来
//被不同平台识别，使用目录分隔符
File f4 = newFile("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
sop(f4);//File.separator是用来实现跨平台目录分隔符的。在不同的平台都可以实现目录分离
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

File类常见方法：
1，创建。（注意有时候记不住这些命令没事，但一定要知道有这些功能，当需要用到的时候可以去查阅API使用这些功能）
boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。重点掌握
和输出流不一样，输出流对象一建立创建文件。如果文件已经存在，会覆盖。
boolean mkdir():创建文件夹。
boolean mkdirs():创建多级文件夹。
2，删除。
boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回false。
void deleteOnExit();在程序退出时删除指定文件。当流正在操作的时候无法完成操作的，这个指令的意义就在于操作完以后可以删除文件
3，判断。
canExecute():判断文件是否可以执行
boolean exists() :文件是否存在.（频率高，重点记忆）
mkdir()创建单级目录，成功就返回true，但是不能创建多级目录
mkdirs()创建多级目录，成功返回true
isFile():是否是一个文件。一个文件或者文件夹不被创建，是不会被判断到的，返回false。判断对象f返回值都是false，只有真正创建了文件（执行createNewFile()）或文件夹才能返回true。
isDirectory();是否是一个目录
isHidden();是否为隐藏文件（了解就行）
isAbsolute();是否为绝对路径，如果是绝对路径，就会返回true，不论这个文件或者文件夹是否创建（了解就行）
4，获取信息。
getName():只获取名字，返回字符串
getPath():获取路径，字符串（封装成什么路径就获取什么路径）
getParent():获取父目录，字符串上两个命令加在一起就是下面这个命令。
特殊点：该方法可以返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。如果相对路径中有上一层目录那么该目录就是返回结果。
getAbsolutePath() 获取绝对路径，字符串。上两个命令无论文件存在与否都可以得到字符串信息
了解知识：和getCanonicalFile() 的区别，getCanonicalFile的返回值是File对象，也就是将字符串封装到对象中以便使用
long lastModified()返回此抽象路径名表示的文件最后一次被修改的时间。
long length(),文件的长度。和上面的返回值都是long类型。和available()的不同是，这个是long类型，返回的值更大。
renameTo()：更改名字。f1.renameTo(f2)。更改到另一盘符地址下的时候就直接移动了，类似于剪切后换名字
流操作对象，文件存在才能操作，不存在就抛出异常，所以要先判断。这就是把文件封装成对象的好处。
例子：
importjava.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException//为什么要抛异常？因为会调用到系统内部函数，如果调用失败，如不能创建文件，那么java需要进行处理
{
//method_1();//创建并返回true
//method_1(); //创建并返回false
//method_3();
method_5();
}
public static void method_5()
{
File f1 = newFile("c:\\a.txt");
File f2 = newFile("d:\\haha.txt");
sop("rename:"+f1.renameTo(f2));//更改名字，但是如果不在一个盘下，会出现改名并移动的现象。类似于移动，剪切
}
public static void method_4()throwsIOException
{
File f = new File("abc\\file.txt");
sop("Parent:"+f.getParent());//该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。file封装的只有相对路径,那么就返回null，如果有部分相对路径，那么返回上层目录，如abc
//如果相对路径中有上一层目录那么该目录就是返回结果。
sop("path:"+f.getPath());//file.txt封装f是什么路径就打印什么路径。
sop("absolutepaty:"+f.getAbsolutePath());//D:\Javawxj\day20\file.txt假如输出一样是因为路径本身就是绝对路径。虽然文件不存在，但是路径是可以得到的
sop(f.lastModified());//返回最后的修改时间
}
public static void method_3()throwsIOException
{
File f = newFile("file.txt");
sop("dir:"+f.isDirectory());//判断是否为一个目录，为false
sop("dir:"+f.isFile());//判断是否为一个文件。为false
//记住在判断文件对象是否是文件或者目录时，必须要先判断该文件对象封装的内容是否存在。
//f.createNewFile();
//sop("dir:"+f.isDirectory());//false
//sop("dir:"+f.isFile());//true
f.mkdir();
sop("dir:"+f.isDirectory());//true
sop("dir:"+f.isFile());//false 因为文件夹创立了，文件名为file.txt
//判断是否为绝对路径
sop(f.isAbsolute());//是否为绝对路径，如果是绝对路径，就会返回true，不论这个文件或者文件夹是否创建
}
public static void method_2()throwsIOException
{
File f = newFile("FileDemo.java");
//sop("execute"+f.canExecute());//booleancanExecute()测试应用程序是否可以执行此抽象路径名表示的文件。如果有这个文件就为true，没有就是false
sop("exists:"+f.exists());//测试文件是否存在
//创建文件夹
File dir = new File("abcd\\zzz\\bb\\cc\\a\\d\\d");//在当前目录创建一个abc的文件夹，
sop("mkdir:"+dir.mkdir());//创建一个文件，并返回boolean值。如果创建多层目录，最子级目录以上的父目录必须依据存在
sop("mkdir:"+dir.mkdirs());//mkdirs()是创建多级目录的命令
}
public static void method_1()throwsIOException
{
File f = newFile("demo.txt");//建立一个对象f，为demo.txt
//sop("create:"+f.createNewFile());//返回值为布尔
sop("delete"+f.delete());//输出的是true
}
public static void consMethod()
{//将a.txt封装成file对象，可以将已有的和未出现的文件或者文件夹封装成对象
File f1 = newFile("a.txt");//创建一个f的File对象，并且封装成a.txt，因为file类中有个构造函数是这样的File(Stringpathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。没有目录就是默认当前目录。
//在指定目录下创建创建文件。
File f2 = new File("c:\\abc","b.txt");//在c盘c:\\abc中建立b.txt。如果上条指令写成c:\\abc\\a.txt，结果一样的。两种指令的区别就是这个传入的是2个参数。譬如后面不是一个文件，而是一个参数str（这个str可以是个对象）
//File的第三种构造函数，File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
File d = new File("c:\\abc");//创建一个file对象，赋值是abc文件夹
File f3 = new File(d,"c.txt");//创建一个c.txt，调用file构造函数，在d目录中创建。
sop("f1"+f1);//输出为f1a.txt，相对路径
sop("f2"+f2);
sop("f3"+f3);//输出为f3c:\abc\c.txt，sop打印的都是绝对路径。结论是sop打印的是file文件中的路径，封装成什么路径，就会有什么路径打印出来
//被不同平台识别，使用目录分隔符
File f4 = newFile("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
sop(f4);//File.separator是用来实现跨平台目录分隔符的。在不同的平台都可以实现目录分离
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

文件列表：
listRoots()，列出计算机中的有效盘符（列出可用的文件系统根，返回值（static File[]）
list()： 指定目录下的文件和文件夹名称，返回值为String[]。（包含隐藏文件）返回值为字符串数组，数组里面的内容是指定目录下的文件夹名称和文件名
注意：list()的调用对象必须封装了一个目录。空目录返回为空，文件返回空指针异常
String[]list(FilenameFilter filter) ：FilenameFilter是一个接口，内部有accept函数，建立对象实现FilenameFilter可以使用覆写accept函数来实现过滤文件的功能。Accept方法跟进返回值真假来判断是否返回文件。
File[] listFiles() 这个函数返回的是当前文件已经文件夹的对象。并且以file[]数组的形式返回。好处是，这个file[]可以使用file类的函数
例子：
import java.io.*;//io流和file类都必须导入io包
class FileDemo2
{
publicstatic void main(String[] args)
{
//listDemo();
Filedir = new File("c:\\");//创建一个dir的file类对象，内容为c:\\。
File[] files = dir.listFiles();//将dir的listFiles()封装到数组files中来。
for(File f : files )
{
System.out.println(f.getName()+":"+f.length());//遍历f获得内容，如果是文件就输出其大小
}
}
publicstatic void listDemo_2()
{
Filedir = new File("c:\\");//建立一个dir对象，为c盘目录
String[] arr = dir.list(new FilenameFilter()//建立数组用来放过滤后的元素
{//这里使用了匿名内部类，直接匿名内部类来调用list(FilenameFilterfilter)的accept方法。
publicboolean accept(File dir,String name)//覆写accept函数，返回值为boolean。
{
//System.out.println("dir:"+"...name："+name);//dir就是目录，name是文件名。要过滤就是对文件名进行判断就行了
returnname.endsWith(".jpg");//endsWidth(par1)表是参数是否是par1字符串为结尾.这段话就是返回后缀名问.jpg的文件或者目录（假如有后缀名为.jpg的目录的话）
//returnfalse;//list(new FilenameFilter())是以accept的返回值类型来判断是否要过滤文件，返回为真，说明都符合条件，返回为假，那么文件都被过滤了
}
});
System.out.println("len:"+arr.length);
for(String name : arr )
{
System.out.println(name);
}
}
publicstatic void listDemo()
{
Filef =new File ("c:\\");
String[] names = f.list();//利用list()函数将c盘下的目录以字符串数组形式放在names里面
for(String name :names )//高级for循环，格式为 数据类型名称：数组（或集合） 遍历完以后就会将遍历完的数据赋值给name
{
System.out.println(name);//输出c盘下的文件以及文件夹的名称
}//如果f对象内为一个文件，那么遍历f的时候，会提示空指针异常，因为文件内部没有文件和文件夹。空目录返回为空（表现为没有任何显示）
}
publicstatic void listRootsDemo()
{
File[] files = File.listRoots();
for(File f : files)
{
System.out.println(f);//输出计算机中的有效盘符。
}
}
}
递归：
需求：列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容。
分析：因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。
这种调用自己函数的表现形式，或者编程手法，称为递归。
递归需要注意：
递归要注意：
1，限定条件。
没有限定条件，会出现无法结束，一直在调用自身函数，无法停止。
2，要注意递归的次数。尽量避免内存溢出。
如果递归次数太对，占用内存太多，系统卡死
例子：
importjava.io.*;
class FileDemo3
{
public static void main(String[] args)
{
File dir = new File("d:\\javawxj");//对象dir是d:\\javawxj
//showDir(dir);//调用函数
toBin(6);
System.out.println(getSum(8000));//这里要注意递归次数，如果递归的数字太大，那么有可能会造成内存溢出
}
public static void showDir(File dir)//建立一个函数，对象为file对象
{
System.out.println(dir);//dir内存放的是文件目录或文件名
File [] files = dir.listFiles();//建立file类数组对象files，用来放file里面的文件名或者文件目录
for (int x= 0;x<files.length;x++ )
{
if(files[x].isDirectory())//如果dir下的任意一个元素是文件夹
showDir(files[x]);//那么调用自身函数，继续遍历，直到不是文件夹，就输出文件名
else
System.out.println(files[x]);//不是文件夹，就输出文件名
}
}
public static void toBin(int num)
{
if (num>0)
{
toBin(num/2);//递归，解析见示例图
System.out.println(num%2);
}
}
//求和递归
public static int getSum(int n)
{
if (n == 1)
return 1;
return n+getSum(n-1);
}
}
运用列出目录下的所有文件：
import java.io.*;
class FileDemo33
{
publicstatic void main(String[] args)
{
File dir = new File("d:\\javawxj");
showDir(dir,0);//跟进构造函数调用对象
}
publicstatic String getLevel(int level)//设置构造层级的函数
{
StringBuildersb = new StringBuilder();//建立sb对象，用来输出文件目录前面的符号
for(int x=0; x<level ;x++ )
{
sb.append("|——");//随着x的增加，添加|——。当x为零是，不添加，为1是，添加1个，以此类推
}
returnsb.toString();//返回sb的字符串形式
}
publicstatic void showDir(File dir,int level)//建立一个函数，接收file对象和level。
{
System.out.println(getLevel(level)+dir.getName());//dir内存放的是文件目录或文件名。输出符号和目录名字
level++;//递归时随着每一层目录的递增而增加符号
File[] files = dir.listFiles();//建立file类数组对象files，用来放file里面的文件名或者文件目录
for(int x= 0;x<files.length;x++ )
{
if(files[x].isDirectory())//如果dir下的任意一个元素是文件夹
showDir(files[x],level);//那么调用自身函数，继续遍历，直到不是文件夹，就输出文件名
else
System.out.println(getLevel(level)+files[x]);//不是文件夹，就输出相对性的符号和文件名
}
}
}
删除一个带文件的目录：
删除原理：在window中，删除目录从里面往外删除的。既然是从里往外删除。就需要用到递归。
import java.io.*;
class removeDir
{
publicstatic void main(String[] args)
{
Filefile = new File("D:\\Javawxj\\day20\\abc");
removeDir(file);
}
publicstatic void removeDir(File file)
{
File[]files = file.listFiles();
for(int x = 0;x<files.length;x++)
{
if(files[x].isDirectory())
removeDir(files[x]);
else
System.out.println(files[x].delete());//删除有文件的文件夹里面的每一个文件，并返回布尔型
}
System.out.println(file+"::"+file.delete());//删除根目录
}
}

经典例子：

编写一个程序，将d:\java 目录下的所有.java 文件复制到d:\jad 目录下，并将原来文件的扩展名从.java 改为.jad。

步骤分析：

* 1 获取读取文件目录的文件对象，用File类方法listFiles，并使用过滤器

* 2 在for循环内，获取完成匹配的文件名

* 3 并在for循环内， 创建输入流和输出流，完成读写操作

* 4 关闭流

import java.io.*;

public class Test9

{

public static void main(String[] args)

{

//创建File路径对象,确定

File file=new File("d:\\java");

//声明字符读取流、输出流

FileReader fr=null;

FileWriter fw=null;

//声明字符流缓冲区

BufferedReader bufr=null;

BufferedWriter bufw=null;

//进行文件类型匹配,用过滤器获取.java文件

File[] java=file.listFiles(

new FileFilter()

{

//复写方法，匹配文件类型

public boolean accept(File pathname)

{

return (pathname+"").endsWith(".java");

}

});

String name="";

String firstName="";

//for循环，遍历目录文件，实现各个文件的读写操作

for(int i=0;i<java.length;i++)

{

try

{

//获取文件名

name=java[i].getName();

//分割文件名，去掉后缀名，获取文件短名称

firstName=name.split(".java")[0];//取数组的第一个元素

//创建读取输入流

fr=new FileReader(java[i]);

//创建输出写入流，关联文件的绝对路径名

fw=new FileWriter("d:\\jad\\"+firstName+".jad");

//创建输入流缓冲区

bufr=new BufferedReader(fr);

//创建输出流缓冲区

bufw=new BufferedWriter(fw);

//读取和写入文件

String line="";

while((line=bufr.readLine())!=null)//读取一行

{

bufw.write(line);//向目标文件写入读取到的内容

bufw.flush();//刷新

bufw.newLine();//换行

}

}

catch(IOException ie)

{

System.out.println(ie);

}

//finally块里面进行关流操作，这里简单做简单异常处理

finally

{

try

{

if(bufr!=null)

bufr.close();

}

catch(IOException ie)

{

System.out.println(ie);

}

try

{

if(bufw!=null)

bufw.close();

}

catch(IOException ie)

{

System.out.println(ie);

}

}

}

}

}

这也是我参加黑马初级测试的题目。感觉很有意思。

练习：

创建java文件列表清单
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。
建立一个java文件列表文件。
思路：
1，对指定的目录进行递归。
2，获取递归过程所以的java文件的路径。
3，将这些路径存储到集合中。
4，将集合中的数据写入到一个文件中。
将数据存入文件叫做数据的持久化
演示代码：
import java.io.*;
import java.util.*;//会用到List，所以导入util包
class JavaFileList
{
publicstatic void main(String[] args)
{
try
{
Filedir = new File("D:\\Javawxj");//建立一个dir对象，封装D:\\Javawxj
List<File>list= new ArrayList<File>();//建立一个File类型的ArrayList对象list
fileToList(dir,list);//调用fileToList进行递归
System.out.println(list.size());//输出list长度
Filefile = new File(dir,"javalist.txt");//在dir对象里面目录下建立javalist文件。
writeToFile(list,file.toString());//将对象list传入file文件
}
catch(IOException e)
{//调用writeToFile函数就一定要进行try处理，因为下面的函数有了声明。这里如果捕捉到了IO异常，那么就停止程序
thrownew RuntimeException();
}
}
publicstatic void fileToList(File dir,List<File> list)//建立一个函数，将file写入list中
{
File[] files = dir.listFiles();//建立files数组
for(File file: files )//遍历files文件，将结果保存到file里面
{
if(file.isDirectory())//如果是文件夹，
fileToList(file,list);//那么就递归
else
{
if(file.getName().endsWith(".java"))//递归直到不是文件夹，将里面所有的java文件
list.add(file);//写入到file里面
}
}
}
publicstatic void writeToFile(List<File> list,String javalistFile)throwsIOException//这里声明了，如果调用，就必须进行处理
{
BufferedWriterbufw = null;//建立一个空缓冲流对象
try//这里用到了文件读取，有可能出现异常，所以try处理
{
bufw= new BufferedWriter (new FileWriter(javalistFile));//接收的javalistFile，进行写入操作，并建立缓冲流
for(File f : list )
{//遍历list
Stringpath = f.getAbsolutePath();//建立path存放绝对路径
bufw.write(path);//将path写入缓冲流
bufw.newLine();//换行
bufw.flush();//刷新
}
}
catch(IOException e)
{
throwe;//可以throwRuntimeException，那么函数上就不用做声明了。
}
finally//finally的作用就是关闭资源
{
try//为什么要try？因为只要调用到writeToFile就得处理异常
{
if(bufw!=null)
bufw.close();
}
catch(IOException e)
{
throwe;
}
}
}
}

2 Properties类
Properties 是hashtable的子类。
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件。
那么在加载数据时，需要数据有固定格式：键=值。
setProperty()：调用 Hashtable 的方法 put。setProperty(Stringkey, String value).分别放入key和value值。
getProperty()：用getProperty(String key) 方法，返回值为String，通过制定的key，可返回相应的value
stringPropertyNames()：返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。意思就是返回set集合，集合泛型为String，包含的是key的集合。
import java.io.*;
import java.util.*;//Properties属于util包中的函数
class PropertiesDemo
{
publicstatic void main(String[] args)
{
setAndGet();
}
publicstatic void setAndGet()
{
Propertiesprop = new Properties();//建立对象
prop.setProperty("zhangsan","30");//调用 Hashtable 的方法 put。setProperty(Stringkey, String value).分别放入key和value值。
prop.setProperty("lisi","39");
//System.out.println(prop);//输出结果为：{zhangsan=30, lisi=39}，键值对关系用等号连接
Stringvalue = prop.getProperty("lisi");//用getProperty(String key) 方法，返回值为String，通过制定的key，可返回相应的value
//System.out.println(value);//输出39
//Set<String> stringPropertyNames() 返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。意思就是返回set集合，集合泛型为String，包含的是key的集合。
prop.setProperty("lisi",89+"");//一个key对已一个value，这条指令以后，lisi对应的就只是89了。
Set<String>names = prop.stringPropertyNames();//建立names的set集合，里面都是字符串类型
for(String s : names )//遍历names
{
System.out.println(s+":"+prop.getProperty(s));//输出prop的key值（名字）和value值（年龄）
}
}
}
演示，如何将流中的数据存储到集合中。
想要将info.txt中键值数据存到集合中进行操作。
1,用一个流和info.txt文件关联。
2，读取一行数据，将该行数据用"="进行切割。
3，等号左边作为键，右边作为值。存入到Properties集合中即可。
演示代码：
import java.io.*;
import java.util.*;//Properties属于util包中的函数
class PropertiesDemo
{
publicstatic void main(String[] args) throws IOException//因为涉及到IO流读写，所以抛异常
{
loadDemo();
}
publicstatic void loadDemo()throws IOException
{
FileInputStreamfis = new FileInputStream("info.txt");//建立一个字节流对象，与info相连接
Propertiesprop = new Properties();//建立Properties对象
prop.load(fis);//调用load函数 void load(InputStream inStream) 从输入流中读取属性列表（键和元素对）。这个函数可以将字节流中的键和元素读取到Properties对象中去
prop.setProperty("lisi","39");//这样输出的结果是lisi39，但是这个函数内存里面更改了，但是文件中的数值没有更改
FileOutputStreamfos = new FileOutputStream("info.txt");//建立一个输入流。
prop.store(fos,"haha");//store(OutputStreamout, String comments)，out - 输出流。comments - 属性列表的描述。这个方法的作用就是将prop更改后的数据存入一个（输出）流中，并存入文件中.haha字符串是注释信息，前面有#存入文件，加载时不会被Property加载，Property加载的只有键值对信息
//System.out.println(prop);//输出prop
prop.list(System.out);//利用list将prop输出到打印流，效果和上条指令一样.函数void list(PrintStream out) 将属性列表输出到指定的输出流。
fos.close();
fis.close();
}
publicstatic void method_1()throws IOException
{
BufferedReaderbufr = new BufferedReader(new FileReader("info.txt"));//建立缓冲区，bufr，并与info连接
Stringline = null;//建立字符串用来中转缓冲区的数据
Propertiesprop = new Properties();
while((line=bufr.readLine())!=null)//遍历
{
String[] arr = line.split("=");//String[] split(String regex)根据给定正则表达式的匹配拆分此字符串。将line的key和value拆分成2部分，分别放入数组中
//System.out.println(arr[0]+"..."+arr[1]);
prop.setProperty(arr[0],arr[1]);//将数组中的元素成对放入prop的键值中区
}
bufr.close();//关闭缓冲区
System.out.println(prop);//输出
}
publicstatic void setAndGet()
{
Propertiesprop = new Properties();//建立对象
prop.setProperty("zhangsan","30");//调用 Hashtable 的方法 put。setProperty(Stringkey, String value).分别放入key和value值。
prop.setProperty("lisi","39");
//System.out.println(prop);//输出结果为：{zhangsan=30, lisi=39}，键值对关系用等号连接
Stringvalue = prop.getProperty("lisi");//用getProperty(String key) 方法，返回值为String，通过制定的key，可返回相应的value
//System.out.println(value);//输出39
//Set<String> stringPropertyNames() 返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。意思就是返回set集合，集合泛型为String，包含的是key的集合。
prop.setProperty("lisi",89+"");//一个key对已一个value，这条指令以后，lisi对应的就只是89了。
Set<String>names = prop.stringPropertyNames();//建立names的set集合，里面都是字符串类型
for(String s : names )//遍历names
{
System.out.println(s+":"+prop.getProperty(s));//输出prop的key值（名字）和value值（年龄）
}
}
}

File简单总结：

File

|-- File对象，将文件和文件夹，目录封装成了对象，提供更多属性和功能

|-- File类的常用方法

|-- 创建功能 createNewFile(),mkdir(),mkdirs()

|-- 删除功能 delete() 不走回收站

|-- 判断功能

|-- isAbsolute 判断是否是绝对路径 c:\\ http://www.
|-- isDirectory 判断是否是文件夹

|-- isFile 判断是否是文件

|-- isHidden 判断是否是隐藏属性

|-- exists() 判断File封装的目录或者是文件是否存在

|-- 获取功能

|-- static listRoots()当前系统的根目录 ，返回的是File类型的数组

|-- String[] list()返回File对象封装的目录下的全部文件和文件夹

|-- File[] listFiles 返回File对象封装的目录下的全部文件和文件夹

|-- list listFiles区别，第一个返回的是字符串，只能调用字符串的方法

第二个返回的是File对象，可以调用File对象中的方法

|-- FileFilter

|-- FileNameFiler 文件过滤器 匿名内部类

本篇博文结束！

@感谢老师的辛苦批阅