黑马程序员——JAVA基础之File类，递归，打印流，合并切割流

------- android培训、java培训、期待与您交流！ ----------

File类

用来将文件或者文件夹封装成对象

方便对文件与文件夹的属性信息进行操作。

File对象可以作为参数传递给流的构造函数。

File类常见方法：

1，创建。

boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。 和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。

boolean mkdir():创建文件夹。只能在已经存在的目录中创建创建文件夹。

boolean mkdirs():创建多级文件夹。可以在不存在的目录中创建文件夹。

import java.io.File;
import java.io.IOException;

class FileDemo
{
	public static void main(String[] args) throws IOException
	{
		File f = new File("E:\\JAVA\\Demo\\a\\b\\c");

		System.out.println(f.mkdirs());

		File fi = new File("E:\\JAVA\\Demo\\a\\b\\c\\FileDemo.txt");

		System.out.println(fi.createNewFile());
	}
}

2，删除。

boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。

void deleteOnExit();在程序退出时删除指定文件。

import java.io.File;
import java.io.IOException;

class FileDemo
{
	public static void main(String[] args) throws IOException
	{
		File f = new File("E:\\JAVA\\Demo\\a\\b\\c\\FileDemo.txt");

		System.out.println(f.delete());
	}
}

3，判断。

exists() :文件是否存在.

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

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

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

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

isAbsolute(); 测试此抽象路径名是否为绝对路径名。

import java.io.File;
import java.io.IOException;

class FileDemo
{
	public static void main(String[] args) throws IOException
	{
		File f = new File("E:\\JAVA\\Demo\\a\\b\\c");

		System.out.println(f.exists());
		System.out.println(f.canExecute());
		System.out.println(f.isFile());
		System.out.println(f.isDirectory());
		System.out.println(f.isHidden());
		System.out.println(f.isAbsolute());
	}
}

4，获取信息。

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

getPath(): 此抽象路径名转换为一个路径名字符串。

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

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

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

long length() 返回由此抽象路径名表示的文件的长度。

import java.io.File;
import java.io.IOException;

class FileDemo
{
	public static void main(String[] args) throws IOException
	{
		File f = new File("E:\\JAVA\\Demo\\a\\b\\c\\FileDemo.txt");

		System.out.println(f.getName());
		System.out.println(f.getPath());
		System.out.println(f.getParent());
		System.out.println(f.getAbsolutePath());
		System.out.println(f.lastModified());
		System.out.println(f.length());
	}
}

5.修改

renameTo          重新命名此抽象路径名表示的文件。

import java.io.File;
import java.io.IOException;

class FileDemo
{
	public static void main(String[] args) throws IOException
	{
		File f = new File("E:\\JAVA\\Demo\\a\\b\\c\\FileDemo.txt");
		File f1 = new File("FileTest.txt");

		System.out.println(f.renameTo(f1));//等同于剪切粘贴
	}
}

import java.io.File;
import java.io.IOException;
/**
 *
 * 遍历一个目录,打印一级子文件
 *
 */
class FileDemo
{
	public static void main(String[] args) throws IOException
	{
		File dir = new File("E:\\");
		File[] files = dir.listFiles();

		for (File f : files)
		{
			System.out.println(f.getName()+"-------"+f.length());
		}
	}
}

import java.io.File;
import java.io.IOException;
/**
 *
 * 列出盘符
 *
 */
class FileDemo
{
	public static void main(String[] args) throws IOException
	{
		File[] files = File.listRoots();

		for (File f : files)
		{
			System.out.println(f);
		}
	}
}

import java.io.File;
import java.io.IOException;
/**
 *
 * 遍历一个目录,打印子文件
 *
 */
class FileDemo
{
	public static void main(String[] args) throws IOException
	{
		File dir = new File("E:\\Fetion");

		String[] names = dir.list();

		for (String name : names)
		{
			System.out.println(name);
		}
	}
}

接口 FilenameFilter       实现此接口的类实例可用于过滤器文件名

boolean accept(File dir, String name)      测试指定文件是否应该包含在某一文件列表中。

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
/**
 *
 * 遍历一个目录,打印某一种格式的子文件
 *
 */
class FileDemo
{
	public static void main(String[] args) throws IOException
	{
		File dir = new File("E:\\Fetion");

		String[] arr = dir.list(new FilenameFilter()
		{
			public boolean accept(File dir,String name)
			{
				return name.endsWith(".xml");
			}
		});

		System.out.println("len:"+arr.length);
		for (String name : arr)
		{
			System.out.println(name);
		}
	}
}

