-------android培训、java培训、java学习型技术博客、期待与您交流！ ----------
知识点六 File类
一、概述：
1、File类：文件和目录路径的抽象表现形式
2、特点：
1）用来将文件或文件夹封装成对象
2）方便于对文件与文件夹的属性信息进行操作
3）File对象可以作为多数传递给流的构造函数
二、创建File对象：
方式一：File f1 = new File("a.txt");
---> 将a.txt封装成对象，可将已有的和未出现的文件或文件夹封装成对象
方式二：File f2 = new File("c:\\abc","b.txt");
---> 分别指定文件夹和文件。好处：降低了两者的关联程度，
方式三：File d = new File("c:\\abc"); File f3 = new File(d,"c.txt");
---> 可以传入父目录和文件名。
目录分隔符：调用File.separator，相当于是反斜杠 \
三、File类的常见方法
1.创建
boolean createNewFile();在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不一样，输出流对象一创建就创建文件。而且文件已经存在，则覆盖。
boolean mkdir()：创建文件夹，只能创建一级目录
boolean mkdirs():创建多级文件夹，可以创建多级目录
2.删除
boolean delete();删除失败，返回false；
void deleteOnExit();在程序退出时删除指定文件。
3.判断。
boolean exists():文件是否存在
booleanisFile():是否是文件
boolean isDirectory():是否是文件目录
boolean isHidden():文件是否隐藏
boolean isAbsolute():是否是绝对路径
4.获取信息。
String getName(); 获取文件名
String getPath(); 获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）
String getParent();获取父目录，该方法返回绝对路径中的父目录，获取相对路径，返回null， 如果相对路径中有上一级目录，则返回的即为该目 录
String getAbsolutePath();获取绝对路径
long lastModified();最后一次修改的时候
long length():文件的大小
static File[] listRoots() ;获取文件的系统根，即各个盘符
String[] list() ;列出当前目录所有文件，包含隐藏文件。注：调用了list方法的file对象，必须是封装了一个目录，且该目录必须存在。
boolean renameTo(File dest);对文件重命名为dest
5.换名字： renameTo();方法用于更换文件的名字
6. 列出及过滤文件：
String[] list(); 列出当前目录所有文件，包含隐藏文件，调用list方法的file对象，必须是封装了一个目录，且该目录必须存在。
File[] list(FilenameFilter filter); FilenameFilter：文件名过滤器，是一个接口，其中包含一个方法，accept(File dir,String name)，返回 的是boolean型，对不符合条件的文件过滤掉。
File[] listFiles(); 获取当前文件夹下的文件和文件夹，返回类型为File数组
ListFiles(FilenameFilter filter);同list，是对获取的 当前文件夹下的文件和文件夹的 文件名过滤器。
***关于覆盖：覆盖的原理是先删除，然后再创建 ***
示例：
import java.io.*;
class FileDemo
{
public static void main(String[] args) throws IOException
{
// consMethod();
method_5();
}
//创建File对象
public static void consMethod()
{
//将a.txt封装成file对象。可以将已有的和未出现的文件或则文件夹封装成对象。
File f1=new File("a.txt");
//abc指的是父目录，b.txt指的是目录中的文件名
File f2=new File("C:/abc","b.txt");
//将目录封装成对象
File d=new File("C:/abc");
File f3=new File(d,"c.txt");
sop("f1:"+f1);
sop("f2:"+f2);
sop("f3:"+f3);
//separator是与系统有关的默认的名称分割符，这样就可以实现跨平台
File f4=new File("c:"+File.separator+"abc"+File.separator+"ggg"+File.separator+"a.txt");
}
public static void sop(Object obj)
{
System.out.println(obj);
}
//方法一
public static void method_1() throws IOException
{
File f=new File("file.txt");
f.deleteOnExit();
// sop("create:"+f.createNewFile());
sop("delete:"+f.delete());
}
//方法二
public static void method_2() throws IOException
{
File f=new File("file.txt");
//文件是否能被执行
// sop("execute:"+f.canExecute());
//判断文件是否存在
//sop("exists:"+f.exists());
//创建文件夹
//mkdir()方法用于创建目录,只能创建一级目录，不能创建多级目录
//File dir=new File("abc\\aaa");
//mkdir()方法用于创建一级目录
//sop("mkdir:"+dir.mkdir());
//mkdirs()方法用于创建多级目录
File dir=new File("abc\\aaa\\ccc\\nnggg");
//mkdir()方法用于创建多级目录
sop("mkdir:"+dir.mkdirs());
}
//方法三
public static void method_3() throws IOException
{
File f=new File ("file.txt");
//记住在判断文件对象是否是文件对象或者目录时，必须要先判断该文件对象封装的内容是否存在
//通过exists判断。
//f.createNewFile();
f.mkdir();
//isDirectory()判断是否是目录，isFile判断是否是文件
sop("dir:"+f.isDirectory());
sop("dir:"+f.isFile());
//判断文件是否是绝对路径
sop(f.isAbsolute());
}
//方法四
public static void method_4() throws IOException
{
File f=new File("file.txt");
sop("path:"+f.getPath());
sop("abspath:"+f.getAbsolutePath());
//该方法返回的是绝对路径中的父目录
//如果获取的是相对路径，返回null空
//如果相对路径中有上一层目录，那么该目录就是返回结果
sop("parent:"+f.getParent());
}
//方法五
public static void method_5() throws IOException
{
//这样相当于移动（剪贴）和重命名
File f1=new File("C:/Test.java");
File f2=new File("d:/Sword.java");
//renameTo()方法用于更换文件的名字
sop(f1.renameTo(f2));
}
}/*
list用于打印指定目录下文件或则文件夹的名称的
listRoots()列出机器中有效的盘符
*/
import java.io.*;
class FileDemo2
{
public static void main(String[] args) throws IOException
{
File dir=new File("C:\\");
File[] files=dir.listFiles();
for(File f: files)
{
System.out.println(f.getName()+"::"+f.length());
}
}
public static void listDemo_2()
{
// listRootsDemo();
//listDemo();
File dir=new File("C:\\Users\\Administrator\\Desktop\\冲刺黑马之路\\代码");
//FilenameFilter()为匿名内部类
String[] arr=dir.list(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
// System.out.println("dir:"+dir+"...name"+name);
/*
if(name.endsWith(".java"))
{
return true;
}
*/
return name.endsWith(".java");
}
});
System.out.println("len:"+arr.length);
for(String name:arr)
{
System.out.println(name);
}
}
public static void listDemo()
{
File f=new File("C:\\");
//list()用于打印指定目录下文件或则文件夹的名称的
//调用list方法的file对象必须是封装了一个目录，该目录还必须存在。
String[] names=f.list();
for(String name:names)
{
System.out.println(name);
}
}
public static void listRootsDemo()
{
//列出机器中有效的盘符
File[] files=File.listRoots();
//高级for循环，也就是for增强
for(File f:files)
{
System.out.println(f);
}
}
}四、递归：
对于每次循环都是用同一个功能的函数，即函数自身调用自身，这种表现形式或手法，称为递归。
注意：
1、限定条件，是作为结束循环用的，否则是死循环
2、注意递归的次数，尽量避免内存溢出。因为每次调用自身的时候都会先执行下一次调用自己的发那个发，所以会不断在栈内存中开辟新空间，次数过多，会导致内存溢出。
例一：
列出指定目录下文件或者文件夹，包含子目录中的内容，也就是列出指定目录下所有内容。用递归的方式层级显示
分析，因为目录中还有目录，只有使用同一个列出目录功能的函数完成即可，在列出过程中出现的还是目录的话，还可以再调用本功能，这就是利用递归原理。
import java.io.*;
class FileDemo3
{
public static void main(String[] args)
{
File dir = new File("d:\\testdir");
//showDir(dir,0);
//toBin(6);
//int n = getSum(8000);
//System.out.println("n="+n);
System.out.println(dir.delete());
}
//对目录进行分级
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(getLevel(level)+dir.getName());
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]);
}
}
public static int getSum(int n)
{
if(n==1)
return 1;
return n+getSum(n-1);
}
public static void toBin(int num)
{
if(num>0)
{
toBin(num/2);
System.out.println(num%2);
}
}
public static void method()
{
method();
}
}
删除一个带内容的目录：
删除原理：在window中，删除目录是从里往外删除的，同样使用递归
import java.io.*;
class RemoveDir
{
public static void main(String[] args)
{
File dir = new File("d:\\testdir");
removeDir(dir);
}
public static void removeDir(File dir)
{
File[] files = dir.listFiles();
for(int x=0; x<files.length; x++)
{
//if(!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文件列表文件。
思路：
1，对指定的目录进行递归。
2，获取递归过程所有的java文件的路径。
3，将这些路径存储到集合中。
4，将集合中的数据写入到一个文件中。
补充一点：
数据的持久化：把数据存硬盘里就是持久化存储
import java.io.*;
import java.util.*;
class JavaFileList
{
public static void main(String[] args) throws IOException
{
File dir = new File("d:\\java1223");
List<File> list = new ArrayList<File>();
fileToList(dir,list);
// System.out.println(list.size());
//dir是父目录，"javalist.txt"是文件名
File file = new File(dir,"javalist.txt");
//file.toString()将路径强转成字符串
writeToFile(list,file.toString());
}
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);
}
}
}
public static void writeToFile(List<File> list,String javaListFile)throws IOException
{
BufferedWriter bufw = null;
try
{
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 类
一、概述：
1、Properties是hashtable的子类。也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串，不需要泛型定义。
Properties是不仅可以操作键值对信息，而且可以硬盘上的键值对信息。是集合中和IO技术相结合的集合容器。
2、特点：
1）可用于键值对形式的配置文件
2）在加载时，需要数据有固定的格式，常用的是：键=值
二、常用方法：
1、设置和获取元素：
Object setProperty(String key,String value);调用Hashtable的方法put
String getProperty(String key); 指定key搜索value
Set<String> stringPropertyName();返回属性列表的键集，存入Set集合
void load(InputStream ism) ;从输入字符流中读取属性列表
void load(Reader reader); 从输入字符流中读取属性列表
示例：
import java.io.*;
import java.util.*;
class PropertiesDemo
{
public static void main(String[] args) throws IOException
{
//method_1();
loadDemo();
}
public static void loadDemo()throws IOException
{
Properties prop = new Properties();
FileInputStream fis = new FileInputStream("info.txt");
//将流中的数据加载进集合。
prop.load(fis);
//setProperty改变的是内存的结果
prop.setProperty("wangwu","39");
FileOutputStream fos = new FileOutputStream("info.txt");
//haha是注入信息，注释，#代表注释信息，不会被Properties所加载，Properties所加载的信息必须是键值对
//那么在加载数据时，需要数据有固定的格式，键=值
prop.store(fos,"haha");
// System.out.println(prop);
prop.list(System.out);
fos.close();
fis.close();
}
//演示，如何将流中的数据存储到集合中。
//想要将info.txt中键值数据存到集合中进行操作。
/*
1,用一个流和info.txt文件关联。
2，读取一行数据，将该行数据用"="进行切割。
3，等号左边作为键，右边作为值。存入到Properties集合中即可。
*/
public static void method_1()throws IOException
{
BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));
String line = null;
Properties prop = new Properties();
while((line=bufr.readLine())!=null)
{
//split是切割
String[] arr = line.split("=");
///System.out.println(arr[0]+"...."+arr[1]);
prop.setProperty(arr[0],arr[1]);
}
bufr.close();
System.out.println(prop);
}
//设置和获取元素。set和get方法
public static void setAndGet()
{
Properties prop = new Properties();
//setProperty设置键值对
prop.setProperty("zhangsan","30");
prop.setProperty("lisi","39");
// System.out.println(prop);
String value = prop.getProperty("lisi");
//System.out.println(value);
//89+""转化成字符型
prop.setProperty("lisi",89+"");
Set<String> names = prop.stringPropertyNames();
for(String s : names)
{
System.out.println(s+":"+prop.getProperty(s));
}
}
}1）很容易想到的是:计数器。
可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。
可是随着该应用程序的退出，该计数器也在内存中消失了。
2）下一次在启动该程序，又重新开始从0计数。
这样不是我们想要的。
3）程序即使结束，该计数器的值也存在。
下次程序启动在会先加载该计数器的值并加1后在重新存储起来。
4）所以要建立一个配置文件。用于记录该软件的使用次数。
5）该配置文件使用键值对的形式。 这样便于阅读数据，并操作数据。
6）键值对数据是map集合。 数据是以文件形式存储，使用io技术。那么map+io -->properties.
补充知识点：
配置文件可以实现应用程序数据的共享。
现在要用的配置文件有两种：键值对的和xml文件
dom4j: dom for java解析xml文件
示例：
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");
if(!file.exists())
file.createNewFile();
FileInputStream fis = new FileInputStream(file);
//将流中的数据加载到集合当中
prop.load(fis);
int count = 0;
String value = prop.getProperty("time");
if(value!=null)
{
count = Integer.parseInt(value);
if(count>=5)
{
System.out.println("您好，使用次数已到，拿钱!");
return ;
}
}
count++;
prop.setProperty("time",count+"");
FileOutputStream fos = new FileOutputStream(file);
//注入信息没写
prop.store(fos,"");
fos.close();
fis.close();
}
}
/*
name=zhangsan
age=20
<persons>
<person id="001">
<name>zhagnsan</name>
<age>30</age>
<address>bj</address>
</person>
<person>
<name>...
</person>
</persons>
*/知识点八 打印流
一、概述：
1、打印流包括：PrintStream和PrintWriter
2、该流提供了打印方法，可以将各种数据类型的数据都原样打印。
二、字节打印流：PrintStream
构造方法中可接收的参数类型：
1、file对象。File
2、字符串路径：String
3、字符输出流：OutputStream
三、字符串打印流：PrintWriter
构造方法中可接受的参数类型
1、file对象：File
2、字符串路径：String
3、字节输出流：OutputStream
4、字符输出流：Writer
补充知识点：在dos命令控制台下，输入cls可以清空dos控制台，按下ctrl+c关闭输入
示例：
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.flush();
}
out.close();
bufr.close();
}
}知识点九 序列流
一、概述：
1.序列流SequenceInputStream没有直接对应OutputStream，表示其它输入流的逻辑串联
2、SequenceInputStream可以将多个流连接成一个源
3、构造函数：
SequenceInputStream(Enumeration<? extends FileInputStream> e)
二、如何合并多个文件：
1、创建集合，并将流对象添加进集合
2、创建Enumeration对象，将集合元素加入。
3、创建SequenceInputStream对象，合并流对象
4、创建写入流对象，FileOutputStream，将数据写入流资源
5、定义数组，将读取流数据存入数组，并将数组中元素写入文件中。
示例：
class SequenceDemo
{
public static void main(String[] args) throws IOException
{
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("c:\\1.txt"));
v.add(new FileInputStream("c:\\2.txt"));
v.add(new FileInputStream("c:\\3.txt"));
//Enumeration是个接口不是类（列举）为了实现遍历枚举也用于将输入流指定到 SequenceInputStream 中。
//注：此接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。
//新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。
Enumeration<FileInputStream> en = v.elements();
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("c:\\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();
}
}
1、先关联文件FileInputStream
2、定义写入流变量：FileOutputStream
3、创建数组，并定义切割所需的大小|
4、循环读写数据，并每次创建一个新写入流，创建完后并写入文件中
5、关闭流资源
示例：
import java.io.*;
import java.util.*;
class SplitFile
{
public static void main(String[] args) throws IOException
{
//splitFile();
merge();
}
public static void merge()throws IOException
{
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int x=1; x<=3; x++)
{
al.add(new FileInputStream("c:\\splitfiles\\"+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("c:\\splitfiles\\0.bmp");
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
public static void splitFile()throws IOException
{
FileInputStream fis = new FileInputStream("c:\\1.bmp");
FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];
int len = 0;
int count = 1;
while((len=fis.read(buf))!=-1)
{
fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
}
最新最全的的java学习视频教程：http://pro.net.itcast.cn/View-22-1458.aspx
-------android培训、java培训、java学习型技术博客、期待与您交流！ ----------
详细请查看：http://edu.csdn.net/heima
151
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
