黑马程序员_IO流3_(File操作,Properties,PrintWrite,合并流)

来源：互联网发布：南风知我意txt下载编辑：程序博客网时间：2024/06/05 22:56

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

一.File文件

1.File类
1)用来将文件或者文件夹封装成对象
2）方便对文件与文件夹的属性信息进行操作。
3）File对象可以作为参数传递给流的构造函数。
2.深入介绍File类
1）构造函数：
<1>public File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
如果给定字符串是空字符串，那么结果是空抽象路径名。
参数：
pathname - 路径名字符串
抛出：
NullPointerException - 如果 pathname 参数为 null
<2>public File(String parent,String child)根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
如果 parent 为 null，则创建一个新的 File 实例，
这与调用以给定 child 路径名字符串作为参数的单参数 File 构造方法效果一样。
否则，parent 路径名字符串用于表示目录，child 路径名字符串用于表示目录或文件。
如果 child 路径名字符串是绝对路径名，则用与系统有关的方式将它转换为一个相对路径名。
如果 parent 是空字符串，则通过将 child 转换为抽象路径名，并根据与系统有关的默认目录解析结果
来创建新的 File 实例。否则，将每个路径名字符串转换为一个抽象路径名，
并根据父抽象路径名解析子抽象路径名。
参数：
parent - 父路径名字符串
child - 子路径名字符串
抛出：
NullPointerException - 如果 child 为 null
<3>public File(File parent,String child)
根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
如果 parent 为 null，则创建一个新的 File 实例，
这与调用给定 child 路径名字符串的单参数 File 构造方法的效果一样。
2)字段摘要：
separator-----跨平台的目录分隔符
public static final String separator与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
此字符串只包含一个字符，即 separatorChar。

二File对象功能

1.创建：
boolean createNewFile() throws IOException
在指定位置创建文件，如果该文件已经存在，则不创建，返回false.
和输出流不一样，输出流对象一建立创建文件，而且文件已经存在，会覆盖。
boolean mkdir():创建文件夹。
boolean mkdirs():创建多级文件夹。
2.删除：
<1>boolean delete()
删除此抽象路径名表示的文件或目录。删除失败返回false.
<2>void deleteOnExit()
在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。在程序退出时删除指定文件。
注意：若前面的代码发生异常，则此时后面的删除操作就执行不到，此时就会产生垃圾。
就算是在finally中删除有时也未必有效。因为正在被流操作的文件会报提示无法删除。
此时用deleteOnExit()退出时删除方法就很容易解决这个问题了。
3.判断：
<1>boolean canExecute()
测试应用程序是否可以执行此抽象路径名表示的文件。
<2>boolean canRead()
测试应用程序是否可以读取此抽象路径名表示的文件。
<3>boolean canWrite()
测试应用程序是否可以修改此抽象路径名表示的文件。
<4>int compareTo(File pathname)
按字母顺序比较两个抽象路径名。
<5>boolean exists()
测试此抽象路径名表示的文件或目录是否存在。
<6>boolean isAbsolute()
测试此抽象路径名是否为绝对路径名。
<7>boolean isDirectory()
测试此抽象路径名表示的文件是否是一个目录。
<8>boolean isFile()
测试此抽象路径名表示的文件是否是一个标准文件。
<9>boolean isHidden()
测试此抽象路径名指定的文件是否是一个隐藏文件。
注意：文件夹也可能叫a.txt
4.获取信息：
<1>String getName()
返回由此抽象路径名表示的文件或目录的名称。
<2>String getParent()
返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
<3>File getParentFile()
返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。
<4>String getPath()
将此抽象路径名转换为一个路径名字符串。
<5>String getAbsolutePath()
返回此抽象路径名的绝对路径名字符串。
<6>long lastModified()
返回此抽象路径名表示的文件最后一次被修改的时间。
<7>long length()
返回由此抽象路径名表示的文件的长度。
<8>boolean renameTo(File dest)
重新命名此抽象路径名表示的文件。
5.文件列表
文件列表功能：
1）static File[] listRoots()
列出可用的文件系统根。
2）String[] list()
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
3）String[] list(FilenameFilter filter)
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
4）String[] list(FilenameFilter filter)
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
5）File[] listFiles()
返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
6）File[] listFiles(FileFilter filter)
返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
7）File[] listFiles(FilenameFilter filter)
返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目.
6. 例题一：列出目录下所有内容-递归

