File 类
import java.io.File;
import java.io.IOException;
public class FileTest {
public static void main(String[] args) throws IOException {
// 创建文件类型的对象，并与"D:\\Android\\a.txt"文件关联
File file = new File("D:\\Android\\a.txt");
if (file.exists()) {
file.delete();
System.out.println("删除成功");
} else {
file.createNewFile();
System.out.println("文件名" + file.getName());
System.out.println("文件大小" + file.length());
}
// 关联目录并获取里面的内容
File dir = new File("D:\\Bitcoin");
if ( dir.exists() ) {
File[] files = dir.listFiles();
if (files != null) {
for (File tmp : files) {
System.out.println(tmp.getName());
}
}
}
}
}
java.io.File
- createNewFile()
- delete()
- exist()
- getName()
- isFile()
- isDirectory()
- listFiles()
IO流基本概念及分类
IO，Input和Output，即输入和输出的意思
- 字节流和字符流
- 字节流：以字节为单位读写文件，可以处理任何类型的文件
- 字符流：字符流以字符（2个字节）为单位处理文件，只能进行文本文件的读写
- 输入流和输出流（从程序的角度出发）
- 输入流：数据从文件输入到程序中，即读文件
- 输出流：数据从程序中输出到文件中，即写文件
- 节点流和处理流
- 节点流：直接和源文件接触的输入输出流
- 处理流：需要建立在节点流之上的流
各类流简介
字符流： FileWriter
public class FileWriter extends OutputStreamWriter
- public String getEncoding()
返回此流使用的字符编码的名称。 - public void write(int c) c - 指定要写入的字符的int
- public void write(char[] cbuf, int off, int len)
- cbuf - 字符缓冲区
- off - 开始写入字符的偏移量
- len - 要写入的字符数
- public void write(String str, int off, int len) 写一个字符串的一部分
- public void flush() 刷新流
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterTest {
public static void main(String[] args) {
FileWriter fileWriter = null;
try {
// 1. 创建FileWriter对象并与D:\\Android\\Java\\a.txt文件关联
// 以追加的方式写入，会保留原文件中的内容
// fileWriter = new FileWriter("D:\\Android\\Java\\a.txt", true);
// 会覆盖原来的内容，如果文件不存在，会先创建该文件
fileWriter = new FileWriter("D:\\Android\\Java\\a.txt");
// 2. 通过FileWriter对象对文件进行写入操作
fileWriter.write("hello\n");
fileWriter.write('c');
fileWriter.write(97);
fileWriter.write('\n');
// 写入字符数组
char[] chars = new char[]{'a', 'c', 'c', 'u', 'm', 'u', 'l', 'a', 't', 'e', 'd'};
fileWriter.write(chars);
fileWriter.write('\n');
fileWriter.write(chars, 1, 4);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
// 3. 关闭流对象并释放相关资源
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字符流：FileReader
public class FileReader extends InputStreamReader
- public String getEncoding() 返回此流使用的字符编码的名称。
- public int read() 读一个字符， 返回的int就是这个字节的int，表示方式如果已到达流的末尾，则返回-1
- public int read(char[] cbuf, int offset, int length) 将字符读入数组的一部分,返回每次读入cbuf数组中的字符的个数，如果已到达流的末尾，则返回-1
- cbuf - 目标缓冲区
- offset - 开始存储字符的偏移量
- length - 要读取的最大字符数
示例：
import java.io.FileReader;
import java.io.IOException;
public class FileReaderTest {
public static void main(String[] args) {
//1. 创建FielReader对象并与D:\Android\Java\a.txt关联
FileReader fileReader = null;
try {
fileReader = new FileReader("D:\\Android\\Java\\a.txt");
//2. 读取输入流中的内容
//读取单个字符
int num = fileReader.read();
System.out.println("读取到的字符的Ascii码是:" + num);
System.out.println("读取到的字符是:" + (char) num);
//读取多个字符
char[] chars = new char[10];
//从数组下标2的位置开始存放，读取五个字符
//int cnt = fileReader.read(chars, 2, 5);
//数组从0存储, 直至chars满或者file内容读完
int cnt = fileReader.read(chars);
//System.out.println(fileReader.getEncoding());
System.out.println("读取的结果为：" + String.valueOf(chars) + "\n"
+ "字符数为：" + cnt);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != fileReader){
try {
// 3. 关闭FileReader对象并释放相关资源
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
字节流：FileOutputStream
- public void flush() throws IOException ：刷新此输出流并强制写出任何缓冲的输出字节
字节流：FileInputStream
public class FileInputStream extends InputStream
- public int available() throws IOException : 估计可以从此输入流中无阻塞地读取（或跳过）的剩余字节数。
举例：拷贝文件
public class FileCopyTest {
public static void main(String[] args) {
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
// FileReader fileReader = new FileReader("D:\\Android\\Books\\ANDROID框架揭秘.pdf");
// FileWriter fileWriter = new FileWriter("D:\\Android\\Books\\ANDROID框架揭秘.pdf");
fileInputStream = new FileInputStream("D:/Android/Books/Android Studio finish()方法.pdf");
fileOutputStream = new FileOutputStream("D:/Android/Books/Android Studio finish()方法_copy.pdf");
// 1. 以字节为单位复制，速度慢
int singleByte = -1;
long beginTime1 = System.currentTimeMillis();
while((singleByte = fileInputStream.read()) != -1) {
fileOutputStream.write(singleByte);
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1- beginTime1);
// 2. 直接复制整个文件，文件过大时对内存要求高
byte[] fileBytes = new byte[fileInputStream.available()]; // 直接一次性读取整个文件的size
long beginTime2 = System.currentTimeMillis();
fileInputStream.read(fileBytes);
fileOutputStream.write(fileBytes);
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2 - beginTime2);
// 3. 固定字节数复制
byte[] fixedBytes = new byte[8 * 1024]; //
int count = -1;
long beginTime3 = System.currentTimeMillis();
while ( (count = fileInputStream.read(fixedBytes)) != -1) {
fileOutputStream.write(fixedBytes, 0, count);
}
long endTime3 = System.currentTimeMillis();
System.out.println(endTime3 - beginTime3);
} catch (IOException e) {
// throw new RuntimeException(e);
e.printStackTrace();
} finally {
try {
if(fileOutputStream != null) {
fileOutputStream.close();
}
if(fileInputStream != null) {
fileInputStream.close();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
其他流
缓冲流
BufferedWriter
public class BufferedWriter extends Writer
- 将文本写入字符输出流，缓冲字符，以便有效地写入单个字符，数组和字符串。
- 可以指定缓冲区大小，或者可以接受默认大小。 对于大多数用途，默认值足够大。
- 提供了一个newLine（）方法，它使用平台自己的行分隔符概念，由系统属性line.separator定义。 并非所有平台都使用换行符（‘\ n’）来终止行。 因此，调用此方法终止每个输出行比直接编写换行符更为可取。
- 通常，Writer会立即将其输出发送到基础字符或字节流。 除非需要提示输出，否则建议将BufferedWriter包装在任何write（）操作可能代价高昂的Writer周围，例如FileWriters和OutputStreamWriters。 例如，
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("foo.out")));将PrintWriter的输出缓冲到文件。 如果没有缓冲，每次调用print()方法都会导致字符转换为字节，然后立即写入文件，效率很低。
BufferedReader
public class BufferedReader extends Reader
- 从字符输入流中读取文本，缓冲字符，以便有效地读取字符，数组和行。
- 可以指定缓冲区大小，或者可以使用默认大小。 对于大多数用途，默认值足够大。
- 通常，由Reader构成的每个读取请求都会导致相应的读取请求由基础字符或字节流构成。 因此，建议将BufferedReader包装在任何read（）操作可能代价高昂的Reader上，例如FileReaders和InputStreamReaders。 例如，
BufferedReader in = new BufferedReader(new FileReader("foo.in"));
BufferedOutputStream
public class BufferedOutputStream extends FilterOutputStream
BufferedInputStream
public class BufferedInputStream extends FilterInputStream
- BufferedInputStream向另一个输入流添加功能 - 即缓冲输入并支持mark和reset方法的功能
- mark操作会记住输入流中的一个点，并且reset操作会导致在从包含的输入流中获取新字节之前重新读取自最近的mark操作以来读取的所有字节。
使用缓冲流拷贝文件
public class BufferedStreamTest {
public static void main(String[] args) {
BufferedInputStream bufferedInputStream = null;
BufferedOutputStream bufferedOutputStream = null;
try {
bufferedInputStream = new BufferedInputStream(
new FileInputStream("D:\\Android\\Books\\ANDROID框架揭秘.pdf"));
bufferedOutputStream = new BufferedOutputStream(
new FileOutputStream("D:\\Android\\Books\\ANDROID框架揭秘_copy.pdf"));
byte[] bytes = new byte[8192];
int size = -1;
while ((size = bufferedInputStream.read(bytes)) != -1) {
bufferedOutputStream.write(bytes, 0, size);
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
if (null != bufferedOutputStream) {
try {
bufferedOutputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
if (bufferedInputStream != null) {
try {
bufferedInputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}
286
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