递归：函数自己调用自己。

注意：递归时一定要明确结束条件，避免溢出。

应用场景：  当某一功能要重复使用时。

import java.io.File;

/**
 *
 * 打印一个目录下所有子文件
 *
 */
public class DiguiDemo
{
	public static void main(String[] args)
	{
		File f = new File("E:\\黑马\\");

		printDir(f);
	}

	public static void printDir(File f)
	{
		if (f.isDirectory())
		{
			File[] files = f.listFiles();
			for (int x=0;x<files.length;x++)
			{
					printDir(files[x]);
			}
		}
		System.out.println(f.toString());
	}
}

import java.io.*;

/**
	打印一个目录下的所有文件，包括子文件目录下的文件
*/
class DirPrintDemo
{
	public static void main(String[] args)
	{
		File dir = new File("F:\\java");

		dirPrint(dir);
	}

	public static void dirPrint(File dir)
	{
		File[] files = dir.listFiles();

		System.out.println(dir);
		for (File file : files )
		{
			if (file.isDirectory())
				dirPrint(file);
			else
				System.out.println(file);
		}
	}
}

/*
删除一个带内容的目录。
删除原理：
在window中，删除目录从里面往外删除的。

既然是从里往外删除。就需要用到递归。
*/
import java.io.*;
class  RemoveDir
{
	public static void main(String[] args)
	{

		File dir = new File("E:\\JAVA\\Demo\\a");
		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]);
			else
				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.*;
class  JavaFileList
{
	public static void main(String[] args) throws IOException
	{

		File dir = new File("d:\\java1223");

		List<File> list = new ArrayList<File>();

		fileToList(dir,list);

		File file = new File(dir,"javalist.txt");
		writeToFile(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 writeToFile(List<File> list,String javaListFile)throws IOException
	{
		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 e;
		}
		finally
		{
			try
			{
				if(bufw!=null)
					bufw.close();
			}
			catch (IOException e)
			{
				throw e;
			}
		}
	}
}

打印流：

该流提供了打印方法，可以将各种数据类型的数据都原样打印。

 

字节打印流：

PrintStream

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

 

字符打印流：

PrintWriter

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

4，字符输出流，Writer。

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

Properties是hashtable的子类。

也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。

 

是集合中和IO技术相结合的集合容器。

该对象的特点：可以用于键值对形式的配置文件。

 

那么在加载数据时，需要数据有固定格式：键=值。

/*
用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示。

很容易想到的是:计数器。
可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。
可是随着该应用程序的退出，该计数器也在内存中消失了。

下一次在启动该程序，又重新开始从0计数。
这样不是我们想要的。

程序即使结束，该计数器的值也存在。
下次程序启动在会先加载该计数器的值并加1后在重新存储起来。

所以要建立一个配置文件。用于记录该软件的使用次数。

该配置文件使用键值对的形式。
这样便于阅读数据，并操作数据。

键值对数据是map集合。
数据是以文件形式存储，使用io技术。
那么map+io -->properties.

配置文件可以实现应用程序数据的共享。

*/
import java.io.*;
import java.util.*;
class  RunCount
{
	public static void main(String[] args) 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);

		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,"");

		fos.close();
		fis.close();
	}
}

合并流：

import java.io.*;
import java.util.*;
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();
	}
}

切割流：

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

class SplitFile
{
	public static void main(String[] args) throws IOException
	{
		//splitFile();
		merge();
	}

	public static void merge()throws IOException
	{
		ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();

		for(int x=1; x<=3; x++)
		{
			al.add(new FileInputStream("c:\\splitfiles\\"+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();
			}
		};

		SequenceInputStream sis = new SequenceInputStream(en);

		FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");

		byte[] buf = new byte[1024];

		int len = 0;

		while((len=sis.read(buf))!=-1)
		{
			fos.write(buf,0,len);
		}

		fos.close();
		sis.close();
	}

	public static void splitFile()throws IOException
	{
		FileInputStream fis =  new FileInputStream("c:\\1.bmp");

		FileOutputStream fos = null;

		byte[] buf = new byte[1024*1024];

		int len = 0;
		int count = 1;
		while((len=fis.read(buf))!=-1)
		{
			fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
			fos.write(buf,0,len);
			fos.close();
		}

		fis.close();

	}
}

------- android培训、java培训、期待与您交流！ ----------