[java] view plaincopy
/*
1.需求：
 列出指定目录下文件或者文件夹，包含子目录中的内容。
 也就是列出指定目录下所有内容。
*/
class FileTest
{
public static void main(String[] args)
{
File dir = new File("d:javatest");
showDir(dir);
}
public static void showDir(File dir)
{
System.out.println(dir);
File files = dir.listFiles();
for(int x =0;x<files.length;x++)
{
if(files[x].isDirectory())
showDir(files[x]);
else
System.out.println(files[x]);
}
}
}

7.例题二：（创建java文件列表）
[java] view plaincopy
/*
练习
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。
建立一个java文件列表文件。
思路：
1，对指定的目录进行递归。
2，获取递归过程所以的java文件的路径。
3，将这些路径存储到集合中。
4，将集合中的数据写入到一个文件中。
*/
class JavaFile
{
public static void main(String[] args)
{
File dir = new File("D:\\javatest");
ArrayList<File> list = new ArrayList<File>();
//写到集合中。
file2List(dir,list);
File javalist = new File(dir,"javalist.txt");
write2File(list,javalist.toString());
}
public static void file2List(File dir,List<File> list)
{
File files = dir.listFiles();
for(File file : files)
{
if(file.isDirectory())
file2List(file,list);
else if(file.endsWith("java"))
list.add(file);
}
}
public static void write2File(List<File> list,String javalist)throws IOException
{
BufferedWriter bufw = null;
try
{
bufw = new BufferedWriter(new FileWriter(javalist));
for(File file : list)
{
String dirpath = file.getAbsolutePath();
bufw.write(dirpath);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException();
}
finally
{
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw e;
}
}
}
}

三.Properties集合

1.Map——— >Hashtable——>Properties(java.util包）

1)Properties是Hashtable的子类。也就是说具备Map集合的特点。而且它里面存储的键值对都是字符串。
 是集合和IO技术相结合的集合容器。
 该对象的特点：可以用于键值对形式的配置文件。但在加载数据时有固定格式：键 = 值。
2)构造方法：
Properties(）:创建一个无默认值的空属性的列表。
Properties（Properties default) 创建一个带有指定默认值的空属性的列表。
3)特有方法：
<1>String getProperty(String key) 用指定的键在此属性列表中搜索属性。
<2>String getProperty(String key,String defaultValue)
<3>Object setProperty(String key,String value) 调用它的父类Hashtable的put方法。
<4>Set<String> stringPropertyNames() 返回此属性列表中的键集，其中该键及其对应值是字符串。
如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。

2.Properties存取配置文件
1）Properties方法：
<1>void list<PrintStream out) 将属性列表输出到指定的输出流。
<2>void list<PrintWriter out) 将属性列表输出到指定的输出流。
<3>void load(InputStream inStream) 从输入中读取属性列表。（键和元素对）
<4>void load(Reader reader)按简单的面向行的格式从输入字符中读取属性列表（键和元素对）；
<5>void Store(Writer writer,String comments)
以适合使用load(Reader)方法的格式。将此Properties表中的属性列表写入输出流或文件中。
<6>void Store(OutputStream out ,String comments)
以适合使用load(InputStream )方法加载Properties表中的格式，将此Properties表中的属性列表写到输出流。

3.Properties例题
[java] view plaincopy
1)想要将info.txt中的键值对数据存到集合中进行操作。
思路：
<1>用一个读取流和info.txt文件关联。
<2>读取一行数据，将该行数据用“=”进行切割，
<3>等号左边作为键，等号右边作为值，存到Properties集合中即可。

Class PropertiesTest
{
 public static void main(String[] args)
 {
 Properties prop = new Properties();
 BufferedReader bufr = new BufferedReader(new FileReader("info.txt");
 String line = null;
 While((line = bufr.readLine()))!= null)
 {
 String[] str = line.split("=");
 prop.setProperty(str[0],str[1]);
 }
 bufr.close();
 }
}


2)例题二：
[java] view plaincopy
需求：
用于记录应用程序运行次数。
如果使用次数已到5次，那么给出注册提示。

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

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

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

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

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

class PropertiesTest2
{
 public static void main(String[] args)
 {
 Properties prop = new Properties();
 File file = new File("time.ini");
 if(!file.exists())
 file.creatNewFile();
 prop.load(new FileInputStream(file));

 int count = 0;
 String value = prop.getProperty("time");
 if(value!= null)
 {
 if(value>=5)
 System.out.println("使用次数已到");
 return;
 }
 count++;

 prop.setProperty("time",count+"");
 prop.store(new FileOutputStream(file),null);

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

 }
}

