小梁同学 の
Java学习旅途
你好！ 这是小梁同学使用博客所记录的文章笔记，作为一个初学者的从基础到未来的记录，如果你想和我一起在Java学习路程上坚持下去，欢迎你的关注与指正。
以下所有有关代码，都是个人在上完课后自己重新敲代码之后所做笔记后上传，并非原搬直接上传，谢谢理解
三.IO流
1.IO流分类
1.概念
I/O:input(输入) /Output（输出）
流:抽象概念，数据传输的总称，就是说数据在设备之间的传输称之为流，本质就是传输
常见的数据传输形式:文件的Copy、上传、下载
2.根据数据流向分类
输入流：读数据
输出流：写数据
解释：站在内存的角度考虑
3.根据数据类型分类
字节流（万能流）：字节输入流 / 字节输出流
字符流 ：字符输入流 / 字符输出流
2.字节流
1.字节流写数据
字节输出流–OutputStream
直接创建的话会显示OutputStream抽象类不能够实例化对象,故选择它的子类FileOutputStream创建字节输出流对象，代码如下：
import java.io.FileOutputStream;import java.io.IOException;public class Test1 {public static void main(String[] args) throws IOException {//抽象类不能够实例化对象//OutputStreamtream outputStream = new OutputStream();//1.创建字节输出流对象//（1)覆盖写,每次重新运行程序都会在创建的文本中重新写入数据FileOutputStream fops = new FileOutputStream("./myBook.txt"); //（2)追加写,通过构造方法中的第二个参数来决定//true,则在原文本后面加上新写入的//false，则表示不追加写，与覆盖写异曲同工FileOutputStream fops = new FileOutputStream("./myBook.txt"，true); //2.数据的传输操作//（1）正常一个一个写入fops.write(68);//'D'fops.write(69);//'E'//（2）向文件中写入26个英文字母for (int i = 0; i < 26; i++) {fops.write(65 + i);}//（3）写一个byte数组byte[] bytes = {97,98,99,100,101,102};fops.write(bytes);//'abcdef'//（4）将一个字符串转换未byte类型数组，getBytes()byte[] bytes = "187288837298你好，小白".getBytes();//第一个参数为起始点，后一个为截止长度fops.write(bytes,0,16);//3.关闭流，释放资源fops.close();}}
2.字节流读数据
字节输入流-- InputStream
与字节输出流一样，直接创建的话会显示InputStream抽象类不能够实例化对象,故选择它的子类FileInputStream创建字节输出流对象，代码如下：
import java.io.FileInputStream;import java.io.IOException;public class Test2 {public static void main(String[] args) throws IOException {//1.创建字节输入流对象FileInputStream fips = new FileInputStream("./myBook.txt");//2.操作输入流数据//(1)一次读一个字节// int by = fips.read();// by = fips.read();// by = fips.read();// System.out.println(by);//当没有数字时,by会输出-1.//(2)单个字节循环读取// int by;// while ((by = fips.read())!=-1){// System.out.println((char)by);// }//(3)一次读取一个数组byte[] bytes = new byte[10];//用来读取数据的缓冲区int len = fips.read(bytes);//返回的是数组中实际数据的长度System.out.println(new String(bytes));System.out.println(new String(bytes,0,len));//(4)通过数组循环的方式读取数据//将数据读取到byte数组中时，如果有数据则返回实际数据的长度，如果没有数据，则返回-1while ((len=fips.read(bytes))!=-1) {System.out.println(new String(bytes));System.out.println(new String(bytes, 0, len));}//3.关闭连接并释放资源fips.close();}}
3.字节流异常处理
抛出 或者 捕获通过finally来释放资源close字节流中异常处理可以通过抛出或捕获的方式进行处理，但不推荐捕获，因为相对于抛出而言，捕获的代码不易规整，以下代码为捕获处理异常，仅供参考：
import java.io.FileOutputStream;import java.io.IOException;public class Test1 {public static void main(String[] args) {//1、创建字节输出流对象FileOutputStream fops = null; //覆盖写try {fops = new FileOutputStream("./myBook.txt");//2、数据的传输操作byte[] bytes = "1872367882你好小白".getBytes();//将字符串转换成byte类型数组fops.write(bytes,0,22);} catch (IOException e) {e.printStackTrace();}finally {// 3、关闭流，释放资源try {fops.close();} catch (IOException e) {e.printStackTrace();}}}}
4.字节流(边读边写)
读一个字节，写一个字节
import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class test3 {public static void main(String[] args) throws IOException {//创建字节输入流对象FileInputStream fips = new FileInputStream("./myTest.txt");//创建字节输出流对象FileOutputStream fops = new FileOutputStream("./newMyTest.txt");int by;while ((by = fips.read())!=-1){//读一个字节同时写一个字节fops.write(by);}//关闭流，释放资源fips.close();fops.close();}}
5.字节流缓冲区
BufferedOutputStreamBufferedInputStream分别定义四个方法来进行对比看所复制文件的时间：
基本字节流一次读写一个字节
基本字节流一次读写一个数组
缓冲区字节流一次读写一个字节
缓冲区字节流一次读写一个数组
import java.io.*;public class Test3 {public static void main(String[] args) throws IOException{final String VCR = "./video.mp4";final String TO = "./newVideo.mp4";long startTime = System.currentTimeMillis();//开始时的毫秒数method1(VCR,TO);//method2(VCR,TO);//method3(VCR,TO);//method4(VCR,TO);long endTime = System.currentTimeMillis();//结束时的毫秒数System.out.println("复制该文件共耗时:"+(endTime - startTime)+"毫秒");}//定义method1方法:基本字节流一次读写一个字节,实现文件Copyprivate static void method1(String vcr, String to) throws IOException {//1.创建字节流对象FileInputStream fips = new FileInputStream(vcr);FileOutputStream fops = new FileOutputStream(to);//2.操作字节流数据int by;while ((by = fips.read())!=-1){fops.write(by);}//3.关闭连接并释放资源fips.close();fops.close();}//定义method2方法:基本字节流一次读写一个数组,实现文件Copyprivate static void method2(String vcr, String to) throws IOException {//1.创建字节流对象FileInputStream fips = new FileInputStream(vcr);FileOutputStream fops = new FileOutputStream(to);//2.操作字节流数据byte[] bytes = new byte[1024];int len;while ((len = fips.read(bytes))!=-1){fops.write(bytes,0,len);}//3.关闭连接并释放资源fips.close();fops.close();}//定义method3方法:缓冲区字节流一次读写一个字节,实现文件Copyprivate static void method3(String vcr, String to) throws IOException {//1.创建字节流对象BufferedInputStream bips = new BufferedInputStream(new FileInputStream(vcr));BufferedOutputStream bops = new BufferedOutputStream(new FileOutputStream(to));//2.操作字节流数据int by;while ((by = bips.read())!=-1){bops.write(by);}//3.关闭连接并释放资源bips.close();bops.close();}//定义method4方法:缓冲区字节流一次读写一个数组,实现文件Copyprivate static void method4(String vcr, String to) throws IOException {//1.创建字节流对象BufferedInputStream bips = new BufferedInputStream(new FileInputStream(vcr));BufferedOutputStream bops = new BufferedOutputStream(new FileOutputStream(to));//2.操作字节流数据byte[] bytes = new byte[1024];int len;while ((len = bips.read(bytes))!=-1){bops.write(bytes,0,len);}//3.关闭连接并释放资源bips.close();bops.close();}}
3.字符流
1.概述
存储形式：一个英文、汉字以及标点符号的存储就是其对应的简单字符
字符流 = 字节流 + 编码表
常见的字符编码：
①ASCll
②GBK
③Unicode
④UTF-8/16/32
2.编码与解码
编码 getBytes():使用平台默认的编码格式（字符集）getBytes(Stirng chatSetName) ： 使用的是指定的编码格式（字符集） 解码 String(byte[] bytes) : 使用平台默认的编码格式解码（字符集）String(byte[] bytes，String charSetName) : 使用指定的编码格式解码（字符集）package com.liang.IO03;import java.util.Arrays;import java.io.UnsupportedEncodingException;public class Test04 {public static void main(String[] args) throws UnsupportedEncodingException {String str = "Jack梁";//使用UTF-8字符集进行编码byte[] byte1 = str.getBytes("UTF-8");//使用GBK字符集进行编码byte[] byte2 = str.getBytes("GBK");//不规定的情况下使用的是平台默认的编码格式byte[] byte3 = str.getBytes();System.out.println(Arrays.toString(byte1));System.out.println(Arrays.toString(byte2));System.out.println(Arrays.toString(byte3));//平台默认的编码格式解码System.out.println(new String(byte3));//指定的编码格式解码//因为字符集不同，所以中文出现乱码System.out.println(new String(byte3,"GBK"));}}===========================[74, 97, 99, 107, -26, -94, -127][74, 97, 99, 107, -63, -70][74, 97, 99, 107, -26, -94, -127]Jack梁Jack姊�
3.字符流写数据
OutputStreamWriter
package com.liang.IO03;import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStreamWriter;public class Test05 {public static void main(String[] args) throws IOException {//将字节输出流对象包装成字符输出流对象OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("./muTest.txt",false));//写一个字符osw.write(66);osw.write('d');//写一个字符串osw.write("你好，李焕英！");osw.write("987654321",4,3);//写一个字符数组char[] chars={'a','s','d','f','g'};osw.write(chars);osw.write(chars,3,2);//关闭流osw.close();}}
4.字符流读数据
InputStreamReader
package com.liang.IO03;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStreamReader;public class Test06 {public static void main(String[] args) throws IOException {//将字节输入流对象包装成字符输入流对象InputStreamReader isr = new InputStreamReader(new FileInputStream("./muTest.txt"));//一次读取一个字符// int is;// while ((is = isr.read()) != -1){// System.out.println((char)is);// }//一次读一个字符数组char[] chars = new char[1024];int len;while ((len =isr.read(chars)) != -1){System.out.println(chars);}//关闭流isr.close();}}
5.字符流的文本拷贝
package com.liang.IO03;import java.io.*;public class Test07 {public static void main(String[] args) throws IOException {将字节输出、输入流对象包装成字符输出、输入流对象//字符流构造方法中的第二个参数用来设置字符集（编码格式）InputStreamReader isr = new InputStreamReader(new FileInputStream("./muTest.txt"), "GBK");OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("./myTest.txt"),"GBK");//单个字符形式int is ;while ((is = isr.read()) != -1){osw.write(is);}//单个字符数组形式char[] chars = new char[1024];int len;while ((len = isr.read(chars)) != -1){osw.write(chars,0,len);}//关闭流isr.close();osw.close();}}
6.字符流的简化写法
FileReaderFileWriterpackage com.liang.IO03;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;public class Test08 {public static void main(String[] args) throws IOException {FileReader fr = new FileReader("./muTest.txt");FileWriter fw = new FileWriter("./newMuTest.test");//一次读写一个字符int is;while ((is = fr.read()) != -1){fw.write(is);}//一次读写一个字符数组char[] chars = new char[1024];int len;while ((len = fr.read(chars)) != -1){fw.write(chars,0,len);}fr.close();fw.close();}}
7.字符流缓冲区
1.高效读写
BufferedReaderBufferedWriterpublic class Test09 {public static void main(String[] args) throws IOException {//创建缓冲区字符流对象// BufferedReader br = new BufferedReader(//new InputStreamReader(new FileInputStream("./muTest.txt")));// BufferedWriter bw = new BufferedWriter(//new OutputStreamWriter(new FileOutputStream("./myNewTest.txt")));//简写创建缓冲区字符流对象BufferedReader br = new BufferedReader(new FileReader("./muTest.txt"));BufferedWriter bw = new BufferedWriter(new FileWriter("./myNewTest.txt"));//实现文本文件复制char[] chars = new char[1024];int len;while ((len = br.read(chars)) != -1){bw.write(chars,0,len);}//关闭流br.close();bw.close();}}
2.特有方法
public class Test10 {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new FileReader("./muTest.txt"));BufferedWriter bw = new BufferedWriter(new FileWriter("./muNewTest.txt"));//将读出来的一行字符串存入到line中String line;//判断行是否为空while ((line = br.readLine()) != null){//写一行bw.write(line);//换一行，插入一个换行符bw.newLine();//手动刷新bw.flush();}br.close();bw.close();}}
4.标准流
1.System.in标准输入流
获取标准设备输入的流
public class Test11 {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));BufferedWriter bw = new BufferedWriter(new FileWriter("./myNewTest.txt"));//向程序中输入内容，直到over出现程序终止String str;System.out.println("请输入一行字符串：");while (true){//判断输入的内容是不是overif ((str = br.readLine()).equals("over")){//出现over 则结束后跳出循环System.out.println("聊天结束！");break;}//程序没有结束时写入一行bw.write(str);//进行换行继续写入bw.newLine();//实时刷新bw.flush();}br.close();bw.close();}}=========================请输入一行字符串：sdfbgb2655451516edrg516656415454rgrfgwefover聊天结束！
2.System.out标准输出流
将数据显示到标准输出设备中
public class Test12 {public static void main(String[] args) throws IOException {BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));bw.write("标准输出流");System.out.println("正常打印");bw.close();}}
3.System.err 标准错误流
public class Test13 {public static void main(String[] args) throws IOException {System.out.println("正常输出");//标准错误流：显示颜色红色，不建议与自己封装的错误流同时使用//System.err.println("我是标准错误流");//自己封装的错误流BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.err));bw.write("自定义封装的错误流");bw.close();}}
5.对象的持久化存储
1.单个学生对象存储到文件
public class Student {private String name;private int 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;}public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}}
public class Demo01 {public static void main(String[] args) throws IOException {Student stu = new Student("Jack", 18);// mySave(stu);Student resStu = myLoad();System.out.println(resStu);}private static Student myLoad() throws IOException {//读文件BufferedReader br = new BufferedReader(new FileReader("./myTest.txt"));String str = br.readLine();String[] split = str.split("##");Student stu = new Student(split[0], Integer.parseInt(split[1]));br.close();return stu;}private static void mySave(Student stu) throws IOException {//将其写到文件中BufferedWriter bw = new BufferedWriter(new FileWriter("./myTest.txt"));bw.write(stu.getName() + "##" + stu.getAge());bw.close();}}
2.多个学生对象存储到文件
public class Demo02 {public static void main(String[] args) throws IOException {Student[] students = new Student[8];students[0] = new Student("张三", 28);students[1] = new Student("李四", 26);students[2] = new Student("王五", 22);students[3] = new Student("赵六", 27);students[4] = new Student("贾七", 24);students[5] = new Student("魏八", 25);students[6] = new Student("孙九", 29);students[7] = new Student("老大", 30);//将多个对象存储到文件中//saveStu(students);//读取文件内容Student[] stud = loadStu();for (Student stu :stud) {System.out.println(stu);}}private static Student[] loadStu() throws IOException {BufferedReader br = new BufferedReader(new FileReader("./myTest.txt"));//获取每一条学生信息String[] stuArr = br.readLine().split("@@");//存储从文件中取出来的学生信息对象Student[] students = new Student[8];for (int i = 0;i<students.length;i++){String[] stus = stuArr[i].split("##");students[i] = new Student(stus[0],Integer.parseInt(stus[1]));}br.close();return students;}private static void saveStu(Student[] students) throws IOException {BufferedWriter bw = new BufferedWriter(new FileWriter("./myTest.txt"));//遍历数组拿到对象for (Student stu:students) {bw.write(stu.getName() + "##" + stu.getAge() + "@@");}bw.close();}}
3.对象的串行化（序列化）操作
ObjectOutputStreamObjectInputStreampublic class Student implements Serializable {private String name;private int age;private static final long serialVersionUID = -5281125824123725016L;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;}public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}public void show(){System.out.println("zhanshi ");}}public class Demo03 {public static void main(String[] args) throws IOException, ClassNotFoundException {//序列化存单个对象// Student stu = new Student("Jack", 50);// ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myTest.txt"));// oos.writeObject(stu);// oos.close();//序列化取单个对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myTest.txt"));Student student = (Student) ois.readObject();System.out.println(student);ois.close();}}
注：
1.实体类序列化（串行化）后，不可以改变类中方法，否则报错
解决方式：找到序列化编号，在实体中定义常量
private static final long serialVersionUID = -5281125824123725016L;
2.屏蔽序列化：transient
java进阶基础—2.2----上一章节: File类
java进阶基础—课后习题: 跳转
