Java——File类和Properties类

最新推荐文章于 2022-08-16 10:05:31 发布

Zack-Avalanche

最新推荐文章于 2022-08-16 10:05:31 发布

阅读量468

点赞数

本文链接：https://blog.csdn.net/ozackaeris/article/details/47124745

版权

File类

File类是对文件和文件目录进行抽象的类，从而简化对文件的直接操作。

创建File对象时，可以对已存在或未存在的文件和目录名进行封装，许多对文件进行操作的流对象的构造函数都可以传入File对象。

构造方法：

相对路径：

File f = new File("a.txt");

绝对路径：

File d= new File("c:\\abc");

目录加文件名：

File f2=newFile("c:\\abc","b.txt");

常用方法：

1、创建：

boolean createNewFile() //创建新文件，返回true，如果文件已存在，则不作操作并返回false，区别于流的创建（流对象创建文件，已存在会覆盖）

boolean mkdir() //创建一级文件夹

boolean mkdirs() //创建多级文件夹

2、删除：

boolean delete() //删除文件成功删除则返回true

boolean deleteOnExit() //在程序退出时删除文件

3、判断：

boolean canExecute();//是否是可执行文件
boolean exists();//文件是否存在
boolean isFile();//是否是文件
boolean isDirectory();//是否是文件夹
boolean isHidden();//是否是隐藏文件
boolean isAbsolute();//文件是否是绝对路径

注意：在判断文件对象是否是文件或者目录时，必须先用exists()判断该文件对象是否存在。

4、获取属性：

String getName() //获取文件名
String getPath() //获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）
String getParent() //获取文件父目录。返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。如果相对路径中有上一层目录，那么该目录就是返回结果。
String getAbsolutePath() //获取文件的绝对路径
long lastModified() //返回文件最后一次被修改的时间
long length() //返回文件长度

其他方法：

String[] list() //列出当前目录下所有文件。
String[] list(FilenameFilter filter) //返回一个路径名数组，获取目录中满足指定过滤器的文件或目录。
File[] listFiles() //列出当前目录下所有文件，将路径下的文件封装成File对象并返回
File[] listFiles(FilenameFilter filter) //加入过滤器

文件过滤器的使用方法是：复写filter对象的accept(File file, String name)方法，已此方法来决定是否返回true，否则过滤掉。

示例：

import java.io.*;

class FileDemo2
{
	public static void main(String[] args)
	{
		//listRootsDemo();
		//listDemo();
		File dir = new File("E:\\my\\app\\eclipse\\heimaPractice");
		File[] files = dir.listFiles();
		for(File f : files)
		{
			print(f.getName()+ " : " + f.length());
		}
		
	}
	
	
	public static void filenameFileter()
	{
		File dir = new File("E:\\my\\app\\eclipse\\heimaPractice");
		String[] lists = dir.list(new FilenameFilter()
		{
			public boolean accept(File dir, String name)
			{
				return name.endsWith(".java");
			}
		});
		
		print("len: " + lists.length);
		for(String s : lists)
		{
			print(s);
		}
	}

练习一：打印一个指定目录下所以文件列表

思想：用递归方式将每一个文件夹视为根目录，如果有子文件夹，则对子文件夹进行相同的操作，直到遍历所以文件。

递归退出条件：File对象不是目录，也就是isDirectory()返回false

代码：

import java.io.File;

class FileDemo3
{
	public static void main(String[] args)
	{
		File dir = new File("E:\\my\\app\\c-cpp");
		showList(dir, 0);
	}
	
	public static String getLevel(int level)
	{
		StringBuilder sb = new StringBuilder();
		for(int i = 0; i < level; i++)
		{
			sb.append("  ");
		}
		
		return sb.toString();
	}
	
	public static void showList(File dir, int level)
	{
		print(getLevel(level) + dir);
		level ++;
		File[] files = dir.listFiles();
		for(int i = 0; i < files.length; i++)
		{
			
			if(files[i].isDirectory())
				showList(files[i], level);
			else
				print(getLevel(level) + files[i]);
		}
	}


	public static void print(Object obj)
	{
		System.out.println(obj);
	}
}

练习二：删除指定目录下的所有文件。

思想：类似遍历所以文件，同样用递归的方法，遍历到文件而不是文件夹时，将其删除，如果是目录则对其进行递归，如果目录为空则将文件夹删除。

递归退出条件：File对象不是目录，也就是isDirectory()返回false，并在每次目录递归后删除当前目录。

代码：

import java.io.File;
//删除指定目录下的所有文件和文件夹
class RemoveDir
{
	public static void main(String[] args)
	{
		removeDir(new File("removeDir"));
		//System.out.println(new File("removeDir").delete());
	}
	
	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() +"::"+ files[i].delete()));
			}
		}
		System.out.println(dir.toString() +"::" + dir.delete());
	}
}

