黑马程序员——Java中IO流下

------Java培训、Android培训、期待与您交流！ -------

一、File类
1、概念：
File类用来将文件和路径封装成对象，方便对文件与文件夹的属性信息进行操作。File对象可以作为参数传递给流的构造函数。
2、常用方法
2.1 创建
boolean createNewFile()：//在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立就创建文件。而且文件已经存在，会覆盖。
boolean mkdir()：创建一级文件夹
boolean mkdirs()：创建多级文件夹
2.2 删除
boolean delete()：删除文件或目录
void deleteOnExit()：在程序退出时删除指定文件
2.3 获取
String getAbsolutePath()：获取文件的绝对路径
String getPath()：获取文件的相对路径
String getParent()：获取文件父目录
String getName()：获取文件名
long length()：返回文件长度
long lastModified()：返回文件最后一次被修改的时间
2.4 判断
boolean exists()：文件是否存在
boolean isFile()：是否是文件
boolean isDirectory()：是否是文件夹
2.5 其他方法
static File[] listRoots()：列出可用的文件系统根目录
String[] list()：列出当前目录下所有文件，包括隐藏
String[]list(FilenameFilter filter：返回一个字符串数组，获取目录中满足指定过滤器的文件或目录。
范例1：

import java.io.File;
import java.io.IOException;
import java.text.DateFormat;
import java.util.Date;

public class FileMethodDemo {

public static void main(String[] args) throws IOException {

// 获取方法
getDemo();
// 创建和删除方法
createAndDeleteDemo();
// 判断方法
isDemo();
// 重命名文件方法
renameToDemo();
// 列出根目录方法
listRootsDemo();
}

public static void listRootsDemo() {

File file = new File("d:\\");

// 获取文件系统能够目录空间信息
System.out.println("getFreeSpace:" + file.getFreeSpace());
System.out.println("getTotalSpace:" + file.getTotalSpace());
System.out.println("getUsableSpace:" + file.getUsableSpace());

// 列出D盘根目录所有文件和文件夹
File[] files = File.listRoots();
for (File file1 : files) {
System.out.println(file1);
}
}

public static void renameToDemo() {

File f1 = new File("c:\\1.png");
File f2 = new File("d:\\a.png");
// 重命名文件
boolean b = f1.renameTo(f2);
System.out.println("b=" + b);
}

public static void isDemo() throws IOException {
File f = new File("aaa");
f.createNewFile();
// 最好先判断是否存在。
System.out.println(f.isFile());
System.out.println(f.isDirectory());

}

public static void createAndDeleteDemo() throws IOException {

File dir = new File("abc\\q\\e\\c");

// 创建文件夹
boolean b = dir.mkdir();
System.out.println("b=" + b);
dir.mkdirs();// 创建多级目录
System.out.println(dir.delete());

// 文件的创建和删除。
File file = new File("file.txt");

// 创建文件，和输出流不一样，如果文件不存在，则创建，如果文件存在，则不创建。
boolean b1 = file.createNewFile();
System.out.println("b=" + b1);

// 删除文件或目录。文件存在，返回true；文件不存在或者正在被执行，返回false
boolean b2 = file.delete();
System.out.println("b=" + b2);
}

public static void getDemo() {
File file = new File("a.txt");
// 获取文件文件名
String name = file.getName();
// 获取文件绝对路径
String absPath = file.getAbsolutePath();
// 获取文件相对路径
String path = file.getPath();
// 获取文件长度
long len = file.length();
// 获取文件最后一次修改时间
long time = file.lastModified();
Date date = new Date(time);
DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG,
DateFormat.LONG);
String str_time = dateFormat.format(date);

System.out.println("parent:" + file.getParent());
System.out.println("name:" + name);
System.out.println("absPath:" + absPath);
System.out.println("path:" + path);
System.out.println("len:" + len);
System.out.println("time:" + time);
System.out.println("str_time:" + str_time);
}
}

输出结果：
parent:null
name:a.txt
absPath:D:\Java学习\视频\历经5年锤炼(史上最适合初学者入门的Java基础视频)\Code\Code\day22e\a.txt
path:a.txt
len:123
time:1336102144000
str_time:2012年5月4日 上午11时29分04秒
b=true
true
b=true
b=true
true
false
b=false
getFreeSpace:22204440576
getTotalSpace:85913014272
getUsableSpace:22204440576
C:\
D:\
E:\
F:\
G:\
H:\

范例二：

//文件过滤器演示
import java.io.File;
import java.io.FilenameFilter;

public class FileFilterDemo {
public static void main(String[] args) {
listDemo();
}

// 过滤后缀名为.java的文件
public static void listDemo() {
File dir = new File("d:\\Java");
String[] names = dir.list(new SuffixFilter(".java"));
for (String name : names) {
System.out.println(name);
}
}
}

class SuffixFilter implements FilenameFilter {
private String suffix;

public SuffixFilter(String suffix) {
this.suffix = suffix;
}

// 过滤指定后缀名的文件
public boolean accept(File dir, String name) {
return name.endsWith(suffix);
}
}

输出结果：
Array1.java
Array3.java
Array4.java
Array5.java
Array6.java
ArrayDemo.java
ArrayTools.java
BL1.java
BL2.java
keygen.java
name1.java
q.java

二、递归
1、递归概述
递归是指函数自身直接或者间接的调用到了自身。当一个功能在被重复使用，
并每次使用时参与运算的结果和上一次调用有关，这时可以用递归来解决问题。
2、递归注意事项
递归一定明确条件和递归次数，否则容易栈溢出。
3、递归应用
范例：

