一、File类
File类既能代表一个特定文件的名称,又能代表一个目录下的一组文件的名称,它是java.io包下代表与平台无关的文件和目录,也就是说程序中操作文件和目录,都可以通过File类实现。如果指的是一个文件集,我们可以对此集合调用list()方法,这个方法将返回一共为字符串数组,注意这里返回的并不是一个泛型类,这里的元素个数是可以确定的。
需要说明的是删除非空文件夹需要从最内部递归删除,不能直接删除。
常见的文件操作代码:
import java.io.File;
public class FileDeleteDemo {
/**
* window下文件删除需要进入最内层,从内向外删除
*
* @param args
*/
public static void main(String[] args) {
File dir = new File("D:\\JAVA2");
removeall(dir);
}
/**
* 递归的进入文件夹内部
* @param dir
*/
private static void removeall(File dir) {
File[] namesFiles = dir.listFiles();
for (File name : namesFiles) {
if (name.isDirectory()) {
removeall(name);
} else {
System.out.println(name + " : " + name.delete());
}
}
System.out.println(dir + " : " + dir.delete());
}
}
二、字符流
Java 内用 默认采用Unicode 编码存储字符,字符流处理类负责将外部的其他编码的字符流和 java 内 Unicode 字符流之间的转换。字符流只适合于文本数据流的传输,因为在传输过程中字符流会对数据进行编码与译码操作,非字符流数据会在这个转换过程中出错,因此不要采用字符流进行非文本文件的处理。
几乎所有的Java IO流类都有相应的Reader和Writer类来提供天然的Unicode操作。可见Reader和Writer类是针对字符流处理的,(其子类后缀名均为Reader或Writer,前缀为流对象的主要功能)。
Reader:读取字符流的抽象类。
|--BufferReader:从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。
|--LineNumberReader:跟踪行号的缓冲字符流。
|--InputStreamReader:字节流向字符流转换的桥梁。
|--FileReader:用来读取字符文件的类。
|--CharArrayReader:
|--StringReader:
Writer:写入字符流的抽象类。
|--BufferWriter:将文本写入字符输出流,缓冲各个字符,从而实现单个字符、数组、字符串的高效写入。
|--OutputStreamReader:字符流向字节流转换的桥梁,缓冲各个字符,从而实现字符、数组和行的高效写入。
|--FilerWriter:用来写入字符文件的类。
|--CharArrayWriter:
|--StringReader:
|--PrintWriter:
1、关于字符流的读写操作:
写入字符流时必须要明确被操作的文件,目录下如果已有同名文件,在Writer方法不采用具有刷新功能时,则同名文件将被覆盖。Writer方法不采用具有刷新功能时,可调用flush()方法,刷新该流的缓冲,将数据刷新到目的地中。
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriteDemo {
/**
* @param args
* @throws IOException
* @throws InterruptedException
*/
public static void main(String[] args) {
FileReader fileReader = null;
FileWriter fileWriter = null;
try {
fileReader = new FileReader(new File("Read.txt"));
fileWriter = new FileWriter(new File("write.txt"));
char[] buf = new char[1024];
int key = 0;
while ((key = fileReader.read(buf)) != -1) {
fileWriter.write(buf, 0, key);
}
} catch (Exception e) {
throw new RuntimeException(e.toString());
} finally {
try {
if (fileReader != null) {
fileReader.close();
}
if (fileWriter != null) {
fileWriter.flush();
fileWriter.close();
}
} catch (Exception e) {
throw new RuntimeException(e.toString());
}
}
Runtime runtime = Runtime.getRuntime();
try {
Process p = runtime.exec("notepad.exe write.txt");
Thread.sleep(2000);
} catch (Exception e) {
throw new RuntimeException(e.toString());
}
}
}
但是当Writer方法采用自动刷新时,每次写入的内容将在原油内用的基础上进行添加,不会将原有内容覆盖。
流资源必须得到释放。调用close方法,关闭前会刷新一次内部的缓冲数据,并将数据刷新到目的地中。
2、字符流的性能改善:字符流缓冲区BufferedWriter和BufferedReader
缓冲区的出现:提高了流的读写效率,所以在缓冲区创建前,要先创建流对象,即先将流对象初始化到构造函数中。数据写入时,可以先将数据缓冲到数组,将数据存入,在一次性取出(缓冲区的大小一般为1024的整数倍)。
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileBufferWriterDemo {
/**
* @param args
*/
public static void main(String[] args) {
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
try {
bufferedReader = new BufferedReader(new FileReader("Read.txt"));
bufferedWriter = new BufferedWriter(new FileWriter("write.txt"));
String str = null;
while ((str = bufferedReader.readLine()) != null) {
bufferedWriter.write(str);
bufferedWriter.newLine();
bufferedWriter.flush();
}
} catch (IOException e) {
throw new RuntimeException(e.toString());
} finally {
try {
if (bufferedReader != null) {
bufferedReader.close();
}
if (bufferedWriter != null) {
bufferedWriter.close();
}
} catch (Exception e) {
throw new RuntimeException(e.toString());
}
}
Runtime runtime = Runtime.getRuntime();
try {
Process p = runtime.exec("notepad.exe write.txt");
Thread.sleep(2000);
} catch (Exception e) {
throw new RuntimeException(e.toString());
}
}
}
当数据读取时可以一次性读取一行,即采用readline方法,当采用该方法返回null时即读取结束。
三、字节流
字节流适合任意类型数据的处理,因为字节流本身是按照按位处理的思想,因此在处理过程中不会对数据进行更改。InputStream和 OutputStream是针对字节流处理的,(其子类后缀名均为Reader或Writer,前缀为流对象的主要功能)。
由于字节流操作的是字节,即数据的最小单位,不需要像字符流一样要进行转换为字节。可直接将字节写入到指定文件中,因此字节流的处理过程中不存在刷新的问题。
InputStream:
|--FileOutputStream
|--FileterOutputStream
1、关于字节流的读写操作:
字节流不存在译码编码操作,也不存在刷新问题,因此直接进行文件处理即可。
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class FileInputDemo {
/**
* @param args
*/
public static void main(String[] args) {
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
fileInputStream = new FileInputStream(new File("Read.txt"));
fileOutputStream = new FileOutputStream(new File("write.txt"));
int key = 0;
while ((key = fileInputStream.read()) != -1) {
fileOutputStream.write(key);
}
} catch (Exception e) {
throw new RuntimeException(e.toString());
} finally {
try {
if (fileInputStream != null) {
fileInputStream.close();
}
if (fileOutputStream != null) {
fileOutputStream.close();
}
} catch (Exception e) {
throw new RuntimeException(e.toString());
}
}
Runtime runtime = Runtime.getRuntime();
try {
Process p = runtime.exec("notepad.exe write.txt");
Thread.sleep(2000);
} catch (Exception e) {
throw new RuntimeException(e.toString());
}
}
}
2、字节流的性能改善--字节流缓冲区:
定义一个固定长度的byte数组(长度一般为1024的整数倍),read方法返回的是读取到的数据长度,直到返回值为0时读取操作结束。
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class FileByteArrayInputDemo {
/**
* @param args
*/
public static void main(String[] args) {
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
fileInputStream = new FileInputStream(new File("Read.txt"));
fileOutputStream = new FileOutputStream(new File("write.txt"));
int key = 0;
byte[] buffer = new byte[1024];
while ((key = fileInputStream.read(buffer)) != -1) {
fileOutputStream.write(buffer, 0, key);
}
} catch (Exception e) {
throw new RuntimeException(e.toString());
} finally {
try {
if (fileInputStream != null) {
fileInputStream.close();
}
if (fileOutputStream != null) {
fileOutputStream.close();
}
} catch (Exception e) {
throw new RuntimeException(e.toString());
}
}
Runtime runtime = Runtime.getRuntime();
try {
Process p = runtime.exec("notepad.exe write.txt");
Thread.sleep(2000);
} catch (Exception e) {
throw new RuntimeException(e.toString());
}
}
}
3、 字节流的性能改善:字节流缓冲区B ufferedInputStream和BufferedOutputStream
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class FileBufferInputDemo {
public static void main(String[] args) {
BufferedInputStream buInputStream = null;
BufferedOutputStream bufferedOutputStream = null;
try {
buInputStream = new BufferedInputStream(new FileInputStream(
"Read.txt"));
bufferedOutputStream = new BufferedOutputStream(
new FileOutputStream("write.txt"));
byte[] buffer = new byte[1024];
int len = 0;
while ((len = buInputStream.read(buffer)) != -1) {
bufferedOutputStream.write(buffer, 0, len);
}
} catch (Exception e) {
throw new RuntimeException(e.toString());
} finally {
try {
if (buInputStream != null) {
buInputStream.close();
}
if (bufferedOutputStream != null) {
bufferedOutputStream.close();
}
} catch (Exception e) {
throw new RuntimeException(e.toString());
}
}
}
}