四.PrintWriter

1.IO包中的其他类
 1）打印流
 PrintWriter与PrintStream
 可以直接操作输入流和文件。
 2）合并流
 SequenceInputStream
 对多个流进行合并。
 3）对象序列化
 ObjectInputStream与ObjectOutputStream
 被操作的对象需要实现Serializable（标记接口）;

2.打印流：
 该流提供了打印方法，可以将各种数据类型的数据都原样打印。
 1）字节打印流：
 PrintStream
 构造函数可以接收的参数类型：
 <1>file对象。File
 <2>字符串路径。String
 <3>字节输出流。OutputStream
 2）字符打印流：
 PrintWriter
 构造函数可以接收的类型：
 <1>file对象。File
 <2>字符串路径。String
 <3>字节输出流。OutputStream
 <4>字符输出流。Writer.

3.Writer ---> PrintWriter类（java.io）
 1）向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream 中的所有 print 方法。
 它不包含用于写入原始字节的方法，对于这些字节，程序应该使用未编码的字节流进行写入。
3.Writer ---> PrintWriter类（java.io）
 1）向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream 中的所有 print 方法。
 它不包含用于写入原始字节的方法，对于这些字节，程序应该使用未编码的字节流进行写入。

 与 PrintStream 类不同，如果启用了自动刷新，则只有在调用 println、printf 或 format
 的其中一个方法时才可能完成此操作，而不是每当正好输出换行符时才完成。
 这些方法使用平台自有的行分隔符概念，而不是换行符。

 此类中的方法不会抛出 I/O 异常，尽管其某些构造方法可能抛出异常。
 客户端可能会查询调用 checkError() 是否出现错误。
2）字段摘要
 protected Writer out
 此 PrintWriter 的底层字符输出流。
 3）构造方法摘要
 <1>PrintWriter(File file)
 使用指定文件创建不具有自动行刷新的新 PrintWriter。
 <2>PrintWriter(OutputStream out)
 根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。
 <3>PrintWriter(OutputStream out, boolean autoFlush)
 通过现有的 OutputStream 创建新的 PrintWriter。
 <4>PrintWriter(String fileName)
 创建具有指定文件名称且不带自动行刷新的新 PrintWriter。
 <5>PrintWriter(Writer out)
 创建不带自动行刷新的新 PrintWriter。
 <6>PrintWriter(Writer out, boolean autoFlush)
 创建新 PrintWriter。
4）特有方法：
 void println(Object x)
 打印 Object，然后终止该行。
4.注意：
 System.out ---- PrintStream（OutputStream的子类）
 System.in ----- InputStream

五.合并流

1.InputStream ---> SequenceInputStream类（java.io包）
 1）SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，
 并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，
 直到到达包含的最后一个输入流的文件末尾为止。
 2）构造方法摘要
 <1>SequenceInputStream(Enumeration<? extends InputStream> e)
 通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。
 <2>SequenceInputStream(InputStream s1, InputStream s2)
 通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个参数，先读取 s1，然后读取 s2），以提供从此 SequenceInputStream 读取的字节。
3）方法摘要
 <1>int available()
 返回不受阻塞地从当前底层输入流读取（或跳过）的字节数的估计值，方法是通过下一次调用当前底层输入流的方法。（不明白这个方法）
 <2>void close()
 关闭此输入流并释放与此流关联的所有系统资源。
 <3>int read()
 从此输入流中读取下一个数据字节。
 <4>int read(byte[] b, int off, int len)
 将最多 len 个数据字节从此输入流读入 byte 数组。
2 切割文件例题
[java] view plaincopy
合并文件的时候，要用到集合，而Vector的效率太低，所以选择用ArrayList.
读取里要用用序列流SequenceInputStream.但该序列流要传入枚举类型的参数。
而枚举是Vector中的方法，ArrayList 中没有枚举方法，只有相似的Iterator迭代器
。故可建立枚举的匿名类，复写类中的方法以返回调用Iterator的方法即可。

注：匿名内部类访问的局部变量要用final修饰。

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

 public static void merge()throws IOException
 {
 ArrayList<FileInputStream> al = new ArraList<FileInputStream>();
 for(int x = 0;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 boolean nextElement(){
 return it.next();
 }
 };


 SequenceInputStream sis = new SequenceInputStream(en);

 FileOutputStream fos = new FileOutputStream("C\\splifies\\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("1.mp3");
 FileOutputStream fos = null;

 byte[] buf = new byte[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();

 }
 }

}