File 文件类
用来将文件或者文件夹封装成为对象。
方便对文件与文件夹的属性信息进行操作。
File对象可以作为参数传递给流的构造函数。
</pre></div><div></div><h2>File 类的常用的方法。</h2><div><pre name="code" class="java">import java.io.*;
/*File类的常见方法
1.创建。
boolean createNewFile();
boolean mkdir();创建文件夹
boolean mkdirs();创建多级文件夹。
2.删除。
boolean delete();
void deleteOnExit();在程序退出时删除文件。
3.判断。
boolean canExcute(); 判断是否可执行
boolean exists(); 文件事是否存在。
isFile();文件
isDirectory();文件夹
isHidden();//java能得到文件中的隐藏文件但是对隐藏文件时不能访问的
isAbsolute();//绝对路径即时不存在也能得到。
4.获取信息。
getName();
getPath();
getParent();
getAbsolutePath();
long lastModified();
long length();
*/
public class FileDemo {
/**
* @param args
*/
public static void main(String[] args)throws IOException {
// TODO Auto-generated method stub
method_4();
}
public static void method_1() throws IOException{
File f= new File("d:\\file.txt");
f.deleteOnExit();//告诉程序当程序结束时才删除f关联的文件 即使发生异常也不受影响
//System.out.println("creat:"+f.createNewFile());
System.out.println("delete:"+f.delete());
}
public static void method_2(){
File f = new File("file.txt");
// System.out.println("execute:"+f.canExecute());
// System.out.println("exists:"+f.exists());
//创建文件夹
File dir = new File("d:\\abc");
File dirs = new File("d:\\abc\\a\\b\\c");
System.out.println("dir:"+dir.mkdir());
System.out.println("dirs:"+dirs.mkdirs());
}
public static void method_3(){
File f = new File("file.txt");
System.out.println("path:"+f.getPath());
System.out.println("absolutePath:"+f.getAbsolutePath());
System.out.println("parentpath:"+f.getParent());//该方法返回的是绝对路径中文件的父目录。如获取的是相对路径返回的是null。
// 如果相对路径中有上一层目录那么该目录就是返回结果。
}
public static void method_4(){
File f1= new File("d:\\a.txt");
File f2= new File("haha.txt");
System.out.println(f2.renameTo(f1));//类似于剪切功能
}
public static void consMethod(){
//将a.txt封装成file对象，可以将已有的和为出现的文件或者文件夹封装为对象。
File f1 = new File("d:\\a.txt");
File f2 = new File("d:\\abc","b.txt");
File d = new File("d:\\abc");
File f3= new File(d,"a.txt");
System.out.println("f1:"+f1);
System.out.println("f2:"+f2);
System.out.println("f3:"+f3);
//跨平台分隔符<span style="font-family: Arial, Helvetica, sans-serif;">File.separator</span>
File f4 = new File("d:"+File.separator+"abc"+File.separator+"a.txt");
System.out.println("f4:"+f4);
}
}
获取系统根目录例子
import java.io.*;
public class FileDemo2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
listDemo();
}
public static void listDemo(){
File f = new File("d:\\");
String[] names= f.list();//调用list方法的对象必须封装一个目录，封装文件返回为null
for(String name : names){
System.out.println(name);
}
}
public static void listRootsDemo(){
File[] files=File.listRoots();
for(File f: files)
{
System.out.println(f);
}
}
}
递归输出文件列表
import java.io.*;
/*
列出指定目录下的文件或文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容。
递归注意
1 注意要有结束
2 要注意递归的次数 防止内存溢出
*/
public class FileDemo3 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
File f= new File("d:\\u盘备份");
showDir(f,0);
//System.out.println(getSum(10));
}
public static String getLevel(int level)
{
StringBuilder sb= new StringBuilder();
for(int i=0; i<level;i++){
sb.append(" ");
}
sb.append("|--");
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 i=0;i<files.length;i++)
{
if(files[i].isDirectory())
showDir(files[i],level);
else
System.out.println(getLevel(level)+files[i]);
}
}
//补充:递归方法求和
public static int getSum(int num){
if(num==1)
return 1;
else return num+getSum(--num);
}
}
删除文件夹实例
import java.io.*;
/*
* 删除文件夹要先删除里边的文件。因此就要用到递归了
* 从里往外删除文件
*
*/
public class FileRemoveDir {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
File file= new File("d:\\abc");
removeDir(file);
}
public static void removeDir(File dir)
{
File[] files =dir.listFiles();
for(int i=0;i<files.length;i++)
{
if(files[i].isDirectory())
{
removeDir(files[i]);
}else
System.out.println(files[i].toString()+"file:"+files[i].delete());
}
System.out.println(dir+"dir:"+dir.delete());
}
}
查找文件夹指定类型保存在文件中
import java.io.*;
import java.util.*;
/*
将一个指定目录下的java文件的绝对路径，存储到一个文件中。
建立一个java文件列表清单。
思路：
1.对指定的目录进行递归。
2.获取递归过程所有的java文件的路径。
3.将这些路径存储到集合中。
4.将集合中的数据写入到一个中。
* */
public class JavaFileList {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
File dir = new File("d:\\u盘备份");
List<File> list= new ArrayList<File>();
fileToList(dir,list);
File f =new File("javaList.txt");
writeToFile(list,f);
}
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 f) throws IOException
{
BufferedWriter bw= new BufferedWriter(new FileWriter(f));
try{
for(File file: List)
{
String path= file.getAbsolutePath();
bw.write(path);
bw.newLine();
bw.flush();
}
}catch(Exception e){
throw new RuntimeException("失败！");
}
finally{
try{
if(bw!=null)
bw.close();
}catch(Exception ex){
throw new RuntimeException("关闭失败！");
}
}
}
}
Propreties与流关联的集合类HashTable的子类
import java.io.*;
import java.util.*;
public class PropertiesDemo {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//setAndget();
//method_1();
loadDemo();
}
//load方法进行文件的集合加载。
public static void loadDemo() throws IOException
{
FileInputStream fis= new FileInputStream("info.txt");
Properties prop= new Properties();
prop.load(fis);
prop.list(System.out);
prop.setProperty("wangwu","25");
FileOutputStream fos= new FileOutputStream("info.txt");
prop.store(fos, "haha");
}
//将info.txt中的键值数据存到集合中进行操作。
/*步骤:
1.用一个流和info.txt文件关联。
2.读取一行数据，将该数据用"="进行切割。
3.等号左边为建，右边卫值。存入Porperties集合中即可.
*/
public static void method_1() throws IOException
{
BufferedReader br= new BufferedReader(new FileReader("info.txt"));
String line=null;
Properties prop= new Properties();
while((line=br.readLine())!=null)
{
String[] s=line.split("=");
prop.setProperty(s[0], s[1]);
}
System.out.println(prop);
}
//设置和获取元素
public static void setAndget()
{
Properties prop = new Properties();
prop.setProperty("zhangsan", "34");
prop.setProperty("lisi", "22");
System.out.println(prop);
String value =prop.getProperty("zhangsan");
System.out.println(value);
Set<String> names = prop.stringPropertyNames();
for(String name:names)
{
System.out.println(prop.getProperty(name));
}
}
}
Properties实现程序的使用次数限制
/*用于记录应用程序的次数。
如果使用次数已到，那么给出注册信息。
思路:
通过Properties属性文件将使用次数的属性存在此文件中，每次使用一次将计数
属性修改并重新存到属性文件中，此操作就要借用Properties对象进行操作。
属性文件用于键值对的存储方式。
这样便于对数据操作。
键值对是map集合
数据是以文件的形式存储，使用io数据。
*/
import java.io.*;
import java.util.*;
public class PropertiesCount {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
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,"haha");
}
}
PrintStream与PrintWriter 打印流的用法
/*打印流}}
为了方便各种数据类型的原样打印。
字节打印流
PrintStream
可以接收的参数类型
1.file对象 File
2.字符串路径。String
3.字节输出流 OutputStream
PrintWriter
可以接收的参数类型
1.file对象 File
2.字符串路径。String
3.字节输出流 OutputStream
4.字符输出流 Writer
*/
import java.io.*;
public class PrintStreamDemo {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
BufferedReader bufr=
new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
String line = null;
while((line=bufr.readLine())!=null)
{
out.println(line.toUpperCase());
out.flush();
}
out.close();
bufr.close();<pre name="code" class="java">
DataInputStream和DataOutputStream 基本数据操作流
import java.io.*;
/*
DataStream类主要用于操作基本数据类型的流的读取和写入
*/
public class DataInputStreamDemo {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
//writeData();
//readData();
writeUTFDemo();
}
public static void writeUTFDemo() throws IOException
{
DataOutputStream dos =
new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeUTF("你好");
dos.close();
}
public static void readData() throws Exception
{
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
int num =dis.readInt();
boolean b= dis.readBoolean();
double d= dis.readDouble();
System.out.println("num:"+num);
System.out.println("b:"+b);
System.out.println("d:"+d);
}
public static void writeData() throws IOException
{
DataOutputStream dos =
new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeInt(234);
dos.writeBoolean(true);
dos.writeDouble(444.456);
dos.close();
}
}
ObjectInputStream和ObjectOutputStream对象操作流
import java.io.*;
public class ObjectStreamDemo {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
writeObj();
readObj();
}
public static void readObj() throws IOException, IOException, ClassNotFoundException
{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
Person p =(Person)ois.readObject();
System.out.println(p);
ois.close();
}
public static void writeObj() throws IOException, IOException
{
ObjectOutputStream oos=
new ObjectOutputStream(new FileOutputStream("obj.txt"));
oos.writeObject(new Person("lisi",39,"china"));
oos.close();
}
}
class Person implements Serializable
{
/**
* 自定义
*/
private static final long serialVersionUID = 1L;
private String name;
transient int age;//关键字transient定义的成员也不能被序列化 在堆内存中也无法被序列化
static String country="cr" ;//静态成员不能被序列化，不再堆内存中
Person(String name ,int age,String country){
this.name=name;
this.age=age;
this.country=country;
}
public String toString(){
return name+":"+age+country;
}
}
PipedInputStream 和PipedOutputStream 管道操作流
import java.io.*;
public class PipedStreamDemo {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
PipedInputStream pis= new PipedInputStream();
PipedOutputStream pos= new PipedOutputStream();
pis.connect(pos);
PipedRead read = new PipedRead(pis);
PipedWrite write = new PipedWrite(pos);
new Thread(read).start();
new Thread(write).start();
}
}
class PipedRead implements Runnable
{
private PipedInputStream in;
PipedRead(PipedInputStream i)
{
this.in=i;
}
@Override
public void run() {
// TODO Auto-generated method stub
try
{ byte[] buf = new byte[1024];
int len=in.read(buf);
String s = new String(buf,0,len);
System.out.println(s);
in.close();
}catch(Exception e)
{
throw new RuntimeException("读取失败");
}
}
}
class PipedWrite implements Runnable{
private PipedOutputStream pos;
PipedWrite(PipedOutputStream out){
this.pos= out;
}
@Override
public void run() {
// TODO Auto-generated method stub
try
{
Thread.sleep(6000);
pos.write("ge men lai le".getBytes());
pos.close();
}catch(Exception e)
{
throw new RuntimeException("写入流失败！");
}
}
}
RondomAccessFile 随机文件读写流
import java.io.*;
/*RandomAccessFile
该类不是IO体系中的子类
而是直接继承Object
但是他是IO包中的成员，因为它具有读写数据的功能。
内部封装了一个数组，而且通过指针对数据元素进行操作。
可以通过getFilePointer 获取指针的位置。
同时可以通过seek方法改变指针的位置。
其实就是内部封装了字节输入流和输出流。
通过其拥有的构造函数可以看出，该类只能操作文件。
而且操作文件还有固定的模式。只读 r 读写rw
如果是只读模式去操作文件，读取已有的文件入如果问价不存在就会报错。
如果是读写，如果没有文件会创建一个文件在写入。
*/
public class RandomAccessFileDemo {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
writeFile();
readFile();
}
public static void readFile() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("random.txt","r");
//seek方法的使用很频繁 将读取文件中的指针调整位置读取数据
raf.seek(8*3);//跳过开头的8个字节开始读取数据。
byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age= raf.readInt();
System.out.println("name:"+name);
System.out.println("age:"+age);
raf.close();
}
public static void writeFile() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("random.txt","rw");
raf.write("李四".getBytes());
//raf.write(97);//write 方法是写入最低八位的二进制形式。
raf.writeInt(97);//writeInt()方法是写入四个字节不会出现乱码。
raf.write("王五".getBytes());
raf.writeInt(99);
raf.seek(8*3);//跳过一个8字节写入数据
raf.write("周七".getBytes());
raf.writeInt(98);
raf.close();
}
}