目录
1.字节流
1.1 IO流概述和分类
1.2字节流写数据
1.3字节流写数据的三种方式
1.4字节流写数据的两个小问题
1.5字节流写数据加异常处理
1.6字节流读数据(一次读一个字节数据)
1.7字节流复制文件
1.8字节流读数据(一次读一个字节数组数据)
1.9字节流复制文件
2.字节缓冲流
2.1字节缓冲流构造方法
2.2字节缓冲流复制视频
3.字符流
3.1字符串中的编码解码问题
3.2字符流写数据
3.3字符流读数据
4.字符缓冲流
4.1字符缓冲流特有功能
4.2字符缓冲流操作文件中数据排序案例
5.转换流
5.1转换流读写数据
6.对象操作流
6.1对象序列化流
6.2对象反序列化流
1.字节流
1.1 IO流概述和分类
-
IO流介绍
-
IO:输入/输出(Input/Output) -
流:是一种抽象概念,是对数据传输的总称.也就是说数据在设备间的传输称为流,流的本质是数据传输 -
IO流就是用来处理设备间数据传输问题的.常见的应用: 文件复制; 文件上传; 文件下载
-
IO流的分类
-
IO流的使用场景
-
如果操作的是纯文本文件,优先使用字符流 -
如果操作的是图片、视频、音频等二进制文件,优先使用字节流 -
如果不确定文件类型,优先使用字节流.字节流是万能的流
1.2字节流写数据
-
字节流抽象基类
-
InputStream:这个抽象类是表示字节输入流的所有类的超类 -
OutputStream:这个抽象类是表示字节输出流的所有类的超类 -
子类名特点:子类名称都是以其父类名作为子类名的后缀
-
字节输出流
-
使用字节输出流写数据的步骤
-
创建字节输出流对象(调用系统功能创建了文件,创建字节输出流对象,让字节输出流对象指向文件) -
调用字节输出流对象的写数据方法 -
释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源) -
示例代码 -
public class FileOutputStreamDemo01 {
public static void main(String[] args) throws IOException {
//创建字节输出流对象
/*
注意点:
1.如果文件不存在,会帮我们创建
2.如果文件存在,会把文件清空
*/
//FileOutputStream(String name):创建文件输出流以指定的名称写入文件
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
//void write(int b):将指定的字节写入此文件输出流
fos.write(97);
// fos.write(57);
// fos.write(55);
//最后都要释放资源
//void close():关闭此文件输出流并释放与此流相关联的任何系统资源。
fos.close();
}
}
??
1.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 {
//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);
//释放资源
fos.close();
}
}
1.4字节流写数据的两个小问题
-
字节流写数据如何实现换行
-
windows:\r\n -
linux:\n -
mac:\r
-
字节流写数据如何实现追加写入
public class FileOutputStreamDemo03 {
public static void main(String[] args) throws IOException {
//创建字节输出流对象
// FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt",true);
//写数据
for (int i = 0; i < 10; i++) {
fos.write("hello".getBytes());
fos.write("\r\n".getBytes());
}
//释放资源
fos.close();
}
}
1.5字节流写数据加异常处理
异常处理格式
try{
可能出现异常的代码;
}catch(异常类名 变量名){
异常的处理代码;
}finally{
执行所有清除操作;
}
public class FileOutputStreamDemo04 {
public static void main(String[] args) {
//加入finally来实现释放资源
FileOutputStream fos = null;
try {
fos = new FileOutputStream("myByteStream\\fos.txt");
fos.write("hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
1.6字节流读数据(一次读一个字节数据)
-
字节输入流
-
字节输入流读取数据的步骤
-
创建字节输入流对象 -
调用字节输入流对象的读数据方法 -
释放资源
-
示例代码
public class FileInputStreamDemo01 {
public static void main(String[] args) throws IOException {
//创建字节输入流对象
//FileInputStream(String name)
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
int by;
/*
fis.read():读数据
by=fis.read():把读取到的数据赋值给by
by != -1:判断读取到的数据是否是-1
*/
while ((by=fis.read())!=-1) {
System.out.print((char)by);
}
//释放资源
fis.close();
}
}
1.7字节流复制文件
1.8字节流读数据(一次读一个字节数组数据)
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();
}
}
1.9字节流复制文件
public class CopyJpgDemo {
public static void main(String[] args) throws IOException {
//根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("E:\\develop\\a.jpg");
//根据目的地创建字节输出流对象
FileOutputStream fos = new FileOutputStream("myByteStream\\a.jpg");
//读写数据,复制图片(一次读取一个字节数组,一次写入一个字节数组)
byte[] bys = new byte[1024];
int len;
while ((len=fis.read(bys))!=-1) {
fos.write(bys,0,len);
}
//释放资源
fos.close();
fis.close();
}
}
2.字节缓冲流
2.1字节缓冲流构造方法
-
字节缓冲流介绍
-
lBufferOutputStream:该类实现缓冲输出流.通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用 -
lBufferedInputStream:创建BufferedInputStream将创建一个内部缓冲区数组.当从流中读取或跳过字节时,内部缓冲区将根据需要从所包含的输入流中重新填充,一次很多字节
构造方法:
BufferedOutputStream(OutputStream out) | 创建字节缓冲输出流对象 | BufferedInputStream(InputStream in) | 创建字节缓冲输入流对象 |
示例代码
public class BufferStreamDemo {
public static void main(String[] args) throws IOException {
//字节缓冲输出流:BufferedOutputStream(OutputStream out)
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\bos.txt"));
//写数据
bos.write("hello\r\n".getBytes());
bos.write("world\r\n".getBytes());
//释放资源
bos.close();
//字节缓冲输入流:BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myByteStream\\bos.txt"));
//一次读取一个字节数据
// int by;
// while ((by=bis.read())!=-1) {
// System.out.print((char)by);
// }
//一次读取一个字节数组数据
byte[] bys = new byte[1024];
int len;
while ((len=bis.read(bys))!=-1) {
System.out.print(new String(bys,0,len));
}
//释放资源
bis.close();
}
}
2.2字节缓冲流复制视频
public class CopyAviDemo {
public static void main(String[] args) throws IOException {
//复制视频
// method1();
method2();
}
//字节缓冲流一次读写一个字节数组
public static void method2() throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\develop\\字节流.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();
}
}
3.字符流
-
字符流的介绍 由于字节流操作中文不是特别的方便,所以Java就提供字符流 字符流 = 字节流 + 编码表 -
中文的字节存储方式 用字节流复制文本文件时,文本文件也会有中文,但是没有问题,原因是最终底层操作会自动进行字节拼接成中文,如何识别是中文的呢? 汉字在存储的时候,无论选择哪种编码存储,第一个字节都是负数
3.1字符串中的编码解码问题
byte[] getBytes() | 使用平台的默认字符集将该 String编码为一系列字节 | byte[] getBytes(String charsetName) | 使用指定的字符集将该 String编码为一系列字节 | String(byte[] bytes) | 使用平台的默认字符集解码指定的字节数组来创建字符串 | String(byte[] bytes, String charsetName) | 通过指定的字符集解码指定的字节数组来创建字符串 |
代码演示
public class StringDemo {
public static void main(String[] args) throws UnsupportedEncodingException {
//定义一个字符串
String s = "中国";
//byte[] bys = s.getBytes(); //[-28, -72, -83, -27, -101, -67]
//byte[] bys = s.getBytes("UTF-8"); //[-28, -72, -83, -27, -101, -67]
byte[] bys = s.getBytes("GBK"); //[-42, -48, -71, -6]
System.out.println(Arrays.toString(bys));
//String ss = new String(bys);
//String ss = new String(bys,"UTF-8");
String ss = new String(bys,"GBK");
System.out.println(ss);
}
}
3.2字符流写数据
-
介绍 Writer: 用于写入字符流的抽象父类 FileWriter: 用于写入字符流的常用子类 -
构造方法
FileWriter(File file) | 根据给定的 File 对象构造一个 FileWriter 对象 | FileWriter(File file, boolean append) | 根据给定的 File 对象构造一个 FileWriter 对象 | FileWriter(String fileName) | 根据给定的文件名构造一个 FileWriter 对象 | FileWriter(String fileName, boolean append) | 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象 |
-
成员方法
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 off, int len) | 写一个字符串的一部分 |
-
刷新和关闭的方法
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();
}
}
3.3字符流读数据
-
介绍 Reader: 用于读取字符流的抽象父类 FileReader: 用于读取字符流的常用子类
-
构造方法
FileReader(File file) | 在给定从中读取数据的 File 的情况下创建一个新 FileReader | FileReader(String fileName) | 在给定从中读取数据的文件名的情况下创建一个新 FileReader |
-
成员方法
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();
}
}
-
4.字符缓冲流 -
字符缓冲流介绍
-
构造方法
BufferedWriter(Writer out) | 创建字符缓冲输出流对象 | BufferedReader(Reader in) | 创建字符缓冲输入流对象 |
-
代码演示
public class BufferedStreamDemo01 {
public static void main(String[] args) throws IOException {
//BufferedWriter(Writer out)
BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\bw.txt"));
bw.write("hello\r\n");
bw.write("world\r\n");
bw.close();
//BufferedReader(Reader in)
BufferedReader br = new BufferedReader(new FileReader("myCharStream\\bw.txt"));
//一次读取一个字符数据
// int ch;
// while ((ch=br.read())!=-1) {
// System.out.print((char)ch);
// }
//一次读取一个字符数组数据
char[] chs = new char[1024];
int len;
while ((len=br.read(chs))!=-1) {
System.out.print(new String(chs,0,len));
}
br.close();
}
}
4.1字符缓冲流特有功能
-
方法介绍 BufferedWriter:
void newLine() | 写一行行分隔符,行分隔符字符串由系统属性定义 |
BufferedReader:
String readLine() | 读一行文字。 结果包含行的内容的字符串,不包括任何行终止字符如果流的结尾已经到达,则为null |
-
代码演示
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();
}
}
4.2字符缓冲流操作文件中数据排序案例
public class CharStreamDemo14 {
public static void main(String[] args) throws IOException {
//需求:读取文件中的数据,排序后再次写到本地文件
//分析:
//1.要把文件中的数据读取进来。
BufferedReader br = new BufferedReader(new FileReader("charstream\\sort.txt"));
//输出流一定不能写在这里,因为会清空文件中的内容
//BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\sort.txt"));
String line = br.readLine();
System.out.println("读取到的数据为" + line);
br.close();
//2.按照空格进行切割
String[] split = line.split(" ");//9 1 2 5 3 10 4 6 7 8
//3.把字符串类型的数组变成int类型
int [] arr = new int[split.length];
//遍历split数组,可以进行类型转换。
for (int i = 0; i < split.length; i++) {
String smallStr = split[i];
//类型转换
int number = Integer.parseInt(smallStr);
//把转换后的结果存入到arr中
arr[i] = number;
}
//4.排序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//5.把排序之后结果写回到本地 1 2 3 4...
BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\sort.txt"));
//写出
for (int i = 0; i < arr.length; i++) {
bw.write(arr[i] + " ");
bw.flush();
}
//释放资源
bw.close();
}
}
5.转换流
-
InputStreamReader:是从字节流到字符流的桥梁,父类是Reader 它读取字节,并使用指定的编码将其解码为字符 它使用的字符集可以由名称指定,也可以被明确指定,或者可以接受平台的默认字符集 -
OutputStreamWriter:是从字符流到字节流的桥梁,父类是Writer 是从字符流到字节流的桥梁,使用指定的编码将写入的字符编码为字节 它使用的字符集可以由名称指定,也可以被明确指定,或者可以接受平台的默认字符集
5.1转换流读写数据
InputStreamReader(InputStream in) | 使用默认字符编码创建InputStreamReader对象 | InputStreamReader(InputStream in,String chatset) | 使用指定的字符编码创建InputStreamReader对象 | OutputStreamWriter(OutputStream out) | 使用默认字符编码创建OutputStreamWriter对象 | OutputStreamWriter(OutputStream out,String charset) | 使用指定的字符编码创建OutputStreamWriter对象 |
代码演示
public class ConversionStreamDemo {
public static void main(String[] args) throws IOException {
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"),"GBK");
osw.write("中国");
osw.close();
//InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"));
InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"),"GBK");
//一次读取一个字符数据
int ch;
while ((ch=isr.read())!=-1) {
System.out.print((char)ch);
}
isr.close();
}
}
6.对象操作流
6.1对象序列化流
public class Student implements Serializable {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
测试类
public class ObjectOutputStreamDemo {
public static void main(String[] args) throws IOException {
//ObjectOutputStream(OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));
//创建对象
Student s = new Student("佟丽娅",30);
//void writeObject(Object obj):将指定的对象写入ObjectOutputStream
oos.writeObject(s);
//释放资源
oos.close();
}
}
注意事项
6.2对象反序列化流
public class ObjectInputStreamDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//ObjectInputStream(InputStream in):创建从指定的InputStream读取的ObjectInputStream
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));
//Object readObject():从ObjectInputStream读取一个对象
Object obj = ois.readObject();
Student s = (Student) obj;
System.out.println(s.getName() + "," + s.getAge());
ois.close();
}
}
|