黑马程序员_IO流操作_2

一、把文件实体化的类File

1)构造函数

File f=new File(“a.txt”);//这个文件不一定存在

separator是默认的目录分割符，具有跨平台性

2）功能

创建： boolean  creatNewFile（）；在指定位置创建文件，如果该文件已经存在则不创建。

临时文件：creatTempFile（）

mkdir（）：创建目录（文件夹）。只能创建一级目录

mkdirs（）；创建多级文件夹。  

删除：boolean delete();

      void  deleteOnExit();程序退出时删除文件

判断：boolean  canExecute（）：判断是否可执行

      Boolean  exists（）；文件是否存在

     isFile（）；是否是文件

     isDirectory（）；是否是目录

     判断文件或目录是必须先判断该文件对象封装的内容是否存在

     isAbsolute（）；判断是否是绝对路径。文件不存在也可判断

获取信息：

      getName();

      getPath();

getParent();//如果没有明确绝对路径的话，返回的是null。

getAbsolutePath()

long  lastModified()//最后一次修改的时间

long  length()

renameTo（）；重命名。相当于剪切

listRoot();列出了计算机中的盘符

list（）列出当前盘符下的所有文件

文件名过滤：

String[] arr=dir.list(new FilenameFilter()
{
    Public Boolean accept(File dir ,String name)
    { 
        Return  name.endsWith(“.bmp”);   
    }
}

遍历指定目录下的所有文件。利用递归原理

删除带内容的目录：

代码如下：

import java.io.*;
class FileDemo3 
{
	public static void main(String[] args) 
	{
		File dir = new File("d:\\testdir");
		System.out.println(dir.delete());
	}
	public static String getLevel(int level)
	{
		StringBuilder sb = new StringBuilder();
		sb.append("|--");
		for(int x=0; x<level; x++)
		{
			sb.insert(0,"|  ");
		}
		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 x=0; x<files.length; x++)
		{
			if(files[x].isDirectory())
				showDir(files[x],level);
			else
				System.out.println(getLevel(level)+files[x]);
		}
	}

总结：主要思想是利用递归原理，当判断是目录时然后再回调知道不是目录为止，这样一层一层的进入。

二、Properties对象的应用：

如下代码：

import java.io.*;
import java.util.*;
class  JavaFileList
{
	public static void main(String[] args) throws IOException
	{
		File dir = new File("d:\\java20");
		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;
			}
		}
	}
}

总结：这个代码主要的思想是：先建立一个集合用于存储所遍历到的目录，遍历目录时用的思想是递归算法，然后再利用流把集合中的数据写到文件中。

1. getProperty();//获取键值

2. setProperty();//设置键值

3. stringPropertyName();//返回的是Set集合

 Properties存取配置文件：

 把文件中的内容加载到Properties中通过load（）方法和store（）方法进行加载和保存，实际上他就是Map和IO的结合体。

限制一个程序运行的次数。

如下例子：

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

总结：思想是定义一个计数器，每运行一次，计数器加1，然后写到配置文件中，因为写入文件的计数器的值不会改变，当你读到五次时就不让读了

注： Properties类能够读取配置文件方便以后操作开发需要重点掌握

三、其他IO流相关类

PrintStream（）：

字节打印流构造函数可以接受的参数类型：File对象、字符串路径

字节输出流Outputstream

PrintReader（）；字符打印流 可以接受的参数类型：file对象，字符串路径字节输出流，字符输出流。

合并流：SequenceInputStream：

操作对象的流：ObjectInputStream   ObjectOutputStream

对象的持久化存储；注意事项：

1、 把对象传入并且写到文件中。

2、 对象必须实现Serializable接口

3、 如果想改变类中的内容，在经过ObjectInputStream读时会出现异常，因为当你改变类时与原来的类的序列号不对应了，解决这个问题可以自定义一个固定的序列号，

4、 静态的不能被序列化。

5、 如果不想被序列化，加上transient

管道流：PipedInputStream  PipeOutputStream

RandomAccessFile 随机访问文件的读取和写入

1、 只能操作文件

2、  writeIn();写入四个字节

3、 构造函数中要传入模式

4、 可以调整指针来取出想要的seek（8）

5、 SkipBtes（）；跳过多少个字节。取下一个

6、 可以随机添加

7、 如果模式为只读r，不会创建文件，回去读取一个已存在的文件，如果为rw模式，文件如果没有会创建

一、 操作对象的流--------àObjectOutputStream ObjectInputStream

主要的特点是它可以将对象存入文件中。

管道流 ------àpipedInputStream  pipedOutputStream

不建议使用单线程，因为容易发生死锁，

 pipedInputStream  in=new pipedInputStream();

 pipedOutputStream out=new pipedOutputStream();

 in.connect(out) ;----à把两个流联系起来

三、 RandomAccessFile内部封装了一个数组，可以通过getFilePointer()获取指针的位置，可以通过seek改变指针的位置。

注意：该类只能操作文件

在操作文件时时有模式的，例如r，rw

 如果你写入的模式是r，则表示只能进行读操作

 如果你写入的是rw，则表示既可以进行读操作，又可以进行写操作

RandomAccessFile类可以在任意位置进行读写，因为有skipBytes( )方法，它可以跳过指定的字节数。Seek()可以调整指针的位置

DataInputStream与DataOutputStream

用于操作基本数据类型的数据的流对象。