java笔记-IO流-文件操作

File类

用来将文件或者文件夹封装成对象，方便对文件和文件夹的属性进行操作，与此同时，文件对象可作为参数传递给流的构造函数。

File类的常见方法

1.创建

boolean createNewFile() 

当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。 如果指定的文件不存在并成功地创建，则返回 true；如果指定的文件已经存在，则返回 false 

static File createTempFile(String prefix, String suffix) 

在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。 

static File createTempFile(String prefix, String suffix, File directory) 

在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。 

 boolean mkdir() 

 创建此抽象路径名指定的目录。 

 boolean mkdirs() 

 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。 

2.删除

boolean delete() 

 删除此抽象路径名表示的文件或目录。 

 void deleteOnExit() 

在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。 

3.判断

boolean canExecute() 

测试应用程序是否可以执行此抽象路径名表示的文件。 

boolean canRead() 

测试应用程序是否可以读取此抽象路径名表示的文件。 

boolean canWrite() 

测试应用程序是否可以修改此抽象路径名表示的文件。 

int compareTo(File pathname) 

按字母顺序比较两个抽象路径名。 

boolean equals(Object obj) 

 测试此抽象路径名与给定对象是否相等。

boolean exists() 

 测试此抽象路径名表示的文件或目录是否存在。 

boolean isDirectory() 

测试此抽象路径名表示的文件是否是一个目录。

boolean isFile() 

测试此抽象路径名表示的文件是否是一个标准文件。 

boolean isHidden() 

 测试此抽象路径名指定的文件是否是一个隐藏文件。 

long lastModified() 

返回此抽象路径名表示的文件最后一次被修改的时间。 

java中一般不取隐藏文件。

4.获取

 File getAbsoluteFile() 

返回此抽象路径名的绝对路径名形式。 

String getAbsolutePath() 

返回此抽象路径名的绝对路径名字符串。

File getCanonicalFile() 

返回此抽象路径名的规范形式。 

String getCanonicalPath() 

返回此抽象路径名的规范路径名字符串。 

long getFreeSpace() 

返回此抽象路径名指定的分区中未分配的字节数。

String getName() 

返回由此抽象路径名表示的文件或目录的名称。 

String getParent() 

 返回此抽象路径名父目录的绝对路径名字符串；如果此路径名没有指定父目录，则返回 null。

File getParentFile() 

返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。 

String getPath() 

将此抽象路径名转换为一个路径名字符串。

long getTotalSpace() 

返回此抽象路径名指定的分区大小。 

long getUsableSpace() 

返回此抽象路径名指定的分区上可用于此虚拟机的字节数。 

列出指定目录中的文件

/*
 列出目录中的所有文件。
*/
import java.io.*;

class  FileNameDemo
{
	public static void main(String[] args) 
	{
		File f=new File("c:\\");
		//列出指定目录下的所有文件，包含隐藏文件。
		//在对该目录进行操作前，需明确该操作是否针对的是目录，并且该目录是否存在。
		if((f.isDirectory())&&(f.exists())){
			//返回的文件名存储在字符串数组中。
			String[] fileName=f.list();
			for(String n:fileName){
				System.out.println(n);
			}
		}
		else{
			System.out.println("不是目录，或者该目录不存在。");
		}
	}
}

列出目录中的java文件

/*
 列出目录中的所有java文件。
*/
import java.io.*;

class  FileNameDemo
{
	public static void main(String[] args) 
	{

		File f=new File("h:\\javabase\\day19\\");
		
		//列出指定目录下的所有文件，包含隐藏文件。
		//在对该目录进行操作前，需明确该操作是否针对的是目录，并且该目录是否存在。
		if((f.isDirectory())&&(f.exists())){
			//返回的文件名存储在字符串数组中。
			//以下方法使用匿名内部类。
			String[] fileName=f.list(new FilenameFilter(){
				public boolean accept(File f,String name){
					//若返回1则符合条件，否则不符合。
					return name.endsWith(".java");
				}
			});
			System.out.println("符合条件的文件个数："+fileName.length);
			for(String n:fileName){
				System.out.println(n);
			}
		}
		else{
			System.out.println("不是目录，或者该目录不存在。");
		}
	}
}

