Java流操作有关的类或接口:
Java流类图结构:
FilInputStream文件输入流(字节输入流)
FilterInputStream过滤输入流(封装其他输入流)
BufferInputStream缓冲输入流
ObjectInputStream 对象输入流
ByteArrayInputStream字节数组输入流
PrintStream字节打印流
InputStreamReader转换流(字节到字符的转换)
OutStreamWrite转换流(字符到字节的转换)
StringWriter 字符输出流
IO流的分类
根据处理数据类型的不同分为:字符流和字节流
根据数据流向不同分为:输入流和输出流
字符流和字节流
字节流:以字节为单位读取的流
字符流:以字符为单位读取的流
字节流和字符流的区别:
读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。
处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能处理字符类型的数据。
结论:只要是处理纯文本数据,就优先考虑使用字符流。 除此之外都使用字节流。
1.1 FileOutputStream类
(1)基本概念
java.io.FileOutputStream类主要用于将字节流数据写入到输出流中。
(2)常用的方法
FileOutputStream(String name) - 按照参数指定的路径构造对象。
FileOutputStream(String name, boolean append) - 按照追加的方式构造对象与指定的路径关联。
void write(int b) - 写入单个字节。
void write(byte[] b, int off, int len) - 写入数组中的一部分字节数据。 > void write(byte[] b) - 写入整个数组的字节数据。
void flush() - 刷新输出流并强制写入缓冲数据。
void close() - 关闭输出流并释放资源。
1.2 FileInputStream类
(1)基本概念
java.io.FileInputStream类用于读取诸如图像之类的原始字节流。
(2)常用的方法
FileInputStream(String name) - 根据参数指定的文件进行关联并创建对象。
int read() - 用于读取一个字节数据,返回-1表示读到文件末尾,否则返回数据。
int read(byte[] b) - 用于读满整个字节数组。
- 若读到文件尾就返回-1,否则返回实际读取的字节数。
int read(byte[] b, int off, int len) - 用于读满字节数组的一部分空间。
void close() - 关闭流并释放资源。
1.3 DataOutputStream类
(1)基本概念java.io.DataOutputStream类用于将java中的基本数据类型写入输出流中。
(2)常用的方法
DataOutputStream(OutputStream out) - 根据参数指定的引用构造对象。
void writeInt(int v) - 用于将参数指定的整数写入输出流中。
void flush() - 刷新输出流 void close() - 关闭输出流
1.4 DataInputStream类
(1)基本概念
java.io.DataInputStream类用于读取java中的基本数据类型。
(2)常用的方法
DataInputStream(InputStream in) - 根据参数指定的引用构造对象。
- 引用是一个抽象类,实参需要传递子类的对象。
void close() - 关闭输入流。
1.5 BufferedReader类
(1)基本概念
java.io.BufferedReader类用于读取单个字符、字符数组、一行字符的数据。
(2)常用的方法
BufferedReader(Reader in) - 根据参数指定的引用构造对象。
- Reader是个抽象类,实参传递子类的对(InputStreamReader)。
String readLine() - 用于读取一行文本。
void close() - 关闭流对象并释放资源
1.6 PrintStream类
(1)基本概念 java.io.PrintStream类用于打印各种数据内容。
(2)常用的方法 PrintStream(OutputStream out) - 根据参数指定的引用构造对象。
- OutputStream类是个抽象类,实参需要传递子类的对象。 >void print(String s) - 打印参数指定的字符串。 void println(String x) - 打印字符串并换行。 void close() -
关闭流。 void flush() - 刷新流对象。
1.7 ObjectOutputStream类
(1)基本概念
java.io.ObjectOutputStream类用于将一个对象整体写入到输出流中。
只能将支持 java.io.Serializable 接口的对象写入流中。
类通过实现 java.io.Serializable 接口以启用其序列化(将整个对象的所有信息转换为字节流信息的过程)功能。
(2)常用的方法
ObjectOutputStream(OutputStream out) - 根据参数指定的引用构造对象。
- OutputStream类是抽象类,实参传递该类的子类对象。
void writeObject(Object obj) - 将参数指定的对象整体写入到流中。
void flush() - 刷新流对象。
void close() - 关闭流对象。
1.8 ObjectInputStream类
(1)基本概念
java.io.ObjectInputStream类用于将文件的对象整体读取出来。
(2)常用的方法
ObjectInputStream(InputStream in) - 根据参数指定的引用构造对象。
- InputStream类是个抽象类,实参需要传递子类的对象。
Object readObject() - 用于读取输入流中的一个对象并返回。
- 无法根据返回值来判断是否读取到文件的末尾。
void close() - 关闭流对象。
经验:
当需要向文件中写入多个对象时,通常的做法是先将所有被写入的对象放入一个集合中,然后将该集合整体看做一个对象写入文件中,此时读取文件中的内容时,只需要调用一次readObject()方法就可以全部读出。
7.字符流与字节流转换
转换流的特点:
1.其是字符流和字节流之间的桥梁
2.可对读取到的字节数据经过指定编码转换成字符
3.可对读取到的字符数据经过指定编码转换成字节 何时使用转换流?
1.当字节和字符之间有转换动作时;
2.流操作的数据需要编码或解码时。
具体的对象体现:
1.InputStreamReader:字节到字符的桥梁
2.OutputStreamWriter:字符到字节的桥梁 这两个流对象是字符体系中的成员,它们有转换作用,本身又是字符流,所以在构造的时候需要传入字节流对象进来。
8.File类
File类是对文件系统中文件以及文件夹进行封装的对象,可以通过对象的思想来操作文件和文件夹。
File类保存文件或目录的各种元数据信息,包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名,判断指定文件是否存在、获得当前目录中的文件列表,创建、删除文件和目录等方法。
9.RandomAccessFile类
该对象并不是流体系中的一员,其封装了字节流,同时还封装了一个缓冲区(字符数组),通过内部的指针来操作字符数组中的数据。 该对象特点:
1.该对象只能操作文件,所以构造函数接收两种类型的参数:a.字符串文件路径;b.File对象。
2.该对象既可以对文件进行读操作,也能进行写操作,在进行对象实例化时可指定操作模式(r,rw)
代码:
键入
public static void main(String[] args) {
//1.创建BufferedReader类型的对象与键盘输入(System.in)进行关联
BufferReader br=new BufferReader(new InputStreamReader(System.in));
PrintStream ps=new Println(new FileOutputStream("c:/a.txt"));
//3.不断地提示用户输入并读取一行本文,并且写入到c:/a.txt中
int flage=1;
while(true){
System.out.println();
String str=br.readLine();
if("byte".equals(str))break;
Date d=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh24:mm:ss");
ps.println(sdf.format(d)+(flage%2==0? "张三说:":"李四说:")+str);
flage++;
}
ps.flush();
ps.close();
br.close();
读取数据
public static void main(String[] args){
//1.创建DataInputStream类的对象与参数指定的文件关联
DataInputStream dis=new DataInputStream(new FileInputStream("c:/a.txt"));
//2.读取文件中的一个int类型数据并打印出来
int res=dis.readInt();
System.out.println("res="+res);
dis.close();
}
public static void main(String[] args) {
//1.创建DataOutputStream的对象与参数指定的文件进行关联
DataOutputStream dos = new DataOutputStream(
new FileOutputStream("c:/a.txt"));
//2.将整数数据66写入文件
dos.writeInt(88);
//3.关闭输出流对象
dos.close();
}
目录文件打印
public class TestDirPrint {
//打印指定目录中的内容,要求子目录中的内容也要打印出来
public static void dirPrint(File f){
//1.若f关联的是普通文件,则直接打印文件名即可
if(f.isFile()){
System.out.println(f.getName());
}
//2.若f关联的是目录文件,则打印目录名的同时使用[]括起来
if(f.isDirectory()){
System.out.println("[" + f.getName() + "]");
//3.获取该目录中的所有内容,分别进行打印
File[] ff = f.listFiles();
for(File ft : ff){
dirPrint(ft);
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
TestDirPrint.dirPrint(new File("D:/java09/day16"));
System.out.println(10/0);
}
}
**复制文件**
public class TestFileCopy {
public static void main(String[] args) {
try{
//1.建立FileInputStream类的对象与源文件建立关联
FileInputStream fis
= new FileInputStream("D:/java09/day16/javaseday16-IO流常用的类-06.wmv");
//2.建立FileOutputStream类的对象与目标文件建立关联
FileOutputStream fos = new FileOutputStream("c:/javaseday16-IO流常用的类-06.wmv");
//3.不断地读取源文件中的内容并写入到目标文件中
/* 可以实现文件的拷贝,但是文件比较大时效率很低
int res = 0;
while((res = fis.read()) != -1){
fos.write(res);
}
*/
//第二种方案,根据源文件的大小准备对应的缓冲区(数组),可能导致内存溢出
//第三种方案,无论文件的大小是多少,每次都准备一个1024整数倍的数组
byte[] data = new byte[1024 * 8];
int res = 0;
while((res = fis.read(data)) != -1){
fos.write(data, 0, res);
}
System.out.println("拷贝文件结束!");
//4.关闭文件输入流对象
fis.close();
//5.关闭文件输出流对象
fos.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
public class TestFileInputStream {
public static void main(String[] args) {
try{
//1.创建FileInputStream类的对象与指定的文件关联
FileInputStream fis = new FileInputStream("c:/a.txt");
//2.读取文件中的内容并打印
/*
int res = fis.read();
System.out.println("读取到的一个字节是:" + res); //h
System.out.println("\'h\'的ASCII值是:" + (int)'h');
res = fis.read();
System.out.println("读取到的一个字节是:" + res); //e
System.out.println("\'h\'的ASCII值是:" + (int)'e');
*/
/*
int res = 0;
while((res = fis.read()) != -1){
System.out.println("读取到的一个字节是:" + (char)res); //
}*/
byte[] data = new byte[10];
int res = fis.read(data);
System.out.println("实际读取到的数据大小是:"
+ res + ",读取到的文件内容是:" + new String(data, 0, res)
+ "!");
//3.关闭流对象并释放资源
fis.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
创建文件写入数据
public class TestFileOutputStream {
public static void main(String[] args) {
try{
//1.创建FileOutputStream类的对象,与指定的文件关联
//若文件不存在,则自动创建新的空文件
//FileOutputStream fos = new FileOutputStream("c:/a.txt", true);
fos.write("hello".getBytes());
System.out.println("写入数据成功!");
//3.刷新缓冲区并关闭流对象
fos.flush();
fos.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
读取对象object
public class TestObjectInputStream {
public static void main(String[] args) {
try{
//1.创建ObjectInputStream类型的对象与指定的文件关联
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("c:/user.dat"));
//2.读取文件中的一个对象并打印出来
Object obj = ois.readObject();
if(obj instanceof User){
User user = (User)obj;
System.out.println(user);
}
//3.关闭流对象
ois.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
public class TestObjectOutputStream {
public static void main(String[] args) {
try{
//1.创建ObjectOutputStream类的对象与指定的文件关联
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("c:/user.dat"));
//2.准备User类型的对象并进行初始化
User user = new User("Mark", "123456", "[email protected]");
//3.将User类型的对象整体写入到文件中
oos.writeObject(user);
System.out.println("写入对象成功!");
//4.关闭输出流对象
oos.flush();
oos.close();
}catch(Exception e){
e.printStackTrace();
}
}
}