java io
java io包最重要的是5个类和1个接口：File，OutputStream，InputStream，Reader，Writer，Serializable
File
No. |
方法或常量 |
类型 |
描述 |
1 |
public static final String pathSeparator |
常量 |
表示路径的分隔符（windows是：“;”） |
2 |
public static final String separator |
常量 |
表示路径的分隔符（windows是：“\”） |
3 |
public File(String pathname) |
构造 |
创建File类对象，传入完整路径 |
4 |
public boolean createNewFile() throws IOException |
普通 |
创建新文件 |
5 |
public boolean delete() |
普通 |
删除文件 |
6 |
public boolean exists() |
普通 |
判断文件是否存在 |
7 |
public boolean isDirectory() |
普通 |
判断给定的路径是否是一个目录 |
8 |
public long length() |
普通 |
返回文件的大小 |
9 |
public String[] list() |
普通 |
列出指定目录的全部内容，只是列出了名称 |
10 |
public File[] listFiles() |
普通 |
列出指定目录的全部内容，会列出路径 |
11 |
public boolean mkdir() |
普通 |
创建一个目录 |
12 |
public boolean renameTo(File dest) |
普通 |
为已有的文件重新命名 |
windows中使用反斜杆表示目录的分隔符：“\” ；
linux中使用正斜杆表示目录的分隔符：“/”。
import java.io.File;
import java.io.IOException;
public class FileDemo06 {
public static void main(String args[]) {
File
f = new File("d:" + File.separator + "test.txt"); // 文件路径
if (f.exists()) { // 判断文件是否存在
f.delete(); // 删除文件
} else {
try {
f.createNewFile(); // 创建文件
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
java的流：字节流与字符流
在java.io包中操作文件内容的主要有两大类：字节流、字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成，输入使的是InputStream，在字符流中输出主要是使用Writer类完成，输入主要是使用Reader类完成。
字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的。
所有的文件在硬盘或在传输的时候都是以字节的方式进行的，包括图片等都是按字节的方式存储的，而字符是只有在内存中才会形成，所以在开发中，字节流使用较为广泛。
java的io操作步骤
A、使用File类打开一个文件
B、通过字节流或字符流的子类，指定输出的位置
C、进行读/写操作
D、关闭输入/输出
字节流
字节流主要是操作byte类型数据，以byte数组为准，主要操作类就是OutputStream、InputStream。
字节输出流：OutputStream
字节输入流：InputStream
OutputStream
OutputStream是整个io包中字节输出流的最大父类，此类的定义如下：
public abstract class OutputStream extends Object implements Closeable, Flushable
从以上的定义中可以发现，此类是一个抽象类，如果要想使用此类的话，则首先必须通过子类实例化对象，那么如果现在要操作的是一个文件，则可以使用：FileOutputStream类。通过向上转型之后，可以为OutputStream实例化
No. |
方法或常量 |
类型 |
描述 |
1 |
public void close() throws IOException |
普通 |
关闭输出流 |
2 |
public void flush() throws IOException |
普通 |
刷新缓冲区 |
3 |
public void write(byte[] b) throws IOException |
普通 |
将一个byte数组写入数据流 |
4 |
public void write(byte[] b,int off,int len) throws IOException |
普通 |
将一个指定范围的byte数组写入数据流 |
5 |
public abstract void write(int b) throws IOException |
普通 |
将一个字节数据写入数据流 |
构造函数
public FileOutputStream(File file) throws FileNotFoundException public FileOutputStream(File file,boolean append) throws FileNotFoundException //如果将append的值设置为true，则表示在文件的末尾追加内容
样例
// 第1步、使用File类找到一个文件
File f = new File("d:" + File.separator + "test.txt"); // 声明File对象
// 第2步：通过子类实例化父类对象
OutputStream out = null; // 准备好一个输出的对象
out = new FileOutputStream(f); // 通过对象多态性，进行实例化
// 第3步：进行写操作
String str = "Hello World!!!"; // 准备一个字符串
byte b[] = str.getBytes(); // 只能输出byte数组，所以将字符串变为byte数组
out.write(b); // 将内容输出，保存文件
// 第4步：关闭输出流
out.close(); // 关闭输出流
或者以write（int b）的形式写入
// 第1步、使用File类找到一个文件
File f = new File("d:" + File.separator + "test.txt"); // 声明File对象
// 第2步：通过子类实例化父类对象
OutputStream out = null; // 准备好一个输出的对象
out = new FileOutputStream(f); // 通过对象多态性，进行实例化
// 第3步：进行写操作
String str = "Hello World!!!"; // 准备一个字符串
byte b[] = str.getBytes(); // 只能输出byte数组，所以将字符串变为byte数组
for (int i = 0; i < b.length; i++) {
out.write(b[i]); // 将内容输出
}
// 第4步：关闭输出流
out.close(); // 关闭输出流
InputStream
既然程序可以向文件中写入内容，则就可以通过InputStream从文件中把内容读取进来，首先来看InputStream类的定义：
public abstract class InputStream extends Object implements Closeable
与OutputStream类一样，InputStream本身也是一个抽象类，必须依靠其子类，如果现在是从文件中读取，子类肯定是FileInputStream。
观察FileInputStream类的构造方法：
public FileInputStream(File file) throws FileNotFoundException
No. |
方法或常量 |
类型 |
描述 |
1 |
public int available() throws IOException |
普通 |
可以取得输入文件的大小 |
2 |
public void close() throws IOException |
普通 |
关闭输入流 |
3 |
public abstract int read() throws IOException |
普通 |
读取内容，以数字的方式读取 |
4 |
public int read(byte[] b) throws IOException |
普通 |
将内容读到byte数组之中，同时返回读入的个数 |
读入内容V1.0
// 第1步、使用File类找到一个文件
File f = new File("d:" + File.separator + "test.txt"); // 声明File对象
// 第2步：通过子类实例化父类对象
InputStream input = null; // 准备好一个输入的对象
input = new FileInputStream(f); // 通过对象多态性，进行实例化
// 第3步：进行读操作
byte b[] = new byte[1024]; // 所有的内容读到此数组之中
input.read(b); // 把内容取出，内容读到byte数组之中
// 第4步：关闭输入流
input.close(); // 关闭输入流
System.out.println("内容为：" + new String(b)); // 把byte数组变为字符串输出
读入内容V1.1
// 第1步、使用File类找到一个文件
File f = new File("d:" + File.separator + "test.txt"); // 声明File对象
// 第2步：通过子类实例化父类对象
InputStream input = null; // 准备好一个输入的对象
input = new FileInputStream(f); // 通过对象多态性，进行实例化
// 第3步：进行读操作
byte b[] = new byte[1024]; // 所有的内容读到此数组之中
int len = input.read(b); // 将内容读出
// 第4步：关闭输入流
input.close(); // 关闭输入流
System.out.println("读入数据的长度：" + len);
System.out.println("内容为：" + new String(b, 0, len)); // 把byte数组变为字符串输出
读入内容V1.2
// 第1步、使用File类找到一个文件
File f = new File("d:" + File.separator + "test.txt"); // 声明File对象
// 第2步：通过子类实例化父类对象
InputStream input = null; // 准备好一个输入的对象
input = new FileInputStream(f); // 通过对象多态性，进行实例化
// 第3步：进行读操作
byte b[] = new byte[(int)f.length()]; // 所有的内容读到此数组之中，数组大小由文件决定
input.read(b); // 将内容读出
// 第4步：关闭输入流
input.close(); // 关闭输入流
System.out.println("内容为：" + new String(b)); // 把byte数组变为字符串输出
读入内容V1.3
// 第1步、使用File类找到一个文件
File f = new File("d:" + File.separator + "test.txt"); // 声明File对象
// 第2步：通过子类实例化父类对象
InputStream input = null; // 准备好一个输入的对象
input = new FileInputStream(f); // 通过对象多态性，进行实例化
// 第3步：进行读操作
byte b[] = new byte[(int) f.length()]; // 所有的内容读到此数组之中
for (int i = 0; i < b.length; i++) {
b[i] = (byte)input.read(); // 将内容读出
}
// 第4步：关闭输入流
input.close(); // 关闭输入流
System.out.println("内容为：" + new String(b)); // 把byte数组变为字符串输出
字符流
在程序中一个字符等于2个字节，那么JAVA提供了Reader、Writer两个专门操作字符流的类。
Writer
Writer本身是一个字符流的输出类，此类的定义如下：
public abstract class Writer extends Object implements Appendable, Closeable, Flushable
此类本身也是一个抽象类，如果要想使用此类，则肯定要使用其子类，此时如果是向文件中写入内容，所以应该使用FileWriter的子类。
FileWriter类的构造方法定义如下：
public FileWriter(File file) throws IOException
public FileWriter(File file,boolean append) throws IOException //将append的值设置成true，就表示追加。
No. |
方法或常量 |
类型 |
描述 |
1 |
public abstract void close() throws IOException |
普通 |
关闭输出流 |
2 |
public void write(String str) throws IOException |
普通 |
将字符串输出 |
3 |
public void write(char[] cbuf) throws IOException |
普通 |
将字符数组输出 |
4 |
public abstract void flush() throws IOException |
普通 |
强制性清空缓存 |
// 第1步、使用File类找到一个文件
File f = new File("d:" + File.separator + "test.txt"); // 声明File对象
// 第2步：通过子类实例化父类对象
Writer out = null; // 准备好一个输出的对象
out = new FileWriter(f,true); // 通过对象多态性，进行实例化
// 第3步：进行写操作
String str = "\r\nLIXINGHUA\r\nHello World!!!" ; // 准备一个字符串
out.write(str); // 将内容输出
// 第4步：关闭输出流
out.close(); // 关闭输出流
Reader
Reader是使用字符的方式从文件之中取出数据，Reader类的定义如下：
public abstract class Reader extends Object implements Readable, Closeable
Reader本身也是抽象类，如果现在要从文件中读取内容，则可以直接使用FileReader子类。
FileReader的构造方法定义如下：
public FileReader(File file) throws FileNotFoundException
No. |
方法或常量 |
类型 |
描述 |
1 |
public abstract void close() throws IOException |
普通 |
关闭输出流 |
2 |
public int read() throws IOException |
普通 |
读取单个字符 |
3 |
public int read(char[] cbuf) throws IOException |
普通 |
将内容读到字符数组之中，返回读入的长度 |
// 第1步、使用File类找到一个文件
File f = new File("d:" + File.separator + "test.txt"); // 声明File对象
// 第2步：通过子类实例化父类对象
Reader reader = null; // 准备好一个输入的对象
reader = new FileReader(f); // 通过对象多态性，进行实例化
// 第3步：进行读操作
char c[] = new char[1024]; // 所有的内容读到此数组之中
int len = reader.read(c); // 将内容输出
// 第4步：关闭输入流
reader.close(); // 关闭输入流
System.out.println(“内容为：” + new String(c, 0, len)); // 把字符数组变为字符串输出
// 第1步、使用File类找到一个文件
File f = new File("d:" + File.separator + "test.txt"); // 声明File对象
// 第2步：通过子类实例化父类对象
Reader reader = null; // 准备好一个输入的对象
reader = new FileReader(f); // 通过对象多态性，进行实例化
// 第3步：进行读操作
int len = 0; // 用于记录读取的数据个数
char b[] = new char[1024]; // 所有的内容读到此数组之中
int temp = 0; // 接收读取的每一个内容
while ((temp = reader.read()) != -1) {
// 将每次的读取内容给temp变量，如果temp的值不是-1，则表示文件没有读完
b[len] = (char) temp;
len++;
}
// 第4步：关闭输入流
reader.close(); // 关闭输入流
System.out.println("内容为：" + new String(b, 0, len));