//递归演示：
//对包含文件的目录进行深度遍历并删除
import java.io.File;

public class RemoveDirTest {
public static void main(String[] args) {
File dir = new File("d:\\Test");
removeDir(dir);
}

public static void removeDir(File dir) {
File[] files = dir.listFiles();
for (File file : files) {
if (file.isDirectory()) {
removeDir(file);//递归调用本函数进行删除
} else {
System.out.println(file + ":" + file.delete());
}
}
System.out.println(dir + ":" + dir.delete());
}
}

输出结果：
d:\Test\1\22\ad:true
d:\Test\1\22:true
d:\Test\1:true
d:\Test:true

三、Properties类
1、概述
Properties是Map集合下Hashtable类中的一个子类。Properties集合中的键和值都是字符串类型，其中的数据可以保存到流中，或者从流中获取。该集合通常用于操作以键值对形式存在的配置文件。
2、常用方法
String getProperty()：获取属性值
void list()：将属性列表输出到输出流
void load()：从输入流读取属性列表
void store()：将属性列表写入输出流
范例：

//Properties类
import java.io.*;
import java.util.Properties;

public class PropertiesDemo {
public static void main(String[] args) throws Exception {
propertiesDemo();
}

public static void propertiesDemo() throws Exception {
Properties prop = new Properties();
FileInputStream fis = new FileInputStream(" info. txt");
// 使用load方法，读取文件中的属性值
prop.load(fis);
// 输出
prop.list(System.out);
test();
}

/*
* 对已有的配置文件中的信息进行修改。 读取这个文件。 并将这个文件中的键值数据存储到集合中。 再通过集合对数据进行修改。
* 再通过流将修改后的数据存储到文件中
*/
public static void test() throws Exception {
// 读取这个文件
File file = new File(" info. txt");
if (!file.exists()) {
file.createNewFile();
}
FileReader fr = new FileReader(" info. txt");
// 创建集合存储配置信息
Properties prop = new Properties();
// 将流中信息存储到集合中
prop.load(fr);
prop.setProperty(" week", " Monday");
FileWriter fw = new FileWriter(file);
// 将集合中的数据存储到文件中
prop.store(fw, " ");
// 关流
fr.close();
}
}

四、打印流
1、概述
打印流包含PrintWriter与PrintStream两个类，可以直接操作输入流和文件。
2、PrintStream
该类是字节打印流，提供了打印方法可以对多种数据类型值进行打印，并保持数据的表示形式。它不抛IOException，它的构造函数接收三种类型的值：字符串路径、 File对象、字节输出流。该对象具备特有的方法 打印方法 print println,可以打印任何类型的数据，其中特有的print方法可以保持任意类型数据表现形式的原样性，将数据输出到目的地。
3、PrintWriter
该类是字符打印流，它向文本输出流打印对象的格式化表示形式。构造函数参数形式：字符串路径、File对象、字节输出流、字符输出流。构造函数中，如果参数是输出流，那么可以通过指定另一个参数true完成自动刷新，该true对println方法有效。当操作的数据是字符时，可以选择PrintWriter，比PrintStream要方便。
范例：

//打印流演示
import java.io.*;

public class PrintDemo {

public static void main(String[] args) throws IOException {

// 创建打印流
PrintStream ps = new PrintStream("print.txt");

// 将97先变成字符保持原样将数据打印到目的地。
ps.print(97);

// 创建字符流对象
BufferedReader bufr = new BufferedReader(new InputStreamReader(
System.in));

// 创建打印流
PrintWriter out = new PrintWriter(new FileWriter("out.txt"), true);

// 打印输出
String line = null;
while ((line = bufr.readLine()) != null) {
if ("over".equals(line))
break;
out.println(line.toUpperCase());
}
// 关闭资源
ps.close();
out.close();
bufr.close();
}
}

五、序列流
SequenceInputStream对多个流进行合并。也被称为合并流。
范例：

//序列流-合并文件
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;

public class SequenceInputStreamDemo {
public static void main(String[] args) throws Exception {

//创建ArrayList集合
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for (int x = 1; x <= 3; x++) {
al.add(new FileInputStream(x + ".txt"));
}
final Iterator<FileInputStream> it = al.iterator();
//创建枚举对象
Enumeration<FileInputStream> en = Collections.enumeration(al);

//创建序列流
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();
}
}

六、其他IO类
1、ObjectInputStream与ObjectOutputStream
可以对写入类的基本数据和对象进行序列化和反序列化，被操作的对象需要实现Serializable接口。
2、RandomAccessFile类
RandomAccessFile即可读取数据，又可以写入数据，但只能操作文件对象。该类在其内部维护了一个大型的byte数组，通过对数组的操作完成读取和写入。另外，该类可以通过getFilePointer方法获取指针的位置，还可以通过seek方法设置指针的位置。该对象的内容应该封装了字节输入流和字节输出流。
通过seek方法操作指针，可以从这个数组中的任意位置上进行读和写，可以完成对数据的修改。但是要注意：数据必须有规律。
3、管道流¬——PipedOutputStream和PipedInputStream
管道流用于将输入和输出进行连接，需要和多线程技术相结合。
4、DataInputStream与DataOutputStream
用于操作Java中的基本数据类型。

5、ByteArrayInputStream与ByteArrayOutputStream

用于操作字节数组类型数据。关闭字节数组输出输出流无效， 因为它们没有调用底层资源， 所有的操作都是在内存中完成的。

------Java培训、Android培训、期待与您交流！ -------