一、字节流
字节流抽象基类
InputStream:这个抽象类是表示字节输入流的所有类的超类
OutputStream:这个抽象类是表示字节输出流的所有类的超类
子类名特点:子类名称都是以其父类名作为子类名的后缀
一、字节输出流
FileInputStream(String name):创建文件输出流以指定的名称写入文件
使用字节输出流写数据的步骤
1.创建字节输出流对象(调用系统功能创建了文件,创建字节输出流对象,让字节输出流对象指向文件)
2.调用字节输出流对象的写数据方法
3.释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)
字节流写数据的三种方式
void write(int b) 将指定的字节写入此文件输出流 一次写一个字节数据
void write(byte[] b) 将 b.length字节从指定的字节数组写入此文件输出流 一次写一个字节数组数据
void write(byte[] b, int off, int len) 将 len字节从指定的字节数组开始,从偏移量off开始写入此文件输出流 一次写一个字节数组的部分数据
public class FileOutputStreamDemo02 {
public static void main(String[] args) throws IOException {
try {
//FileOutputStream(String name):创建文件输出流以指定的名称写入文件
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
//FileOutputStream(File file):创建文件输出流以写入由指定的 File对象表示的文件
// FileOutputStream fos = new FileOutputStream(new File("myByteStream\\fos.txt"));
//void write(int b):将指定的字节写入此文件输出流
// fos.write(97);
// fos.write(98);
// fos.write(99);
// fos.write(100);
// fos.write(101);
// void write(byte[] b):将 b.length字节从指定的字节数组写入此文件输出流
// byte[] bys = {97, 98, 99, 100, 101};
//byte[] getBytes():返回字符串对应的字节数组
byte[] bys = "abcde".getBytes();
// fos.write(bys);
//void write(byte[] b, int off, int len):将 len字节从指定的字节数组开始,从偏移量off开始写入此文件输出流
// fos.write(bys,0,bys.length);
fos.write(bys,1,3);
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos != null) {
try {
//释放资源
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
字节流写数据如何实现换行
- windows:\r\n
- linux:\n
- mac:\r
字节流写数据如何实现追加写入
public FileOutputStream(String name,boolean append)
创建文件输出流以指定的名称写入文件。如果第二个参数为true ,则字节将写入文件的末尾而不是开头
二、字节输入流
FileInputStream(String name):通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的路径名name命名
字节输入流读取数据的步骤
1.创建字节输入流对象
2.调用字节输入流对象的读数据方法
3.释放资源
字节流读数据
一次读一个字节数组的方法
public int read(byte[] b):从输入流读取最多b.length个字节的数据
返回的是读入缓冲区的总字节数,也就是实际的读取字节个数
public class FileInputStreamDemo02 {
public static void main(String[] args) throws IOException {
//创建字节输入流对象
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
byte[] bys = new byte[1024]; //1024及其整数倍
int len;
//循环读取
while ((len=fis.read(bys))!=-1) {
System.out.print(new String(bys,0,len));
}
//释放资源
fis.close();
}
}
三、字节缓冲流
字节缓冲流介绍
BufferOutputStream:该类实现缓冲输出流.通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用
BufferedInputStream:创建BufferedInputStream将创建一个内部缓冲区数组.当从流中读取或跳过字节时,内部缓冲区将根据需要从所包含的输入流中重新填充,一次很多字节
构造方法:
BufferedOutputStream(OutputStream out) 创建字节缓冲输出流对象
BufferedInputStream(InputStream in) 创建字节缓冲输入流对象
//字节缓冲流一次读写一个字节数组
public static void method2() throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));
byte[] bys = new byte[1024];
int len;
while ((len=bis.read(bys))!=-1) {
bos.write(bys,0,len);
}
bos.close();
bis.close();
}
//字节缓冲流一次读写一个字节
public static void method1() throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));
int by;
while ((by=bis.read())!=-1) {
bos.write(by);
}
bos.close();
bis.close();
}
四、字符流
为什么有了字节流还会有字符流?
因为字节流在读取的时候是一个字节一个字节的读取,而汉字通常是占多个字节(如GBK编码是2个字节,utf8是3个字节),因此在读取的时候就会产生乱码。
字符流底层就是字节流+编码表
方法名 | 说明 |
FileWriter(File fifile)
|
根据给定的
File
对象构造一个
FileWriter
对象
|
FileWriter(File fifile, boolean
append)
|
根据给定的
File
对象构造一个
FileWriter
对象
|
FileWriter(String fifileName)
| 根据给定的文件名构造一个 FileWriter 对象 |
FileWriter(String fifileName,
boolean append)
|
根据给定的文件名以及指示是否附加写入数据的
boolean
值来构造 FileWriter 对象
|
(2)成员方法
方法名 | 说明 |
void write(int c) | 写一个字符 |
void write(char[] cbuf) | 写入一个字符数组 |
void write(char[] cbuf, int off, int len) | 写入字符数组的一部分 |
void write(String str) | 写一个字符串 |
void write(String str, int offff, int len)
|
写一个字符串的一部分
|
(3)刷新和关闭的方法
方法名 | 说明 |
flush()
|
刷新流,之后还可以继续写数据
|
close()
|
关闭流,释放资源,但是在关闭之前会先刷新流。一旦关闭,就不能再写数据
|
public class OutputStreamWriterDemo {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("myCharStream\\a.txt");
//void write(int c):写一个字符
// fw.write(97);
// fw.write(98);
// fw.write(99);
//void writ(char[] cbuf):写入一个字符数组
char[] chs = {'a', 'b', 'c', 'd', 'e'};
// fw.write(chs);
//void write(char[] cbuf, int off, int len):写入字符数组的一部分
// fw.write(chs, 0, chs.length);
// fw.write(chs, 1, 3);
//void write(String str):写一个字符串
// fw.write("abcde");
//void write(String str, int off, int len):写一个字符串的一部分
// fw.write("abcde", 0, "abcde".length());
fw.write("abcde", 1, 3);
//释放资源
fw.close();
}
}
2、字符流读数据
方法名
|
说明
|
FileReader(File file)
|
在给定从中读取数据的
File
的情况下创建一个新
FileReader
|
FileReader(String fileName)
|
在给定从中读取数据的文件名的情况下创建一个新
FileReader
|
(2)成员方法
方法名 | 说明 |
int read()
|
一次读一个字符数据
|
int read(char[] cbuf)
|
一次读一个字符数组数据
|
public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("myCharStream\\b.txt");
//int read():一次读一个字符数据
// int ch;
// while ((ch=fr.read())!=‐1) {
// System.out.print((char)ch);
// }
//int read(char[] cbuf):一次读一个字符数组数据
char[] chs = new char[1024];
int len;
while ((len = fr.read(chs)) != ‐1) {
System.out.print(new String(chs, 0, len));
}
//释放资源
fr.close();
}
}
3、字符缓冲流
方法名
|
说明
|
BufferedWriter(Writer out)
|
创建字符缓冲输出流对象
|
BufferedReader(Reader in)
|
创建字符缓冲输入流对象
|
字符缓冲流特有功能
public class BufferedStreamDemo02 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\bw.txt"));
//写数据
for (int i = 0; i < 10; i++) {
bw.write("hello" + i);
//bw.write("\r\n");
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
//创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("myCharStream\\bw.txt"));
String line;
while ((line=br.readLine())!=null) {
System.out.println(line);
}
br.close();
}
}