listFiles实例(列出的文件和目录包含绝对路径)

/*
 listFiles实例
 一般通过此方法列出目录下的文件和字目录
*/
import java.io.*;

class  ListFilesDemo
{
	public static void main(String[] args) 
	{
		listFile();
	}
	public static void listFile(){
		File f=new File("h:\\javabase\\day19");
		File[] nameStr=f.listFiles();
		for(File str:nameStr){
			System.out.println(str);
		}
	}
}

递归输出目录及其子目录中的所有文件

import java.io.*;
class  listAllFile
{
	public static void main(String[] args) 
	{
		//指定显示的目录
		File f=new File("h:\\javabase\\");
		//显示目录中的文件
		showDir(f);
	}
	public static void showDir(File f){
		File[] str=f.listFiles();
		//遍历存放目录的数组。
		for(int fCount=0;fCount<str.length;fCount++){
			//如果遍历到目录，则递归调用showDir()方法输出目录中的文件。
			if(str[fCount].isDirectory()){
				//打印目录名称。
				System.out.println(str[fCount]);
				//递归调用打印目录中的文件。
				showDir(str[fCount]);
			}
			//如果不是目录，直接输出。
			else{
				System.out.println(str[fCount]);
			}
		}
	}
}

统计文件夹内代码行数

/*
** 统计指定目录中特定文件的行数。
*/
import java.io.*;  
class  listAllFile  
{  
	static int totalLine=0;
    public static void main(String[] args) throws Exception  
    {  
		
        //指定统计的目录  
        File f=new File("h:\\javabase\\");  
        //显示目录中的文件  
        showDir(f);  
		System.out.println("Total code line is:"+totalLine);
    }  
    public static void showDir(File f)throws Exception{  
        File[] str=f.listFiles();  
        //遍历存放目录的数组。  
        for(int fCount=0;fCount<str.length;fCount++){  
            //如果遍历到目录，则递归调用showDir()方法输出目录中的文件。  
            if(str[fCount].isDirectory()){  
                //打印目录名称。  
                System.out.println(str[fCount]);  
                //递归调用打印目录中的文件。  
                showDir(str[fCount]);  
            }  
            //如果不是目录，直接输出。  
			else{  
				System.out.println(str[fCount]);  
				if(str[fCount].getName().endsWith(".java")){
					//获得文件的绝对路径
					File javaFile=new File(str[fCount].getAbsolutePath());
					System.out.println(javaFile.toString());
					
					BufferedReader bufr=new BufferedReader(new FileReader(javaFile));
					String line=null;
					while((line=bufr.readLine())!=null){
						//统计文件行总数。
						totalLine++;
					}
					
				}
			}  
        }  
    }  
}  

删除带内容的目录

/*
 删除带内容的目录
 在windows中，删除是从内向外删除，最先删除最内层的目录。
*/
import java.io.*;
class  removeDirDemo
{
	public static void main(String[] args) 
	{
		File f=new File("h:\\day19\\");
		removeDir(f);
	}
	//递归删除，从内到外。
	public static void removeDir(File f){
		File[] str=f.listFiles();
		//循环遍历文件。
		for(int x=0;x<str.length;x++){
			//如果是目录，再次递归循环
			if(str[x].isDirectory()){
				removeDir(str[x]);
			}
			//如果不是目录，直接删除。
			System.out.println(str[x].delete()+":"+str[x]);
		}
		//目录中的文件删除完后，只剩下空目录，此时再删除空目录。
		System.out.println(f.delete());
	}
}

建立java文件列表文件