Properties类

Properties类是对“属性 = 值”这种储存形式进行封装的类，所以它是HashTable类的子类，储存的元素是键值对，键和值都是字符串。

常用方法：

1、设置

Object setProperty(String key,String value) //设置键值

2、获取

String getProperty(String key) //通过键值获取属性值

Set<String> stringPropertiesName() //获取属性名的set集合

3、存储

void load(InputStream is) //从指定字节输入流获取键值对信息

void load(Reader r) //从指定字符输入流获取键值对信息

4、输出

void list(PrintStream ps) //将键值对信息从打印流输出

void store(OutpurStream os, String comments) //将键值对信息储存进指定输出流，comments是附加信息

void store(Writer w, String comments) //功能同上

示例：将一个存储键值对的文本信息读出，存入Properties对象。

import java.io.*;
import java.util.*;

class PropertiesDemo
{
	public static void main(String[] args)
	{
		//setAndGet();
                File list = new File("list.txt");
                Properties prop = new Properties();
                valueToList(list, prop);	
	}
	
	
	//将txt文本中的键值数据，放到集合中操作
	public static void valueToList(File list, Properties prop)throws IOException
	{
		String pair = null;
		BufferedReader bufr = new BufferedReader(new FileReader(list));
		while((pair = bufr.readLine()) != null) 
		{
			int cutPos =  pair.indexOf('=');
			String key = pair.substring(0, cutPos);
			String value = pair.substring(cutPos + 1);
			prop.setProperty(key, value);
		}
		bufr.close();
	}

练习：将程序运行次数存入配置文件，每运行一次加一，运行到五次后提示“注册”。

import java.util.*;
import java.io.*;

//记录程序运行次数，如果次数已到 则出现注册提示
class PropertiesTest
{
	public static void main(String[] args)throws IOException
	{
		RunCount();
	}
	
	public static void RunCount()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);//load方法可以直接将文本按格式读出，并存入Properties数组
		int count = 0;
		String value = prop.getProperty("time");
		if(value != null)
		{
			count = Integer.parseInt(value);
			if(count >= 5)
			{
				System.out.println("please register");
				fis.close();
				return ;
			}
		}
		count ++;
		
		prop.setProperty("time", count + "");
		
		FileOutputStream fos = new FileOutputStream(file);
		prop.store(fos, "");
		
		fos.close();
		fis.close();
	}
}

打印流类

打印流的目的是方便打印，特有方法是println，print，printf。printf可以接受format参数，从而按照指定格式打印。

打印流包括Printstream和PrintWriter，分别是打印字节流和打印字符流。

应用示例：

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.close();  
        bufr.close();  
  
    }     
}

SequenceInputStream类

SequenceInputStream可以将几个流合按顺序操作，好像将他们合成一个流。构造函数中可以传入两个或多个输入流，如果传入多个，则传入的是一个
Enumeration对象，也就是Vector的迭代器。

示例：

import java.io.*;
import java.util.*;

class SequenceInputStreamDemo
{
	public static void main(String[] args)throws IOException
	{
		Vector<FileInputStream> v = new Vector<FileInputStream>();
		v.add(new FileInputStream("1.txt"));
		v.add(new FileInputStream("2.txt"));
		v.add(new FileInputStream("3.txt"));

		Enumeration<FileInputStream> en = v.elements();
		SequenceInputStream sis = new SequenceInputStream(en);
		FileOutputStream fos = new FileOutputStream("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();
	}
}

分割文件：将一个文件分为大小相同的几份。

import java.io.*;
import java.util.*;

class SplitFileDemo
{
	public static void main(String[] args)throws IOException
	{
		File f = new File("test.mp3");
		splitFile(f);
	}
	
	public static void splitFile(File file)throws IOException
	{
		FileInputStream fis = new FileInputStream(file);
		int count = 0;
		byte[] buf = new byte[1024*1024*2];
		int len = 0;
		FileOutputStream fos = null;
	
		while((len = fis.read(buf)) != -1)
		{
			fos = new FileOutputStream("test" + count++ + ".part");
			
			fos.write(buf, 0, len);
			fos.close();
		}
		fis.close();
	}
}