流的概念:内存与存储设备之间传输数据的通道。
流的分类:
按方向:
输入流:将《存储设备》中的内容读入《内存》中。
输出流:将《内存》中的内容写入到《存储设备》中。
按单位:
字节流:以字节为单位,可以读写所有数据。
字符流:以字符为单位,只能读写文本数据。
按功能:
节点流:具有实际传输数据的读写功能。
过滤流:在节点流的基础之上增强功能。
字节流的父类(抽象类):
InputStream:字节输入流
OutputStream:字节输出流
- 字节节点流
FileOutputStream:
public void write(byte[] b) //一次写对个字节,将b数组中的所有字节,写入输出流。
FileInputStream:
public int read(byte[] b) // 从流中读取多个字节,将读取到的内容存入b数组,返回实际读到的字节数;如果达到文件的尾部,则返回-1。
文件输出流:
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestStream{
public static void main(String[] args) throws Exception{
//绝对路径:E:\\code\\src\\Target.txt
//相对路径:File\\Target.txt 与上一种形式等价
//字节输出流
FileOutputStream fos = new FileOutputStream("File\\Target.txt");
//fos.write(65);//一次输出一个字节
//fos.write(66);
//fos.write('C');
byte[] bs = new byte[]{65,66,67,68,69};
//for.write(bs);//一次输出一组字节
fos.write(bs,1,3);//一次输出一组字节的一部分
}
}
文件输入流:
public class TestFileInputStream{
public static void main(String [] args) thrwos IOException{
FileInputStream fis = new FileInputStream("File\\Targe.txt");
//一次读一个字节
while(true){
int n = fis.read();
if(n==-1){
break;
}
System.out.println((char)n);
}
//一次读一组字节
byte[] cache = new byte[4];//创建了一个长度为4的数组,作为读取时的缓存
while(true){
int count = fis.read(cache);
if(count == -1){
break;
}
for(int i = 0;i<count;i++){ //根据读取字节的个数,决定打印的次数
System.out.print((char)cache[i] + "\t");
}
System.out.println();
}
}
- 字节过滤流
缓冲流:BufferedOutputStream / BufferedInputStream
提高I/O效率,减少访问磁盘的次数;
数据存储在缓冲区中,flush是将缓冲区的内容写入文件中,也可以直接close。
import java.io.BufferedOutputStream;
public class TestBufferedStream{
public static void main(String[] args) throws IOException{
FileOutputStream os = new FileOutputStream("Files\\buffer.txt");//节点流
BufferedOutputStream bos = new BufferedOutputStream(os);//过滤流
bos.write('A');
bos.write('B');
bos.write('C');
bos.flush();//刷新缓冲(将缓冲中的数据,一次性写入文件中,并清空缓冲区)
bos.write('D');
bos.write('E');
bos.close();//级联执行flush
//----------------------------------------------------------------------
FileInputStream is = new FileInputStream("Files\\buffer.txt");
byte[] cache = new byte[4];
while(true){
int conut = is.read(cache);
if(count == -1) break;
for(int i = 1;i<count;i++){
System.out.println(cache[i]+"\t");
}
System.out.println();
}
}
}
-
对象流:ObjectOutStream / ObjectInputStream
增强了缓冲区功能。
增强了读写8中基本数据类型和字符串功能。
增强了读写对象的功能:1、readObject()从流中读取一个对象。2、writeObject(Object obj) 向流中写入一个对象。
import java.io.FileNotFountException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
public class TestObjectStream{
public static void main(String[] args) throws IOException;
OutputStream os = new OutputStream("Files\\object.txt");
ObjectOutputStream oos = new ObjectOutputStream(os);
Object obj = oos.readObject();
Student stu = (Student) obj;
System.out.println(stu.name+"\t"+sut.age+"\t"+stu.sex+"\t"+stu.score);
}
}
class Student implements Serializable{
String name;
Interger age;
String sex;
Double score;
public Student(String name,Interget age,String sex,Double score){
super();
this.name = name;
this.age = age;
this.sex = sex;
this.score = score;
}
}
- 字符流
Reader:字符输入流。
Writer:字符输出流。
- 字符节点流
FileWriter:
public void write(String str) //一次写多个字符,将b数组中所有字符,写入输出流。
FileReader:
public void read(char[] c) //从流中读取多个字符,将读到的内容存入c数组,返回实际读到的字符数;如果达到文件的尾部,则返回-1.
import java.io.Filewriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
public class TestReaderWriter{
public fw = new FileWriter("Files\\chars.txt");
fw.Writer("helloword");
fw.flush();
fw.close();
Reader fr = new FileReader("Files\\chars.txt");
char[] cache = new char[4];
while(true){
int n = fr.read(cache);
if(n==-1)break;
for(int i=0;i<n;i++){
System.out.println(cache[i]);
}
System.out.println();
}
}
-
字符过滤流
缓冲流:BufferedWriter / BufferedReader
支持输入换行。
可一次写一行,读一行。PrintWriter:
PrintWriter封装了print()和println().支持自动换行。
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class TestBuffered{
public static void main(String[] args) throws IOException{
Writer fw = new FileWriter("Files\\b.txt");
BufferedWriter bw = new BufferedWriter(fw);
bw.write("hello");
bw.newLine();
bw.write("World");
bw.close();
Reader fr = new FileReader("Files\\b.txt");
BufferedReader br = new BufferedReader(fr);
for(;;){
String s = br.readLine();
if(s==null)bread;
System.out.println(s);
}
}
}
- 字符节点流
桥接换流:InputStreamReader / OutputStreamWriter
可将字节流转换为字符流
可设置字符的编码方式
public class TestConvertStream{
public static void main(String[] args) throws IOException{
//原来持有字节输出流
OutputStream os = new FileOutputStream("Files\\convert.txt");
//转换为字符输出流
OutputStreamWriter osw = new OutputStreamWriter(os,"GBK");//设置编码方式
//在包装一层
PrintWriter pw = new PrintWriter(osw);
pw.println("你好");
pw.println("世界");
pw.close();
//----------------------------------------------------
InputStream is = new FileInputStream("Files\\convert.txt");
InputStreamReader isr = new InputStreamReader(is,"GBK");//设置解码方式
BufferedReader br = new BufferedReader(isr);
while(true){
String s = br.readLine();
if(s==null) break;
System.out.println(s);
}
}
}
- 使用步骤
1、创建节点流
(创建过滤流 设置字符编码集)
2、封装过滤流
3、读写数据
4、关闭流