文件是计算机系统存放信息的重要途径。对文件的操作是最经常使用的输入输出操作，Java语言的输入输出是通过java.io包中的类实现的。File对象表示文件和目录。通过File对象可以实现对文件或者目录进行访问。如文件的名称、长度、读写属性。甚至可以创建、删除文件或目录。
一、创建File对象：
1、File类的常用构造方法：
File（String pathname）:创建一个File对象，其中pathname可以是文件名，也可以是路径名 。
File(String parent,String child):创建一个File对象，其中parent是一个路径名，child可以是一个文件名，也可以是一个路径名。
File(File parent,String child):创建一个File对象,其中parent是表示路径的File对象，child可以是一个路径名也可以是一个文件名。
说明：使用哪种构造方法取决于所使用的其他文件对象。例如如果在应用程序中之使用一个文件，那么使用第一个构造 函数来创建File对象。如果使用一个公共目录下的若干文件，则使用第二或者第三个构造函数较为方便。
2、创建对象：
下面通过以上的构造方法创建File对象 f1、f2、f3、f4
File f1 = new File("d:\\study"); //创建一个表示路径的File对象。
File f2 = new File("data.txt"); //创建一个表示文件的File对象。
File f3 = new File("d:\\study","data.txt"); //创建一个表示路径和文件的File对象。
File f4 = new File(f1,"data.txt"); //创建一个指定f1目录和文件名的File对象。
3、分隔符：
对与不同的系统分隔符是不一样的，\\是Windows系统的分隔符。在UNIX系统下使用/作为分隔符。要想知道该系统使用什么分隔符，可以使用System类中的getProperty("File.separator")方法。
在Java的API文档中我们可以发现Java语言中定义了separator字段作为分隔符的标记。我们就可以把上面的f1对象写成
File f1 = new File("d"+File.separator+"study");
二、File对象的常用方法：
1、创建： boolean createNewFile() 在指定路径创建文件，如果文件已经存在或者路径名不存在则返回false。
2、删除：
boolean delete() 删除此抽象路径名表示的文件或目录
boolean deleOnExit() 在程序退出时删除指定文件。
3、判断
4、获取信息
String getName() 返回由此抽象路径名表示的文件或目录的名称
Sring getPath() 将此抽象路径名转换为一个路径名字符串.
String getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null。如果相对路径中有上一层目录那么该目录就是返回结果。
File getAbsolutePath() 返回此抽象路径名的绝对路径名形式
String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串
long lastModified() 返回此抽象路径名表示的文件最后一次被修改的时间
long length() 返回由此抽象路径名表示的文件的长度
Flie[] listRoots() 列出可用的文件系统根
String[] list() 列出该路径下所有文件及文件夹的名字。该方法如果被封装成文件的File对象调用，则返回null。所以调用该方法的File对象必须是封装成路径的File路径，并且该路径必须存在。
代码示例：
[java] view plaincopy
<span style="font-size:14px;">import java.io.*;
class FileDemo
{
public static void main(String[] args) throws IOException
{
//File类构造方法的演示
//将d:\FileDemo\normal路径封装在File对象f1中
File f1 = new File("d:"+File.separator+"FileDemo"+File.separator+"normal");
//将d:\FileDemo\normal\a.txt文件封装在File对象f2中
File f2 = new File("d:"+File.separator+"FileDemo"+File.separator+"normal"+File.separator+"a.txt");
//在f1封装的目录下，封装b.txt文件
File f3 = new File(f1,"b.txt");
//运用相对路径在当前目录下封装c.txt文件
File f4 = new File("c.txt");
//创建f2、f3、f4的文件对象。因为f1只是封装的路径不能创建实体对象
f2.createNewFile();
f3.createNewFile();
f4.createNewFile();
//getName方法的应用 返回该File对象的文件或者目录的名称
String name = f1.getName();
System.out.println("f1对象的名称是："+name);
//getPath()方法的应用 返回该对象的路径字符串，封装的是什么就返回什么
String f1path = f1.getPath();
String f4path = f4.getPath();
System.out.println("f1的路径字符串是："+f1path);
System.out.println("f4的路径字符串是："+f4path);
//getabsolutePath()方法的使用 无论封装的是相对路径还是绝对路径都返回绝对路径的字符串
String f1abspath = f1.getAbsolutePath();
String f4abspath = f4.getAbsolutePath();
System.out.println("f1的绝对路径是："+f1abspath);
System.out.println("f4的绝对路径是："+f4abspath);
//listRoots()和list()方法的使用 返回系统的根目录
File[] roots = File.listRoots();
for(File root:roots)
{
System.out.println(root);
String[] listname = root.list();
for(String na:listname)
{
System.out.println(na);
}
}
}
}</span>
5、renameTo:
通过File 1的对象去调用作用于File 2的对象。此时，把File 1的文件名给File 2的文件。相当于剪切。
示例：
[java] view plaincopy
import java.io.*;
class RenameTo
{
public static void main(String[] args)
{
File f1 = new File("f:"+File.separator+"录像-000 (1).mp4");
File f2 = new File("d:"+File.separator+"hello.mp4");
boolean bl = f1.renameTo(f2);
System.out.println("结果："+bl);
}
}
6、String list(FilenameFilter filter)
按照定义的要求过滤文件名。FilenameFilter是一个接口，使用的时候必须要覆盖其中的boolean accept(File dir,String name)。在覆盖accept方法时，将符合要求的文件名的文件返回值为真，即达到过滤的要求。
例：将指定路径中的java文件列出来
[java] view plaincopy
import java.io.*;
class FilenameFilterDemo
{
public static void main(String[] args)
{
//将即将过滤的路径封装在File文件f_path中
File f_path = new File("J:\\JAVA\\day20\\day20");
//调用list(FilenameFilter filter)方法过滤
String[] names = f_path.list(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
return name.endsWith(".java");
}
});
//打印过滤的结果
for(String name:names)
{
System.out.println(name);
}
}
}
7、递归方法：
程序调用自身的编程技巧称为递归。
1、运用递归的时候应注意的方面：
（1）限定条件：因为是自己调用自己。如果没有限定条件或者限定条件不严谨的时候，很容易让程序出现死循环。
（2）要注意递归的次数。尽量避免内存溢出。
2、递归的应用：
列出一个文件夹中所有的文件，如果文件夹中还有文件夹就遍历里边的文件夹，直至把所有的文件都遍历出来。
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归
代码示例：
[java] view plaincopy
import java.io.*;
class ListFileDemo
{
public static void main(String[] args)
{
//定义将要遍历的路径
File f1 = new File("j:\\java");
//调用showfile方法将其列出
showfile(f1);
}
public static void showfile(File dir)
{
File[] files = dir.listFiles();
for(int x=0;x<files.length;++x)
{
if(!files[x].isDirectory())
System.out.println(files[x].getName());
//如果包含目录，则再次调用showfile方法————递归
if (files[x].isDirectory())
{
showfile(files[x]);//递归
}
}
}
}
8、练习：将一个目录下所有的java文件的名称以及路径存贮在txt的文本文件中。
思路：
1，对指定的目录进行递归。
2，获取递归过程所以的java文件的路径。
3，将这些路径存储到集合中。
4，将集合中的数据写入到一个文件中。
代码示例：
[java] view plaincopy
import java.io.*;
import java.util.*;
class JavaList
{
public static void main(String[] args) throws IOException
{
File path = new File("j:\\java");
List<File>list = new ArrayList<File>();
fileToList(path,list);
listToFile(list);
System.out.println(list.size());
}
public static void fileToList(File dir,List<File>list)
{
File[] files = dir.listFiles();
for (int x=0;x<files.length ;++x )
{
if(files[x].isDirectory())
fileToList(files[x],list);
else
{
if(files[x].getName().endsWith(".java"))
list.add(files[x]);
}
}
}
public static void listToFile(List<File>list)throws IOException
{
BufferedWriter bf = new BufferedWriter(new FileWriter("D:\\FileDemo\\normal\\javaList.txt"));
for(File f:list)
{
String path1 = f.getAbsolutePath();
bf.write(path1);
bf.newLine();
bf.flush();
}
bf.close();
}
}
Properties类
Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。一个属性列表可包含另一个属性列表作为它的“默认值”；如果未能在原有的属性列表中搜索到属性键，则搜索第二个属性列表。因为Properties 继承于Hashtable，所以可对 Properties 对象应用put 和 putAll 方法。但不建议使用这两个方法，因为它们允许调用者插入其键或值不是 String 的项。相反，应该使用setProperty 方法。如果在“不安全”的Properties
对象（即包含非 String 的键或值）上调用store 或 save 方法，则该调用将失败。类似地，如果在“不安全”的 Properties 对象（即包含非String 的键）上调用propertyNames 或 list 方法，则该调用将失败。
1、设置和获取元素
1、建立一个Properties对象。
2、通过setProperty(String,String)设置键值对。
3.通过getProperty(String key)获取该键所对应的值。
代码示例
[java] view plaincopy
import java.util.*;
class PropertiesDemo
{
public static void main(String[] args)
{
//建立Properties对象
Properties pro = new Properties();
//设定值
pro.setProperty("张三","30");
pro.setProperty("lisi","29");
//打印Properties对象中的值
System.out.println(pro);
//获取指定键的值
String value = pro.getProperty("lisi");
//遍历所有键及值
System.out.println(value);
Set<String> names = pro.stringPropertyNames();
for(String name:names)
{
System.out.println(name+"::"+pro.getProperty(name));
}
}
}
2、Properties获取配置文件
1、自定义方法获取
步骤：
1、通过一个流对象与配置文件相关联
2、读取一行，将得到的字符串用“=”进行切割
3、等号左边为键，等号右边为值。
用到的方法：
代码示例
[java] view plaincopy
import java.io.*;
import java.util.*;
class PropertiesFile
{
public static void main(String[] args) throws IOException
{
//定义一个读取流和配置文件相关联
BufferedReader br = new BufferedReader(new FileReader("d:\\peizhi.ini"));
//遍历文件中的每一组配置信息
for (String string=br.readLine(); string!=null; string=br.readLine())
{
String[] keyva = string.split("=");
System.out.println(keyva[0]+"::"+keyva[1]);
}
}
}
2、通过load(Reader/InputStream)方法获取
1、步骤：
1、建立一个流对象使之与配置文件相关联
2、建立一个Properties对象。
3.通过Properties的对象调用load(流对象)，并将建立的流对象当作参数传递给load方法。
4、通过setProperty(String,String)设置键值
5.通过Properties对象调用list(输出流对象)，输出配置信息。
6、建立一个输出流与配置文件相关联。
7、通过Properties的对象调用store(输出流，“注释信息”)将修改后的信息保存到配置文件。
8.关闭流。
2、用到的方法
void load(输入流)
void list(输出流)
void store(输出流，“注释信息”)
3、代码示例：
[java] view plaincopy
import java.io.*;
import java.util.*;
class LoadDemo
{
public static void main(String[] args) throws IOException
{
//建立Properties对象和与配置文件相关联的输入流对象
Properties pro = new Properties();
FileInputStream in = new FileInputStream("d:\\peizhi.txt");
//将配置信息载入Properties对象
pro.load(in);
//设置（修改）配置信息，并将其保存在配置文件
pro.setProperty("longhailong","55");
FileOutputStream out = new FileOutputStream("d:\\peizhi1.txt");
pro.store(out,"haah");
pro.list(System.out);
out.close();
in.close();
}
}
IO包中的其他流对象
一、打印流（PrintStream和PrintWriter）
PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。它还提供其他两项功能。与其他输出流同，PrintStream 永远不会抛出 IOException；而是，异常情况仅设置可通过 checkError 方法测试的内部标志。另外，为了自动刷新，可以创建一PrintStream；这意味着可在写入 byte 数组之后自动调用 flush 方法，可调用其中一个 println 方法，或写入一个换行符或字节 ('\n')。
该流是OutputStream的子类，提供了打印方法，可以提供各种数据类型的数据都原样打印。
1、字节打印流——PrintStream
1、构造函数所能接收的参数类型
1、File对象
2、字符串路径
3、字节输出流
4、字符输出流
2.构造函数
1、PrintStream(File file)
2、PrintStream(File file, String csn)
3、PrintStream(OutputStream out)
4、PrintStream(OutputStream out, boolean autoFlush)
5、PrintStream(String fileName)
6、PrintStream(String fileName, String csn)
3、当调用PrintStream用其中一个 println 方法或写入换行符或字节 ('\n') 时都会刷新输出缓冲区.
[java] view plaincopy
import java.io.*;
class PrintStreamDemo
{
public static void main(String[] args) throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
FileWriter fw = new FileWriter("d:\\123.txt");
PrintWriter out = new PrintWriter(fw,true);
for (String line=br.readLine();line!=null ;line=br.readLine())
{
if(line.equals("exit"))
break;
out.println(line.toUpperCase());
}
br.close();
out.close();
}
}
二、SequenceInputStream
SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。
当多个源对应一个目的的时候，此时就用SequenceInputStream，将这多个源整合成一个源。这个经常应用在切割和合并文件。
构造方法：
SequenceInputStream(Enumeration<? extends InputStream> e)：用于整合多个流。
SequenceInputStream(InputStream s1, InputStream s2)：用于整合两个流。
例：将三个文本文件的内容合并到一个文本文件中。
[java] view plaincopy
import java.io.*;
import java.util.*;
class SeDemo
{
public static void main(String[] args) throws IOException
{
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("D:\\FileDemo\\normal\\1.txt"));
v.add(new FileInputStream("D:\\FileDemo\\normal\\2.txt"));
v.add(new FileInputStream("D:\\FileDemo\\normal\\3.txt"));
Enumeration <FileInputStream>e = v.elements();
SequenceInputStream se = new SequenceInputStream(e);
FileOutputStream fo = new FileOutputStream("d:\\FileDemo\\normal\\4.txt");
BufferedOutputStream bo = new BufferedOutputStream(fo);
byte[] buf = new byte[1024];
for (int count=se.read(buf); count!=-1; count=se.read(buf))
{
bo.write(buf,0,count);
}
se.close();
bo.close();
}
}