黑马程序员——JAVA学习笔记——IO
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
JAVA IO
JAVA IO操作主要指的是使用JAVA进行输入、输出操作，JAVA中的所有操作类都存放在JAVA.io包中，在使用时必须导入该包。
在java.io包中重点为5个类和一个接口。5个类指的是：File、OutputStream、InputStream、Writer、Reader;一个接口指的是：Serializable
1、操作文件的类： File
在整个io 包中，唯一与文件本身有关的的类就是File.使用File类可以进行创建或删除文件等操作；
File类的构造方法：
public File(String pathname) ---->实例化File类时，必须设置好路径
File 类中的常用方法：
||-表示路径的分隔符，如Windows为：“；”—>public static final String pathSeparator ;
||-表示路径的分隔符，如Windows为：“\”------>public static final String separator
||-创建新文件：public boolean createNewFile() throws IOException
||-删除文件：public boolean delete()
||-判断文件是否存在：public boolean exists()
||-判断给定的路径是否是一个路径：public boolean isDirectory()
||-返回文件的大小：Public long length()
||-列出指定目录的全部内容，只列出名称：public String[] list()
||-列出指定目录的全部内容，会列出路径：Public File[] listFiles()
||-创建一个目录：public boolean mkdir()
||-为已有的文件重命名：public boolean renameTo(File dest)
练习所列举的方法：
列出指定目录的全部内容;
import java.io.File ;
import java.io.IOException ;
public class Test{
public static void main(String args[]){
File my = new File("d:" + File.separator) ; // 操作路径
print(my) ;
}
public static void print(File file){ // 递归调用
if(file!=null){ // 判断对象是否为空
if(file.isDirectory()){ // 如果是目录
File f[] = file.listFiles() ; // 列出全部的文件
if(f!=null){ // 判断此目录能否列出
for(int i=0;i
print(f[i]) ; // 因为给的路径有可能是目录，所以，继续判断
}
}
}else{
System.out.println(file) ; // 输出路径
}
}
}
};
1.1使用RandomAccessFile类对文件读取：
RandomAccessFile主要对文件内容进行读取，其读取规则属于随机读取类，它可以随机的读取一个文件中指定位置的数据。
RandomAccessFile类中的常用方法：
||-接收File类的对象，指定操作路径，但是在设置时需要设置模型，r为只读；w为只写；rw为读写--------->public RandomAccessFile(File file,String mode) throws FileNotFoundException
||-关闭操作：public void close() throws IOException
||-将内容读取到一个Byte数组中：public int read(Byte[] b)throws IOException
||-从文件中读取整形数据：public final int readInt()throws IOException
注意：在使用mode是如果是用的“rw”操作则会自动创建新文件
代码样板测试：
1、 写入文件：
import java.io.File ;
import java.io.RandomAccessFile ;
public class RandomAccessFileDemo01{
// 所有的异常直接抛出，程序中不再进行处理
public static void main(String args[]) throws Exception{
File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件
RandomAccessFile rdf = null ; // 声明RandomAccessFile类的对象
rdf = new RandomAccessFile(f,"rw") ;// 读写模式，如果文件不存在，会自动创建
String name = null ;
int age = 0 ;
name = "zhangsan" ; // 字符串长度为8
age = 30 ; // 数字的长度为4
rdf.writeBytes(name) ; // 将姓名写入文件之中
rdf.writeInt(age) ; // 将年龄写入文件之中
name = "lisi " ; // 字符串长度为8
age = 31 ; // 数字的长度为4
rdf.writeBytes(name) ; // 将姓名写入文件之中
rdf.writeInt(age) ; // 将年龄写入文件之中
name = "wangwu " ; // 字符串长度为8
age = 32 ; // 数字的长度为4
rdf.writeBytes(name) ; // 将姓名写入文件之中
rdf.writeInt(age) ; // 将年龄写入文件之中
rdf.close() ; // 关闭
}
};
代码运行之后会在d盘下创建一个test.txt文件，并且写入了内容“zhangsan 30 lisi 31 wangwu 32 ”
2、 读取文件内容：
import java.io.File ;
import java.io.RandomAccessFile ;
public class Test{
// 所有的异常直接抛出，程序中不再进行处理
public static void main(String args[]) throws Exception{
File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件
RandomAccessFile rdf = null ; // 声明RandomAccessFile类的对象
rdf = new RandomAccessFile(f,"r") ;// 以只读的方式打开文件
String name = null ;
int age = 0 ;
byte b[] = new byte[8] ; // 开辟byte数组
// 读取第二个人的信息，意味着要空出第一个人的信息
rdf.skipBytes(12) ; // 跳过第一个人的信息
for(int i=0;i
b[i] = rdf.readByte() ; // 读取一个字节
}
name = new String(b) ; // 将读取出来的byte数组变为字符串
age = rdf.readInt() ; // 读取数字
System.out.println("第二个人的信息 --> 姓名：" + name + "；年龄：" + age) ;
// 读取第一个人的信息
rdf.seek(0) ; // 指针回到文件的开头
for(int i=0;i
b[i] = rdf.readByte() ; // 读取一个字节
}
name = new String(b) ; // 将读取出来的byte数组变为字符串
age = rdf.readInt() ; // 读取数字
System.out.println("第一个人的信息 --> 姓名：" + name + "；年龄：" + age) ;
rdf.skipBytes(12) ; // 空出第二个人的信息
for(int i=0;i
b[i] = rdf.readByte() ; // 读取一个字节
}
name = new String(b) ; // 将读取出来的byte数组变为字符串
age = rdf.readInt() ; // 读取数字
System.out.println("第三个人的信息 --> 姓名：" + name + "；年龄：" + age) ;
rdf.close() ; // 关闭
}
};
2、字节流与字符流基本操作：
在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据时使用输入流读取数据，而当程序需要将一些数据保存起来时，就要使用输出流、
而在java.io包中流的操作主要有字节流、字符流两大类，在字节流中使用OutputStream 进行数据输出，InputStream进行数据输入；在字符流中使用Writer类完成，输入主要是使用Reader类完成
不过大体步骤是一样：
l 使用一个File类打开一个文件
l 通过字节流或字符流的子类指定输出的位置
l 进行读/写操作
l 关闭输入/输出
2.1字节输出流：OutputStream
定义格式; public abstract class OutputStream extends Object implements Closeable,Flushable
常用的方法：
||-关闭输出流：public void close() throws IOException
||-刷新缓存区：public void flush() throws IOException
||-将一个byte数组写入数据流：public void write(byte[] b) throws IOException
||-将一个指定范围的byte数组写入流:public void write(byte[] b,int off,int len) throws IOException
||-将一个字节流数据写入数据流：public abstract void write(int b) throws IOException
因为OutputStream类是一个抽象类，如果要使用此类，则必须使用其子类实例化对象；如：使用FileOutputStream类操作一个文件。
实例操作一：向文件中写入字符串
import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class Test{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
OutputStream input = null ; // 准备好一个输入的对象
input = new FileOutputStream(f) ; // 通过对象多态性，进行实例化
// 第3步、进行读操作
String str="hello world!!!";
byte b[] = str.getBytes() ; // 所有的内容都读到此数组之中
input.write(b) ; // 读取内容
// 第4步、关闭输出流
input.close() ; // 关闭输出流
System.out.println("内容为：" + new String(b)) ; // 把byte数组变为字符串输出
}
};
实例操作二：在之前的文本中追加内容
采用方法：public FileOutputStream(File file, boolean appeand) throws FileNotFoundException
此时在构造方法中，如果修改append 的值设置为true ,则表示在文件的末尾追加内容。
import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class Test{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
OutputStream out = null ; // 准备好一个输出的对象
out = new FileOutputStream(f,true) ; // 此处表示在文件末尾追加内容
// 第3步、进行写操作
String str = "Hello World!!!" ; // 准备一个字符串
byte b[] = str.getBytes() ; // 只能输出byte数组，所以将字符串变为byte数组
for(int i=0;i
out.write(b[i]) ; // 每次只写入一个内容
}
// 第4步、关闭输出流
out.close() ; // 关闭输出流
}
};
如果需要换行！可以使用”\r\n”，如：String str=”\r\n Hello World!!!”
2.2、字节输入流：InputStream
定义方法：public abstract class InputStream extends Object implements Closeable,
常用的方法：
||-取得输入文件的大小; public int available() throws IOException
||-关闭输入流：Public void close() throws IOException
||-读取内容，以数字的方式读取：public abstract int read() throws IOException
||-将内容读到byte数组中，同时返回读入的个数： public int read(byte[] b)throws IOException
同样以FileInputStream类为其实例化对象；
实例操作一:从文件中读取内容；
import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class Test{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第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)) ; // 把byte数组变为字符串输出
}
};
实例操作二：开辟指定大小的byte数组
使用File类中的length()方法获取一个文件的大小
import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class Test{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第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()] ; // 数组大小由文件决定
int len = input.read(b) ; // 读取内容
// 第4步、关闭输出流
input.close() ; // 关闭输出流\
System.out.println("读入数据的长度：" + len) ;
System.out.println("内容为：" + new String(b)) ; // 把byte数组变为字符串输出
}
};
3、字符流
在程序中一个字符等于两个字节，JAVA提供了Writer类和Reader类进行操作
3.1 字符输出流Writer
定义格式; public abstract class Writer extends Object implements Appendale ,Closeable.Flushable
常用的方法;
||-关闭输出流：public abstract void close() throws IOException
||-将字符串输入：public void write(String str) throws IOException
||-将字符数组输出：public void write(char[] cbuf) throws IOException
||-强制性清空缓存：public abstract void flush() throws IOException
实例操作一：向文件中写入数据
import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class Test{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
Writer out = null ; // 准备好一个输出的对象
out = new FileWriter(f) ; // 通过对象多态性，进行实例化
// 第3步、进行写操作
String str = "Hello World!!!" ; // 准备一个字符串
out.write(str) ; // 将内容输出，保存文件
// 第4步、关闭输出流
out.close() ; // 关闭输出流
}
};
实例操作二;：使用FileWriter追加文件的内容
public FileWriter(File file,boolean append) throws IOException
import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class Test{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第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\nCSDN\r\nHello World!!!" ; // 准备一个字符串
out.write(str) ; // 将内容输出，保存文件
// 第4步、关闭输出流
out.close() ; // 关闭输出流
}
};
3.2、字符输入流Reader
定义; public abstract class Reader extends Object implements Readable,Closeable
可以使用FileReader子类为其实例化，
其中FileReader 的构造方法为：
public FileReader(File file) throws FileNotFoundException
常用的方法：
||-关闭输出流：public abstract void close() throws IOException
||-读取单个字符：public int read() throws IOException
||-将内容读到字符数组中，返回读入的长度:public int read(char[] cbuf)throws IOException
实例操作一: 从文件中读取内容
import java.io.File ;
import java.io.Reader ;
import java.io.FileReader ;
public class Test{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
Reader input = null ; // 准备好一个输入的对象
input = new FileReader(f) ; // 通过对象多态性，进行实例化
// 第3步、进行读操作
char c[] = new char[1024] ; // 所有的内容都读到此数组之中
int len = input.read(c) ; // 读取内容
// 第4步、关闭输出流
input.close() ; // 关闭输出流
System.out.println("内容为：" + new String(c,0,len)) ; // 把字符数组变为字符串输出
}
};
实例操作二：使用循环的方式读取内容
import java.io.File ;
import java.io.Reader ;
import java.io.FileReader ;
public class Test{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
Reader input = null ; // 准备好一个输入的对象
input = new FileReader(f) ; // 通过对象多态性，进行实例化
// 第3步、进行读操作
char c[] = new char[1024] ; // 所有的内容都读到此数组之中
int temp = 0 ; // 接收每一个内容
int len = 0 ; // 读取内容
while((temp=input.read())!=-1){
// 如果不是-1就表示还有内容，可以继续读取
c[len] = (char)temp ;
len++ ;
}
// 第4步、关闭输出流
input.close() ; // 关闭输出流
System.out.println("内容为：" + new String(c,0,len)) ; // 把字符数组变为字符串输出
}
};
4、字节流和字符流的区别：
字节流在操作时本身不会用到缓存区（内存），是文件本身直接操作，而字符流在操作时使用了缓存区，通过缓存区在操作文件,如下图;
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------