/*
 需求：建立java文件列表文件
	将一个指定目录中的所有java文件的绝对路径存储到文本文件中。
 思路：
	1.根据指定目录循环递归遍历目录
	2.获取递归过程中所有文件的绝对路径
	3.将获取的绝对路径存储到集合中
	4.将集合存储到文本文件中

	文件名->集合->文件

*/
import java.io.*;
import java.util.*;
class  javaFileList
{
	public static void main(String[] args) throws Exception
	{
		File dir=new File("H:\\javabase\\");
		List<File> list=new ArrayList<File>();
		fileNameToList(dir,list);
		listToFile(list,"java.list");
	}
	//遍历目录，将符合要求的文件名存储在集合中。
	public static void fileNameToList(File dir,List<File> list){
		//列出指定目录中的文件名，并存储到File数组中。
		File[] fileList=dir.listFiles();
		//循环遍历数组，如果是目录，则递归。
		for(File f:fileList){
			if(f.isDirectory()){
				fileNameToList(f,list);
			}
			//如果不是目录，判断是否是java文件
			else{
				if((f.getName()).endsWith(".java")){
					//如果是java文件则存储到集合中。
					list.add(f);
				}
			}
		}
	}
	//将存储文件名的集合数据写入文本文件。
	public static void listToFile(List<File> list,String fileName){
		BufferedWriter bufw=null;
		try{
			bufw=new BufferedWriter(new FileWriter(fileName));
			//循环遍历数组，取出文件名并获取绝对路径，将该路径写入到文本文件。
			for(File f:list){
				String path=f.getAbsolutePath();
				bufw.write(path);
				//添加新行
				bufw.newLine();
				//将缓冲区数据刷新到文本。
				bufw.flush();
			}
		}
		catch(Exception e){
			throw new RuntimeException("写入异常。");
		}
	}
}

Properties配置文件的加载和修改

Properties是hashtable的子类，它具备map集合的特点，并且里面存储的键值对都是字符串，是集合中和IO技术相结合的集合容器，该对象通常用于键值对形式的配置文件。

/*
 需求：将存有键值对的配置文件按加载到Properties中。
	   若有数据修改，再将修改的数据存储到配置文件中。
*/
import java.util.*;
import java.io.*;
class PropertyDemo 
{
	public static void main(String[] args) throws IOException
	{
		FileToProperties();
	}
	//将存有键值对的配置文件按加载到Properties中。
	//若有数据修改，再将修改的数据存储到配置文件中。
	public static void FileToProperties()throws IOException{
		//建立文件到流的关系。
		FileInputStream fis=new FileInputStream("info.txt");
		Properties pro=new Properties();
		//将流中的数据加载到Properties中。
		pro.load(fis);
		//System.out.println(pro);
		//修改Properties键值对。
		pro.setProperty("wangwu","18");
		//将修改后的数据重新存储到配置文件中。
		FileOutputStream fos=new FileOutputStream("info.txt");
		pro.store(fos,"cs");
		pro.list(System.out);
	}
	public static void setAndGet(){
		Properties prop=new Properties();
		prop.setProperty("cs001","100");
		prop.setProperty("cs002","200");
		//System.out.println(prop);
		Set<String> s=prop.stringPropertyNames();
		for(String str:s){
		System.out.println(str+":"+prop.getProperty(str));
		}
	}
}

程序运行次数限制(Properties配置文件)

思路：

1.创建配置文件(若不存在，则创建)

2.若存在配置文件，读取配置文件中的程序运行次数

3.若达到运行次数，则程序结束

4.若达不到程序运行次数，则运行次数加一

5.将新增加的运行次数写入配置文件

6.关闭流，抛异常

/*
 达到程序运行设置次数，程序停止运行。
*/
import java.util.*;
import java.io.*;
class runTimes
{
	public static void main(String[] args) throws IOException
	{
		int count=0;
		//设置关联配置文件
		File file=new File("pro.ini");
		//在对文件操作前进行判断是否存在。
		if(!file.exists()){
			file.createNewFile();
		}
		Properties pro=new Properties();
		FileInputStream fis=new FileInputStream(file);
		//加载配置文件
		pro.load(fis);
		//根据键获取值。
		String value=pro.getProperty("time");
		//在对值操作前需先判断值是否为空。
		if(value!=null){
			count=Integer.parseInt(value);
			System.out.println("count:"+count);
			if(count>=5){
				System.out.println("运行次数已经到，请注册。");
				return ;
			}			
		}		
		//程序每运行一次，运行次数加1
		count++;
		//将新的运行次数存储进配置文件。
		pro.setProperty("time",count+"");
		FileOutputStream fos=new FileOutputStream(file);
		pro.store(fos,"cs");
		System.out.println(pro);
		//关闭流。
		fos.close();
		fis.close();
	}
}