File类
用来将文件或者文件夹封装成对象
方便对文件与文件夹的属性信息进行操作
File对象可以作为参数传递给流的构造函数
File类中的常见方法:
1,创建
boolean createNewFile();
在指定位置创建文件,如果文件已经存在,返回false,不创建文件
和输出流不一样,输出流对象一建立就会创建文件,而且如果文件已经存在,会覆盖
boolean mkdir();创建文件夹。
boolean mkdirs();创建多级文件夹。
2,删除
boolean delete();删除失败返回false
void deleteOnExit();在程序退出时删除指定文件
3,判断
boolean exists();文件是否存在
boolean canExecute();文件是否能执行
boolean isFile();是否是文件
boolean isDirectory();是否是目录
boolean isHidden();是否是隐藏文件
4,获取信息
getName();返回由此抽象路径名表示的文件或目录的名称。
getPath();将此抽象路径名转换为一个路径名字符串。
getParent();返回此抽象路径名绝对父目录的路径名字符串;如果此路径名没有绝对父目录,则返回 null。
如果是相对路径,也返回null
getAbsolutePath();返回此抽象路径名的绝对路径名字符串,拿到的都是绝对路径
long lastModified(); 返回此抽象路径名表示的文件最后一次被修改的时间。
long length();返回文件大小
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
method_5();
}
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()
{
File f = new File("file.txt");
//sop("exists:"+f.exists());
//sop("execute:"+f.canExecute());
//创建文件夹
File dir = new File("abc\\a\\d\\gf\\gh\\cdf");
sop("mkdirs:"+dir.mkdirs());
}
public static void method_4()
{
File f = new File("a.txt");
sop("path:"+f.getPath());
sop("Abpath:"+f.getAbsolutePath());
}
public static void method_5()
{
File f1 = new File("c:\\a.txt");
File f2 = new File("d:\\b.txt");
//sop("rename:"+f1.renameTo(f2));
sop(f2.length());
}
//创建File对象
public static void consMethod()
{
//将a.txt封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象
File f1 = new File("a.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);
File f4 = new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
//File.separator与\\作用相同,但是前者可以跨平台
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
import java.io.*;
class FileDemo2
{
public static void main(String[] args)
{
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()
{
File dir = new File("d:\\java0217\\day18");
String[] arr = dir.list(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
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方法的file对象必须是封装了一个目录,该目录还必须存在
String[] names = f.list();//列出f目录下的所有文件,包含隐藏文件
for(String name:names)
{
System.out.println(name);
}
}
public static void listRootsDemo()
{
File[] files = File.listRoots();
for(File f:files)
{
System.out.println(f);
}
}
}
列出指定目录下的文件或者文件夹,包含子目录中的内容–递归
package day20;
import java.io.File;
public class FileDemo3 {
/**
* 列出指定目录下的文件或者文件夹,包含子目录中的内容
* 也就是列出指定目录下的所有内容。
*
*
* 因为目录中还有目录,只要使用同一个列出目录功能的函数完成即可。
* 在列出过程中出现的还是目录的话,还可以再次调用本功能。
* 也就是函数自身调用自身,这种表现形式,或者编程手法,成为递归。
*
* 递归要注意:
* 1,限定条件。
* 2,要注意递归的次数,避免内存溢出。
*
*/
public static void main(String[] args) {
//
File dir = new File("D:\\java0217");
showDir(dir);
}
public static void showDir(File dir){
System.out.println("---------------------------------");
System.out.println(dir);
File[] files = dir.listFiles();
for(File f:files){
if(f.isDirectory())
showDir(f);
else
System.out.println(f);
}
}
}
删除带内容的目录–递归
package day20;
import java.io.File;
public class RemoveDir {
/**
* 删除一个带内容的目录
* 删除原理:
* 在windows中,删除目录是从里面往外删除的
*
* 既然是从里往外删除,就需要用到递归。
*
*/
public static void main(String[] args) {
File dir = new File("D:\\创新项目");
removeDir(dir);
}
public static void removeDir(File dir){
File[] files = dir.listFiles();
for(File f : files){
if(f.isDirectory())
removeDir(f);
else
System.out.println(f+"files"+f.delete());
}
//每一个文件夹内的文件删除完毕,最后把该文件夹删除
System.out.println(dir+"dir"+dir.delete());
}
}
练习
将一个指定目录下的java文件的绝对路径,存储到文本文件中。
建立一个java文件列表文件。
思路:
1,对指定的目录进行递归
2,获取递归过程中所有的java文件路径
3,将这些路径存到集合中。
4,将集合中的数据写入到一个文件中。
package day20;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class JavaFileList {
public static void main(String[] args) {
File dir = new File("D:\\java0217");
List<File> list = new ArrayList<File>();
fileToList(dir,list);
//System.out.println(list.size());
File javaListFile = new File(dir,"javaListFile.txt");
writeToFile(list,javaListFile);
}
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,File javaListFile){
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 new RuntimeException("写入失败");
}
finally{
try {
if(bufw!=null)
bufw.close();
} catch (IOException e) {
throw new RuntimeException("写入失败");
}
}
}
}
Properties类
Properties是hashtable的子类
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串,不需要泛型。
是集合中和IO技术相结合的集合容器。
该对象的特点,可以用于键值对形式的配置文件。
那么在加载数据时,需要数据有固定的格式:键=值
package day20;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class PropertiesDemo {
public static void main(String[] args) {
//setAndGet();
//method_1();
loadDemo();
}
/**
* loadDemo是method_1在java内的封装表现,
* 也就是说,method_1是loadDemo的原理
*
*/
public static void loadDemo(){
Properties prop = new Properties();
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("D:\\Eclipse Java SE_work space\\java0623\\src\\day20\\info.txt");
// 将流中的数据加载进集合
prop.load(fis);
prop.setProperty("lisi", "32");
// fos的位置会影响输出结果。
// 更改集合中的内容,并把更改后的内容存储到info.txt中
fos = new FileOutputStream("D:\\Eclipse Java SE_work space\\java0623\\src\\day20\\info.txt");
prop.store(fos, "zhushi");
} catch (IOException e) {
throw new RuntimeException("导入失败");
}
finally{
try {
if(fis!=null)
fis.close();
} catch (IOException e) {
throw new RuntimeException("读取流关闭失败");
}
try {
if(fos!=null)
fos.close();
} catch (IOException e) {
throw new RuntimeException("输出流关闭失败");
}
}
//System.out.println(prop);
prop.list(System.out);
}
/**
* 演示:
* 如何将流中的数据存储到集合中。
* 想要将info.txt文件中键值数据存储到集合中操作。
*
* 思路:
* 1,用一个流和info.txt文件关联。
* 2,读取一行数据,将该行数据用“=”进行切割。
* 3,等号左边为键,等号右边为值,存入到Properties集合中即可。
*
*/
public static void method_1(){
BufferedReader bufr = null;
String line = null;
Properties prop = new Properties();
try {
bufr = new BufferedReader(new FileReader("D:\\Eclipse Java SE_work space\\java0623\\src\\day20\\info.txt"));
while((line=bufr.readLine())!=null){
// 在等号处分割,并存入数组,等号左边是arr[0],等号右边是arr[1]
String[] arr = line.split("=");
// System.out.println(arr[0]+"....."+arr[1]);
prop.setProperty(arr[0],arr[1]);
}
System.out.println(prop);
} catch (IOException e) {
throw new RuntimeException("读取失败");
}
finally{
try {
if(bufr!=null)
bufr.close();
} catch (IOException e) {
throw new RuntimeException("读取失败");
}
}
}
//设置和获取元素
public static void setAndGet(){
Properties prop = new Properties();
prop.setProperty("zhangsan","30");
prop.setProperty("lisi","39");
System.out.println(prop);
String value = prop.getProperty("lisi");
System.out.println(value);
prop.setProperty("lisi", 100+"");
Set<String> names = prop.stringPropertyNames();
for(String s:names){
System.out.println(s+":"+prop.getProperty(s));
}
}
}
setAndGet()演示图片
method_1()演示图片
loadDemo()演示图片
练习:制作注册提示信息
用于记录应用程序运行次数
如果使用次数已到,那么给出注册提示。
很容易想到的是计数器,
该计数器定义在程序中,随着程序的运行而在内存中存在,并进行自增
可是随着该应用程序的退出,该计数器也在内存中消失了。
下一次在启动该程序,又重新开始从零计数。
这样不是我们想要的
我们希望的是程序即使结束,该计数器的值也存在,
下次程序启动会先加载该计数器的值,并加一后重新存储起来。
所以要建立一个配置文件,用于记录该软件的使用次数。
该配置文件使用键值对的形式
这样便于阅读并操作数据
键值对数据是Map集合
数据是以文件形式存储,使用IO技术
那么IO+Map———>properties
配置文件可以实现应用程序数据的共享
dom4j是常用的配置文件创建工具(dom for java)
package day20;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
public class RunCount {
public static void main(String[] args) {
Properties prop = new Properties();
File file = new File("count.ini");
FileInputStream fis = null;
FileOutputStream fos = null;
int count = 0;
try {
if(!file.exists())
file.createNewFile();
fis = new FileInputStream(file);
prop.load(fis);
String value = prop.getProperty("time");
if(value!=null){
count = Integer.parseInt(value);
if(count>=5){
System.out.println("使用次数到达上限,请注册后继续使用");
// 加入return语句使count到达5次后不继续增加,而是返回。
// 没有return语句count会一直增加。
return;
}
}
count++;
prop.setProperty("time", count+"");
fos = new FileOutputStream(file);
prop.store(fos,"zhushixinxi");
} catch (IOException e) {
throw new RuntimeException("文件创建失败");
}
finally{
try {
if(fis!=null)
fis.close();
} catch (IOException e) {
throw new RuntimeException("读取流关闭失败");
}
try {
if(fos!=null)
fos.close();
} catch (IOException e) {
throw new RuntimeException("打印流关闭失败");
}
}
}
}
打印流
打印流:
PrintStream和PrintWriter
可以直接操作输入流和文件
该流提供了打印方法,可以将各种数据都原样打印。
字节打印流:PrintStream
构造函数可以接收的参数类型:
1,File对象 File
2,字符串路径 String
3,字节输出流 OutputStream
字符打印流:PrintWriter
构造函数可以接收的参数类型:
1,File对象 File
2,字符串路径 String
3,字节输出流 OutputStream
4,字符输出流 Writer
package day20;
import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class PrintStreamDemo {
public static void main(String[] args) throws IOException{
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out,true);
// true前面必须是流,刷新只对于流而言。如果不是流,可以封装成流对象。
// PrintWriter pw = new PrintWriter(new FileWriter("a.txt"),true);
String line = null;
while((line = bufr.readLine())!=null){
if("over".equals(line))
break;
// println带有换行标记,可以 通过(System.out,true)来进行刷新,没有换行标记不能通过 true刷新
pw.println(line.toUpperCase());
// pw.flush();
}
pw.close();
bufr.close();
}
}
序列流
将多个读取流合并成一个读取流
Sequence没有OutputStream,只有InputStream
package day20;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
public 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<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();
}
}
文件的切割与合并
将MP3文件切割(splite)成part文件,再合并(merge)成一个新的MP3文件
package day20;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
public class SpliteFile {
public static void main(String[] args) {
spliteFile();
merge();
}
public static void merge(){
ArrayList<FileInputStream> al = null;
FileOutputStream fos = null;
SequenceInputStream sis = null;
byte[] buf = new byte[1024];
int len = 0;
try {
al = new ArrayList<FileInputStream>();
for(int x =1;x<5;x++){
al.add(new FileInputStream("c:\\splitefiles\\"+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();
}
};
sis = new SequenceInputStream(en);
fos = new FileOutputStream("c:\\splitefiles\\2.mp3");
while((len = sis.read(buf))!=-1){
fos.write(buf,0,len);
}
} catch (IOException e) {
throw new RuntimeException("文件合并失败");
}
finally{
try {
if(sis!=null)
sis.close();
} catch (IOException e) {
throw new RuntimeException("序列流关闭失败");
}
try {
if(fos!=null)
fos.close();
} catch (IOException e) {
throw new RuntimeException("输出流关闭失败");
}
}
}
public static void spliteFile() {
FileInputStream fis = null;
FileOutputStream fos = null;
byte[] buf = new byte[1024 * 1024];
int len = 0;
int count = 1;
try {
fis = new FileInputStream("c:\\1.mp3");
while ((len = fis.read(buf)) != -1) {
// count++第一次出现时不自增,代表count的值
fos = new FileOutputStream("c:\\splitefiles\\"+(count++)+".part");
fos.write(buf, 0, len);
}
} catch (IOException e) {
throw new RuntimeException("文件切割失败");
}
finally {
try {
if (fis != null)
fis.close();
} catch (IOException e) {
throw new RuntimeException("读取流关闭失败");
}
try {
if (fos != null)
fos.close();
} catch (IOException e) {
throw new RuntimeException("输出流关闭失败");
}
}
}
}