目录:1、File概述 2、递归3、Properties类 4、管道流
1、File类概述
File类常见方法:
1,创建
boolean creatNewFile();在指定位置创建文件,如果该文件已经存在,则不创建,返回false。
static File createTempFile(String prefix,String suffix)在默认临时文件目录中创建一个空文件,使用给定前缀和后缀生成其名称。
static File createTempFile(String prefix,String suffix,File directory)在指定文件目录中创建一个空文件,使用给定前缀和后缀生成其名称。和输出流不一样,输出流对象一建立创建文件,而且文件已经存在,会覆盖
boolean mkdir();创建文件夹
boolean mkdirs();创建多级文件夹
2,删除
boolean delete():删除失败返回false
void deleteOnExit();在虚拟机终止时,请求删除此抽象路径名表示的文件或目录。在程序退出时删除指定文件
3,判断
boolean compareTo(File pathname)按字母顺序比较两个抽象路径名。
boolean exists():文件是否存在
isfile();测试此抽象路径名表示的文件是否是一个标准文件。
isDirectory();测试此抽象路径名表示的文件是否是一个目录
isHidden();/测试此文件是否是一个隐藏文件。
isAbsolute();测试此抽象路径名是否为绝对路径名。
4,获取信息
getName();获取名称
getPath()将此抽象路径名转换为一个路径名字符串。
getParent();返回此抽象路径名父目录的路径名字符串,如果此路径名没有指定父目录,则返回null.
getParentFile()返回此抽象路径名父目录的抽象路径名,如果此路径名没有指定父目录,则返回null.
getAbsolutePath();返回的是绝对路径名字符串
getAbsoluteFile();返回绝对路径名形式
long length()返回由此抽象路径名表示的文件的长度。
long lastModified() 返回最后一次被修改的时间。
示例
import java.io.*;
public class FileDemo {
public static void main(String[] args) throws IOException
{ method_2();
method_1();
consMethod();
}
public static void method_5()throws IOException
{
File f=new File("c:\\text.java");
File f1=new File("d:\\haha.java");
System.out.println("rename:"+f.renameTo(f1));//将f的名称换成f1的。
}
public static void method_4()throws IOException
{
File f=new File("d:\\abc\\file1.txt");
System.out.println("path:"+f.getPath());//封装什么就是什么
System.out.println("abspath"+f.getAbsolutePath());//不论是什么都是绝对的。
System.out.println("parent"+f.getParent());//该方法返回的是绝对路径中的父目录,如果获取的是相当路径,返回的是null
//如果相对路径中有上一层目录,那么该目录返回结果。
}
public static void method_3() throws IOException
{
File f=new File("file.txt");
//f.createNewFile();结果是文件是真,目录是假
f.mkdir();//结果是目录是真,文件是假。
//记住在判断文件对象是否是文件或者目的时,必须要先判断该文件对象封装的内容是否存在
//通过exists判断
System.out.println("dir:"+f.isDirectory());
System.out.println("file:"+f.isFile());
System.out.println(f.isAbsolute());//绝对路径的判断
}
public static void method_2()
{
File f=new File("file.txt");
//System.out.println("exists:"+f.exists());
//创建文件夹
File dir=new File("abc\\kkk");
System.out.println("mkdir:"+dir.mkdir());
//System.out.println("execute"+f.canExecute());测试应用程序是否可以执行此抽象路径名表示的文件。
}
public static void method_1() throws IOException
{
File f=new File("file.txt");
f.deleteOnExit();
//code();
System.out.println("creat:"+f.createNewFile());
System.out.println("delete:"+f.delete());
}
//创建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");
System.out.println("f1:"+f1);
System.out.println("f2:"+f2);
System.out.println("f3:"+f3);
File f4=new File("c:"+File.separator/*\\目录分隔符*/+"abc\\zzz\\a.txt");
}
}
2、递归
列出指定目录下文件或者文件夹,包含子目录中的内容,也就是列出指定目录下所有内容,因为目录中还有目录,只要使用同一个列出目录功能的函数完成即可。在列出过程中出现的还是目录的话,还可以再次调用本功能。也就是函数自身调用自身,这种表现形式,或者编程手法,称为递归。
递归要注意:
1,限定条件,
2,要注意递归的次数,尽量避免内存溢出。
import java.io.File;
public class Testl {
public static void main(String[] args)
{
File f=new File("D:jdk\\java");
show(f);
}
public static void show(File f)
{
File[] f1= f.listFiles();
for (int i = 0; i < f1.length; i++)
{
if (f1[i].isDirectory())
{
show(f1[i]); //如果是目录继续调用自己的方法。
}
else
System.out.println(f1[i]);
}
}
}
删除一个带内容的目录
删除原理:在window中,删除目录从里面往外删除的,既然是从里往外删除,就需要用到递归。java删除是不走回车站的。
import java.io.*;
public 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].isDirectory())
removeDir(files[x]);
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.*;
public class JavaFileList {
public static void main(String[] args) {
File dir=new File("d:\\java123");
List<File>list=new ArrayList<File>();
fileToList(dir,list);
//System.out.println(list.size());
File file=new File(dir,"javalist.txt");
writerToFile(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 writerToFile(List<File>list,String javaListFile)
{
BufferedWriter bufw=null;
try {
bufw = new BufferedWriter(new FileWriter(javaListFile));
for (File f : list) {
String path = f.getAbsolutePath();
bufw.write(path);
}
} catch (IOException e) {
throw new RuntimeException();
}
finally{
try {
if(bufw!=null)
bufw.close();
} catch (Exception e2) {
throw new RuntimeException();
}
}
}
}
3、Properties类
Properties是Hashtable的子类, 也就是说它具备map集合的特点,而且它里面存储的键值对都是字符串,不需要泛型。
是集合中和io技术相符合的集合容器
该对象的特点可以用于键值对形式的配置文件。
那么在加载数据时,需要数据有固定格式:键=值,必须有键和值。
void load(InputStream inStream)从输入流中读取属性列表(键和元素对)
void load(Reader reader)按简单的面向行的格式从输入字符流中读取属性列表(键和元素对)
void loadFromXML(InputStream in)将指定输入流中由XML文档所表示的所有属性加载到此属性表中。
Object setProperty(String key,String value)调用的Hashtable方法put。
Set(String) stringPropertyNames()返回此属性列表中的键集,其中该键及其对应值是字符串,如果是在主属性列表中未找到同名的键,则还包括默认属性列表中不同的键。
import java.io.*;
import java.util.*;
public class PropertiesDemo {
public static void main(String[] args) throws IOException
{ loadDemo();
//method_1();
//setAndGet();
}
//load方法原理。
public static void loadDemo() throws IOException
{
Properties prop=new Properties();
FileInputStream fis=new FileInputStream("info.txt");//先关联一个文件。
//将流中的数据加载进集合
prop.load(fis);
prop.setProperty("wangwu", "34");//改变内存的方法,操作集合中的数据.Property加载的是键值对。
FileOutputStream fos=new FileOutputStream("info.txt");
prop.store(fos, "hah");
//System.out.println(prop);
prop.list(System.out);//列出来
fos.close();
fis.close();
}
4、管道流:
管道读取流和管道写入流可以像管道一样对接上,管道读取流就可以读取管道写入流写入的数据。
注意:需要加入多线程技术,因为单线程,先执行read,会发生死锁,因为read方法是阻塞式的,没有数据的read方法会让线程等待。
public static void main(String[] args) throws IOException{
PipedInputStream pipin = new PipedInputStream();
PipedOutputStream pipout = new PipedOutputStream();
pipin.connect(pipout);
new Thread(new Input(pipin)).start();
new Thread(new Output(pipout)).start();
}
对象的序列化:目的:将一个具体的对象进行持久化,写入到硬盘上。
注意:静态数据不能被序列化,因为静态数据不在堆内存中,是存储在静态方法区中。
如何将非静态的数据不进行序列化?用transient 关键字修饰此变量即可。
Serializable:用于启动对象的序列化功能,可以强制让指定类具备序列化功能,该接口中没有成员,这是一个标记接口。这个标记接口用于给序列化类提供UID。这个uid是依据类中的成员的数字签名进行运行获取的。如果不需要自动获取一个uid,可以在类中,手动指定一个名称为serialVersionUID id号。依据编译器的不同,或者对信息的高度敏感性。最好每一个序列化的类都进行手动显示的UID的指定。
import java.io.*;
class ObjectStreamDemo {
public static void main(String[] args) throws Exception{
writeObj();
readObj();
}
public static void readObj()throws Exception{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
Object obj = ois.readObject();//读取一个对象。
System.out.println(obj.toString());
}
public static void writeObj()throws IOException{
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
oos.writeObject(new Person("lisi",25)); //写入一个对象。
oos.close();
}
}
class Person implements Serializable{
private static final long serialVersionUID = 42L;
private transient String name;//用transient修饰后name将不会进行序列化
public int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name+"::"+age;
}
}