目录
IO流
又称输入输出流
注：流开启之后一定要关闭，在finally里关闭
关闭规则：先用后关，后用先关
1.按照流向分
输入流:从硬盘上读取数据到内存。 (读)
输出流:从内存写出数据到硬盘。 (写)
一个文件在传输过程中经历了多次拷贝，I0性能本身就很低。
File类不能操作文件的内容
2.按照操作单元分：
字节流:是一个字节一个字节的操作。二进制操作。操作任意类型的文件。.
字符流:是一个字符一个字符的操作。一个字符两个字节，主要用来处理文本文件
.txt,.java,.py,.xml,.properties,.html,.css,.js...
3、按照角色划分:
节点流:直接操作一个特定的I0设备。
处理流:在节点流的基础上，做进一步的处理。
java中输入/输出流常用的流：
| 字节输入流/输出流 | 字符输入/输出流 | |||
| 抽象基类 | InputStream | OutputStream | Reader | Writer |
| 访问文件 | FileInputStream | FileOutputStream | FileReader | FileWriter |
| 缓冲流 | BufferedInputStream | BufferedOutputStream | BufferedReader | BufferedWriter |
| 操作对象 | ObjectInputStream | ObjectOutputStream | ||
那么流到底怎么用？
输入流：就是一点一点的往内存里读数据！！！
字节输入流：
1.创建一个FileInputStream对象
2.定义一个标记，用来控制输入流的读取
3.循环读取，如果读取到—1，说明读取到了文件末尾，循环结束
4.关闭资源
注意：我们发现一个流读完就没有了，不能再读了。
当一个流读完之后会默认调用mark和resert方法来进行记录和重置
这个流已经重置到了上次读完的位置
所以就无法再次读取内容。并不是读完一次之后就关闭了流
@Test
public void test0() throws IOException {
InputStream inputStream = new FileInputStream("C:\\summerjava\\abc\\a.txt");
//开始读的操作，read方法，返回值是int,当返回值为一1时，说明文件读取到了尾部
// 读取文件是否结束的标记
int read;
// 字节流读数据的时候一个字节一个字节去读
//循环读取
while ((read = inputStream.read()) != -1) {
System.out.print(read + " ");
}
inputStream.close();//关闭资源如果有关闭的操作，就不要抛异常，建议都try/catch字节输出流：
FileOutputStream构造器：
Boolean oppend参数：如果传入true，则代表在原有基础上追加，不覆盖
如果传入false，或者不传，覆盖原有内容
@Test
public void test01(){
OutputStream outputStream=null;
try {
outputStream = new FileOutputStream("a.txt",true);
outputStream.write("\r\n".getBytes());
outputStream.write("八月正午的阳光都没你耀眼".getBytes());
outputStream.write(97);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
try {
outputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}文件的复制：
两个流：
FileInputStream：把对应文件的内容读取出来
FileOutputStream：把读到的内容写出去
read(byte[])
write(byte[])
@Test
public void test01(){
InputStream inputStream = null;
OutputStream outputStream = null;
try {
inputStream = new FileInputStream("E:\\workspace\\vscode\\HTML\\20220709\\img\\lijian.jpeg");
outputStream = new FileOutputStream("e:/lijian.jpeg");
byte [] buf = new byte[3];
int len;
// 循环读进来
while((len = inputStream.read(buf)) != -1){
// 写出去
outputStream.write(buf,0,len);
}
System.out.println("文件复制完毕...");
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
// IOUtil.closeIO(inputStream,outputStream);
try {
if(Objects.nonNull(outputStream)){
outputStream.close();
int i = 10 / 0;
}
} catch (Exception e) {
throw new RuntimeException(e);
}
try {
if(Objects.nonNull(inputStream)){
inputStream.close();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}字符流：
字符输入流：Writer wirter = new FileWriter("c:/a.txt");
字符输出流：Reader reader = new FileReader("c:/a.txt");
//输入流
@Test
public void test02() {
Writer writer = null;
try {
writer = new FileWriter("e:/bbb.txt");
writer.write("阿里巴巴规约手册...");
System.out.println("数据写出成功...");
} catch (IOException e) {
throw new RuntimeException(e);
}finally {
IOUtil.closeIO(null,writer);
}
}
//输出流
@Test
public void test01() {
Reader reader = null;
try {
reader = new FileReader("e:/aaa.txt");
int len;
char [] buf = new char[10];
while((len = reader.read(buf)) != -1){
System.out.println(new String(buf,0,len));
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
IOUtil.closeIO(reader,null);
}
}字符处理流（用的最多）
缓冲流，只能处理纯文本文件：
利用缓冲字符流写一个文件的复制：
@Test
public void test02() {
BufferedWriter bufferedWriter = null;
try {
bufferedWriter = new BufferedWriter(new FileWriter("c:/a.txt"));
bufferedWriter.write("今天是星期二，天气凉爽！");
System.out.println("数据写出成功！");
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
IOUtil.closeIO(null,bufferedWriter);
}
}
@Test
public void test01() {
BufferedReader bufferedReader = null;
try {
bufferedReader = new BufferedReader(new FileReader("c:/aaa.txt"));
String str;
while((str = bufferedReader.readLine()) != null) {
System.out.println(str);
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
IOUtil.closeIO(bufferedReader,null);
}
}写一个工具类用来关闭流：
传入输入输出流，进行判断是否为空并关闭。
import java.io.*;
import java.util.Objects;
public class IOUtil {
public static void closeIO(Reader reader, Writer writer){
if(Objects.nonNull(reader)) {
try {
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if(Objects.nonNull(writer)){
try {
writer.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void closeIO(InputStream inputStream, OutputStream outputStream) {
if(Objects.nonNull(inputStream)) {
try {
inputStream.close();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
if(Objects.nonNull(outputStream)){
try {
outputStream.close();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
}缓冲流：处理流：
Reader reader = new FileReader("e:/aaa.txt")
bufferedReader = new BufferedReader(reader);
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
try {
bufferedReader = new BufferedReader(new FileReader("e:/aaa.txt"));
bufferedWriter = new BufferedWriter(new FileWriter("e:/bbb.txt"));
String str;
while((str = bufferedReader.readLine()) != null){
bufferedWriter.write(str);//写入
bufferedWriter.newLine();//换行
}
System.out.println("文件复制成功！！！");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
IOUtil.closeIO(bufferedReader,bufferedWriter);
}序列化
Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。
将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。
整个过程都是 Java 虚拟机（JVM）独立的，也就是说，在一个平台上序列化的对象可以在另一个完全不同的平台上反序列化该对象。
类 ObjectInputStream 和 ObjectOutputStream 是高层次的数据流，它们包含反序列化和序列化对象的方法。
序列化：将对象写入到IO流中，将内存模型的对象变成字节数字，可以进行存储和传输。
反序列化：从IO流中恢复对象，将存储在硬盘上或者从网络中接收的数据恢复成对象模型
使用场景：
所有可在网络上传输的对象都必须是可序列化的，否则会报错，所有保存在硬盘上的对象也必须要可序列化。
序列化版本号：
反序列化必须拥有class文件，但随着项目的升级，class文件也会升级
序列化保证升级前后的兼容性。java序列化提供了一个版本号
版本号是可以自由指定，如果不指定，JVM会根据类信息自己计算一个版本号，所以无法匹配，则报错！！！
不指定版本号，还有一个隐患，不利于JVM的移植，可能class文件没有改，但是不同的jvm计算规则不一样，导致无法反序列化
如果只修改了方法，反序列化是不受影响，无需修改版本号
修改了静态变量static，瞬态变量transient，反序列化也不受影响，无需修改版本号
总结：
1.所有需要网络传输的对象都需要实现序列化接口
2.对象的类名、实例变量都会被序列化；方法、类变量、transient变量不会被序列化
3.如果想让某个变量不被序列化，可以用transient修饰
4.序列化对象的引用类型成员变量，也必须是可序列化的，否则会报错
5.反序列化时必须有序列化对象的class文件
6.同一个对象被序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化的版本号
7.建议所有可序列化的类加上版本号，方便项目升级。
我们最终会把所有的.class文件打包，把这个包部署到服务器上。
从始至终，.java仅仅是我们程序员写的，给程序员看的。
.java甚至不会参与到打包中，不会出现在服务器上。
运维人员去服务器部署项目，部署的就是一堆的.class。
我们的.properties属性文件是不参与编译的。
作业 ：利用IO流写一个简单的商店商品的增删改查
首先定义一个存储商店商品编号/商品名称/商品价格的类：
并重写toString方法为了方便查看。
Goods类：
public class Goods {
private Integer id;//商品编号
private String name;//商品名称
private Integer price;//商品价格
public Goods(){}
public Goods(Integer id, String name, Integer price) {
this.id = id;
this.name = name;
this.price = price;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getPrice() {
return price;
}
public void setPrice(Integer price) {
this.price = price;
}
@Override
public String toString() {
return "Goods{" +
"id=" + id +
", name='" + name + '\'' +
", price=" + price +
'}';
}
}写增删改查的方法：
ShopTwo类：
首先建一个缓冲流输入输出流对象和一个集合，集合是为了方便实现删除等操作，起到一个中间文件的作用，因为IO流没有删除更改等操作，所以需要把文本文件转换成一个集合方便操作：
public class ShopTwo {
private static BufferedReader bufferedReader =null;
private static BufferedWriter bufferedWriter =null;
private static List<Goods> list;
}增加商品：
public static void insert(Scanner sc){
System.out.println("请输入商品编号：");
Integer id=sc.nextInt();
System.out.println("请输入商品名称");
String name = sc.next();
System.out.println("请输入商品价格");
Integer price= sc.nextInt();
try {
bufferedWriter = new BufferedWriter(new FileWriter("c:/summerjava/d.txt",true));
String read=id+" "+name+" "+price;
bufferedWriter.write("\n"+read);//换行添加
} catch (Exception e) {
throw new RuntimeException(e);
}finally {
IOUtil.closeIO(null,bufferedWriter);
}
//直接追加：
}我先封装了一个方法addList()，因为他们都需要先把文件的内容添加到集合里：
public static void addList(){
try {
list = new ArrayList<>();
bufferedReader = new BufferedReader(new FileReader("c:/summerjava/d.txt"));
String read;
while((read=bufferedReader.readLine())!=null){
String[] s =read.split(" ");//把文本文档的内容以空格为界分为数组存储到s里
Goods goods = new Goods(Integer.valueOf(s[0]),s[1],Integer.valueOf(s[2]));
//利用构造器存到对象中，然后添加到集合中
list.add(goods);
}
}catch (FileNotFoundException e){
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
}finally {
IOUtil.closeIO(bufferedReader,null);
}
}删除商品：
public static void delete(Scanner sc){
System.out.println("请输入商品编号：");
//全部拿出来，删除后覆盖
int id = sc.nextInt();
try {
addList();
bufferedWriter = new BufferedWriter(new FileWriter("c:/summerjava/d.txt"));
Iterator<Goods> iterator = list.iterator();
while(iterator.hasNext()){//利用迭代器循环判断删除传入id的商品
Goods goods=iterator.next();
if(id==goods.getId()){
iterator.remove();
}
}
for (Goods goods: list) {//把删除后的集合写入
bufferedWriter.write(goods.getId()+" "+goods.getName()+" "+ goods.getPrice());
bufferedWriter.newLine();
}
} catch (Exception e) {
throw new RuntimeException(e);
}finally {
IOUtil.closeIO(null,bufferedWriter);
}
}查找一个：
public static void findOne(Scanner sc){
System.out.println("请输入商品编号：");
int id = sc.nextInt();
ShopTwo.addList();//把文件读取到集合里；
for (Goods goods: list) {
if(id==goods.getId()){
System.out.println(goods);//查找到并输出
}
}
}修改：
public static void update(Scanner sc){
//全部拿出来，放集合里，然后改。更新后覆盖
System.out.println("请输入商品编号：");
//全部拿出来，删除后覆盖
int id = sc.nextInt();
try {
addList();
bufferedWriter = new BufferedWriter(new FileWriter("c:/summerjava/d.txt"));
Iterator<Goods> iterator = list.iterator();
while(iterator.hasNext()){
Goods goods=iterator.next();
if(id==goods.getId()){
System.out.println("请输入您要修改后的商品名称");
goods.setName(sc.next());
System.out.println("请输入您要修改后的商品价格");
goods.setPrice(sc.nextInt());
}
}
for (Goods goods: list) {
bufferedWriter.write(goods.getId()+" "+goods.getName()+" "+ goods.getPrice());
bufferedWriter.newLine();
}
} catch (Exception e) {
throw new RuntimeException(e);
}finally {
IOUtil.closeIO(null,bufferedWriter);
}
}Demo：
public class Demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true) {
System.out.println("请选择功能:1.插入新商品、2.删除商品、3.修改商品、4.查找一个商品、5.退出");
String flag = sc.next();
switch (flag) {
case "1":
ShopTwo.insert(sc);
break;
case "2":
ShopTwo.delete(sc);
break;
case "3":
ShopTwo.update(sc);
break;
case "4":
ShopTwo.findOne(sc);
break;
case "5":
System.out.println("退出成功");
System.exit(-1);
break;
default:
break;
}
}
}
}操作类
记得导入操作类哦！！
package IOutil;
import java.io.*;
import java.util.Objects;
public class IOUtil {
public static void closeIO(Reader reader, Writer writer){
if(Objects.nonNull(reader)) {
try {
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if(Objects.nonNull(writer)){
try {
writer.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void closeIO(InputStream inputStream, OutputStream outputStream) {
if(Objects.nonNull(inputStream)) {
try {
inputStream.close();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
if(Objects.nonNull(outputStream)){
try {
outputStream.close();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
}
运行效果：
增加：
查看：
删除：
修改：
总结
又是干货满满的一天，IO流如何的流入流出，如何在文件、对象上应用现在还萦绕脑间上午的各种流的介绍还能听得到，但是具体到代码应用上我却看不懂，由于代码量过大我甚至出现了畏难心理，下午浑浑噩噩啥也没懂，尤其错过了复制应用，以至于晚上作业：IO流商品的增删改查，我到现在依然一脸懵逼，虽然在同学的帮助下写出来了，但是没有弄明白，唉~~
438
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
