day14_io

Ayui.

已于 2023-07-28 10:53:29 修改

阅读量28

点赞数

分类专栏： 01_javase 文章标签： java

于 2023-07-26 13:41:19 首次发布

本文链接：https://blog.csdn.net/m0_61569709/article/details/131937324

版权

01_javase 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1 字节流作业

public static void main(String[] args)throws Exception{
    copy(new File("C:\\Users\\Administrator\\Desktop\\java43课堂记录"),
         new File("C:\\Users\\Administrator\\Desktop\\aa"));
}
// 把a文件中的内容复制到b文件中
public static void fuZhi(File a,File b)throws Exception {
    // 1创建流与文件关联：
    FileInputStream fin=new FileInputStream(a);
    FileOutputStream fout=new FileOutputStream(b);
    // 2 选择读写方式
    byte[] arr=new byte[1024];//定义数组 装读取的信息
    int n;//定义变量记录每次读取的有效字节个数
    while((n=fin.read(arr))!=-1) {
        //把arr中前n个字节 写道fout中
        fout.write(arr, 0, n);
    }
    //3 关闭流
    fin.close();
    fout.close();
}
//2：写一个方法：实现文件/文件夹的复制
public static void copy(File yuan,File muDi)throws Exception{
    //判断yuan是否存在
    if(!yuan.exists()) {
        throw new RuntimeException(yuan.getAbsolutePath()+"不存在！");
    }
    //判断文件夹是否存在
    if(!muDi.exists()) {
        muDi.mkdirs();
    }
    //判断yuan是文件还是文件夹
    File zi=new File(muDi,yuan.getName());
    if(yuan.isFile()) {
        //在muDi中创建一个同名的子文
        zi.createNewFile();
        //把yuan中的内容复制到zi中
        //			// 1创建流与文件关联：
        //			FileInputStream fin=new FileInputStream(yuan);
        //			FileOutputStream fout=new FileOutputStream(zi);
        //			// 2 选择读写方式
        //			byte[] arr=new byte[1024];//定义数组 装读取的信息
        //			int n;//定义变量记录每次读取的有效字节个数
        //			while((n=fin.read(arr))!=-1) {
        //				//把arr中前n个字节 写道fout中
        //				fout.write(arr, 0, n);
        //			}
        //			//3 关闭流
        //			fin.close();
        //			fout.close();
        fuZhi(yuan,zi);
        return;
    }
    //文件夹
    zi.mkdir();
    //获取yuan下的所有子文件/子文件夹
    File[] ziFiles=yuan.listFiles();
    //把ziFiles都复制到zi下
    for (File ziFile : ziFiles) {
        copy(ziFile,zi);
    }
}

//把yuan剪切到muDi
public static void cut(File yuan,File muDi)throws Exception{
    //判断yuan是否存在
    if(!yuan.exists()) {
        throw new RuntimeException(yuan.getAbsolutePath()+"不存在！");
    }
    //判断文件夹是否存在
    if(!muDi.exists()) {
        muDi.mkdirs();
    }
    //判断yuan是文件还是文件夹
    File zi=new File(muDi,yuan.getName());
    if(yuan.isFile()) {
        //在muDi中创建一个同名的子文
        zi.createNewFile();
        //把yuan中的内容复制到zi中
        fuZhi(yuan,zi);
        System.out.println(yuan.getAbsolutePath()+"删除:::"+yuan.delete());//删除源文件
        return;
    }
    //文件夹
    zi.mkdir();
    //获取yuan下的所有子文件/子文件夹
    File[] ziFiles=yuan.listFiles();
    //把ziFiles都复制到zi下
    for (File ziFile : ziFiles) {
        cut(ziFile,zi);
    }
    System.out.println(yuan.getAbsolutePath()+"删除:::"+yuan.delete());
}

2 字符流

字符流：每次读写的是一个字符对应的多个字节

2.1 字符输入流

方法

      * FileReader:字符输入流
	 * 构造方法：
	 *   FileReader(File file) 
	 *   FileReader(String fileName) 
	 * 普通方法：
	 *   void close()  :关闭流释放资源
	 *   String getEncoding() ：获取编码集
	 *   int read()：每次读取一个字符  :::如果已到达流的末尾，则返回 -1 
	 *   int read(char[] arr)：每次读取一个字符数组:::如果已到达流的末尾，则返回 -1

代码

public static void testFileReader1()throws Exception {
    //1 创建流关联文件：
    FileReader fin=new FileReader("src/Test/2.txt");
    //2 选择读写方式：逐个字符读写
    int c;
    while((c=fin.read())!=-1) {
        System.out.print((char)(c));
    }
    //3 关闭流
    fin.close();
}
public static void testFileReader2()throws Exception {
    //1 创建流关联文件：
    FileReader fin=new FileReader("src/Test/2.txt");
    //2 选择读写方式：逐个字符数组读写
    int n;//记录每次读取的有效字符数
    char[] arr=new char[10];//定义字符数组 装每次读取的字符信息
    while((n=fin.read(arr))!=-1) {//每次最多读取arr.length个 装入arr中 n记录的是本次读取的有效字符数
        System.out.print(new String(arr, 0, n));
    }
    //获取编码集
    System.out.println("获取编码集：：："+fin.getEncoding());
    //3 关闭流
    fin.close();
}

2.2 字符输出流

方法

     * FileWriter:字符输出流
	 *  构造方法：
	 *    FileWriter(File file) 
	 *    FileWriter(String fileName) 
	 *    FileWriter(File file,boolean append) 
	 *    FileWriter(String fileName,boolean append) 
	 *  普通方法：
	 *    void close()  :关闭流释放资源
	 *    void write(int n);一次写一个字符
	 *    void write(char[] arr);一次写一个字符数组
	 *    void write(char[] arr,int startIndex,int length);一次写一个字符数组的一部分
	 *    String getEncoding() ：获取编码集
	 *    void flush(); 
	 * ---注意1：
	 *   FileOutPutStream的write方法：把字节信息直接写道目的文件中
	 *   其他输出流的write方法：是把信息写道缓存区中
	 *   其他输出流的flash方法：把缓存区中的信息刷新到目的文件中
	 *   
	 *   所以：除了FileOutPutStream 其他所有的输出流 每次write之后都需要flash
	 *   
	 * --注意2：
	 *    只有文本类型的文件 选择 使用字符流
	 *    所有文件都可以使用字节流

代码

public static void testFileWriter()throws Exception {
    //1 创建流关联文件：
    FileWriter fout=new FileWriter("src/Test/3.txt");
    //2 选择读写方式：
    fout.write('还');//一次写一个字符//把参数字符对应的所有字节打包 传递到缓存区中
    fout.flush();//把缓存区的信息刷新到目的文件中
    fout.write("你是吗？\r\n".toCharArray());//一次写一个字符数组
    fout.flush();
    fout.write("123abc你好吗？AAA".toCharArray(),3,5);//一次写一个字符数组的一部分
    fout.flush();
    //3 关闭流
    //fout.close();//字符输出流 关闭前会刷新一次 缓存区
}

2.3 字符流实现文件的复制

//写一个方法通过字符流实现文件的复制
public static void copyByReaderWriter() throws Exception {
    //1 创建流 关联文件
    FileReader fin=new FileReader("src/Test/Demo01.java");
    FileWriter fout=new FileWriter("src/Test/Demo01.txt");
    //2 选择读写方式
    char[] arr=new char[10];//创建字符数组 装读取的字符信息
    int n;//记录每次读取的有效字符数
    while((n=fin.read(arr))!=-1) {
        //把读取的信息写出去
        fout.write(arr, 0, n);
        //把缓存区中的信息刷新到目的文件中
        fout.flush();
    }
    //3 关闭流
    fin.close();
    fout.close();
}

3 高效流

3.1 概念和方法

     * 高效流：Buffered  是过滤器(关联的是节流流 对节点流的功能进行加强)
	 *        读写速度比关联的节点流快
	 * 字节高效流：BufferedInputStream+BufferedOutputStream
	 *          除了输出流需要flush 没有特有方法  和FileInputStream+FileOutputStream
	 * 字符高效流：BufferedReader+BufferedWriter
	 *         特点：1 高效读写  2 支持逐行读写
	 * BufferedReader：
	 *    构造方法：      
	 *        BufferedReader(Reader in) 
	 *    普通方法：
	 *        int read() 
	 *        int read(char[] cbuf, int off, int len)      
	 *        int read(char[] cbuf)  
	 *        void close()  
	 *     特有方法：
	 *        String readLine() ；一次读取一行： 如果已到达流末尾，则返回 null 
	 *BufferedWriter：
	 *     构造方法：
	 *        BufferedWriter(Writer out) 
	 *     普通方法：
	 *        void close() 
	 *        void flush()  
	 *        void write(int c)  
	 *        void write(char[] cbuf, int off, int len)  
	 *        void write(char[] cbuf)  
	 *        void write(String message)   
	 *        void write(String s, int off, int len)  
	 *     特有方法：
	 *        void newLine()

3.2 高效字符流实现复制

public static void testBufferedReaderWriter()throws Exception{
    //1 创建节点流与文件关联
    FileReader fin=new FileReader("src/Test/Student.java");
    FileWriter fout=new FileWriter("src/Test/Student.txt");
    // 创建高效流与节点流关联
    BufferedReader bin=new BufferedReader(fin);
    BufferedWriter bout=new BufferedWriter(fout);
    //2 选择读写方式： 1 逐个字符 2 逐个字符数组 3 逐行
    String line;//定义引用记录读取的行信息
    while((line=bin.readLine())!=null) {
        //把读取的信息写道目的文件中
        bout.write(line);//line中不包含换行符
        bout.flush();//把缓存区中的信息刷新到目的文件中
        bout.newLine();
        bout.flush();
    }
    //3 关闭流
    bin.close();
    bout.close();
}

3.3 高效字节流实现复制

public static void testBufferedStream()throws Exception{
    //1 创建节点流与文件关联
    FileInputStream fin=new FileInputStream("src/Test/55.jpeg");
    FileOutputStream fout=new FileOutputStream("src/Test/555.jpeg");
    // 创建高效流与节点流关联
    BufferedInputStream bin=new BufferedInputStream(fin);
    BufferedOutputStream bout=new BufferedOutputStream(fout);
    //2 选择读写方式： 1 逐个字节 2 逐个字节数组
    byte[] arr=new byte[1024];
    int n;
    while((n=bin.read(arr))!=-1) {
        //把读取的信息写道目的文件中
        bout.write(arr, 0, n);
        bout.flush();
    }
    //3 关闭流
    bin.close();
    bout.close();
}

4 转换流

4.1 转换流概念

转换流--过滤流
转换流：把字节流转换为字符流
       InputStreamReader 是字节输入流流通向字符输入流的桥梁
       OutputStreamWriter 是字节输出流流通向字符输出流的桥梁
相当于FileReader和FileWriter没有特有方法： 但 OutputStreamWriter需要flush
构造方法：
    OutputStreamWriter(OutputStream out, String charsetName) 
    InputStreamReader(InputStream in, String charsetName)

4.2转换流实现复制

//转换流实现复制
public static void copy() throws Exception{
    //1 创建节点流与文件关联
    //FileInputStream fin=new FileInputStream("src/Test/Demo01.txt");
    //FileOutputStream fout=new FileOutputStream("src/Test/Demo02.txt");
    // 2 源文件是文本文件：使用转换流把字节流转换为字符
    InputStreamReader in=new InputStreamReader(new FileInputStream("src/Test/Demo01.txt"),"GBK");
    OutputStreamWriter out=new OutputStreamWriter(new FileOutputStream("src/Test/Demo02.txt"),"GBK");
    //3 选择读写方式
    char[] arr=new char[10];
    int n;
    while((n=in.read(arr))!=-1) {
        out.write(arr, 0, n);
    }
    // 4 关闭流
    in.close();
    out.close();
}
//不使用scanner 把键盘输入的内容 大小写转换 删除数字  后输出
public static void change() throws Exception{
    //1 把系统的字节输入流转化为字符输入流
    InputStreamReader in=new InputStreamReader(System.in);
    // 想实现逐行读写：：再把字符流转化为高效流
    BufferedReader bin=new BufferedReader(in);
    //2 选择读的方式
    String line;
    while(true) {
        //系统流 没有结束：：：
        line=bin.readLine();
        //自己定义个特殊的字符串 表示交互结束
        if(line.endsWith("886")) {
            break;
        }
        line=changeStr(line);
        System.out.println("读取的信息是：：："+line);

    }
    //系统流不能关闭
}
private static String changeStr(String str) {
    StringBuffer stb=new StringBuffer(str);
    for (int i = 0; i < stb.length(); i++) {
        char c=stb.charAt(i);
        if(c>='a'&&c<='z') {
            stb.setCharAt(i, (char)(c-('a'-'A')));
        }else if(c>='A'&&c<='Z') {
            stb.setCharAt(i, (char)(c+('a'-'A')));
        }else if(c>='0'&&c<='9') {
            stb.deleteCharAt(i);
            i--;
        }
    }
    return stb.toString();
}

5 练习

5.1 练习1

public static void main(String[] args) throws Exception {
    yunSuan();
}
//3 获取键盘输入的内容：：：一个算式：把算式及其结果写道一个文件中
//每行输入的都是一个算式：如1+1   写道目的文件中：1+1=2
public static void yunSuan()throws Exception {
    // 分析：需要获取键盘输入流的信息---字符类型  逐行读取 并进行运算
    //       需要创建一个输出流与目的文件关联
    //1 键盘输入流是 字节流---使用转换流转化为字符流
    //2 为了实现逐行读写 需要高效字符流
    // 创建高效字符流 关联系统输入流
    BufferedReader bin=new BufferedReader(new InputStreamReader(System.in));
    // 为了实现逐行写 高效字符流最合适
    BufferedWriter bout=new BufferedWriter(new FileWriter("src/Test/运算.txt"));
    //逐行读写
    String line;
    while(true) {
        line=bin.readLine();
        //系统输入流没有末尾  只能通过特殊字符判断是否结束：：%886%
        if(line.endsWith("%886%")) {
            break;
        }
        line=changeStr(line);
        bout.write(line);
        bout.flush();
        bout.newLine();
        bout.flush();
    }
    bout.close();
}
private static String changeStr(String line) {//1+1   --->：1+1=2
    line=line.trim();
    //获取运算符的位置
    int index=0;
    if(line.contains("+")) {
        index=line.indexOf("+");
    }else if(line.contains("-")) {
        index=line.indexOf("-");
    }else if(line.contains("*")) {
        index=line.indexOf("*");
    }else if(line.contains("/")) {
        index=line.indexOf("/");
    }
    //获取运算符
    char ysf=line.charAt(index);
    double num1=Double.parseDouble(line.substring(0,index).trim());
    double num2=Double.parseDouble(line.substring(index+1).trim());
    //运算
    double result=0;
    switch(ysf) {
        case '+':
            result=num1+num2;
            break;
        case '-':
            result=num1-num2;
            break;
        case '*':
            result=num1*num2;
            break;
        case '/':
            result=num1/num2;
            break;
    }
    return num1+""+ysf+num2+"="+result;
}

5.2 练习2

public class LianXi02 {
	public static void main(String[] args)throws Exception {
		//添加
//		for (int i = 0; i < 10; i++) {
//			IoUtil.addOne(new Student(1000+i, 
//					"韩梅"+i, 
//					Math.random()>0.5?"男":"女", 
//					(int)(Math.random()*1001)/10.0f, 
//					(int)(Math.random()*10+18), Math.random()>0.5));
//		}
//		System.out.println("获取所有：："+IoUtil.getAll());
//		System.out.println("获取一个：：："+IoUtil.getOne(1001));
//		System.out.println("删除一个："+IoUtil.deleteOne(1000));
		System.out.println("修改一个："+IoUtil.updateOne(new Student(1002, "新来的", "妖", 11f, 12, true)));
		System.out.println("获取所有：："+IoUtil.getAll());
	}
}
//对Student.txt进行增删改查的工具类
class IoUtil{
	private static final String filePath="src/day14_io/Student.txt";
	public static int addOne(Student s)throws Exception {//返回0 表示添加失败 返回1 表示添加1行成功
		writeString(s.toString()+"\r\n",true);
		return 1;
	}
	public static Student getOne(int sid)throws Exception {
		File file=new File(filePath);
		if(!file.exists()) {
			return null;
		}
		BufferedReader bin=new BufferedReader(new FileReader(file));
		Student student=null;
		String line;
		while((line=bin.readLine())!=null) {
			line=line.trim();
			if(line.isEmpty()) {
				continue;
			}
			if(line.startsWith(sid+":")) {
				//把行信息解析为学生对象
				student=parseString(line);
				break;
			}
		}
		bin.close();
		return student;
	}
	public static List<Student> getAll()throws Exception  {
		File file=new File(filePath);
		if(!file.exists()) {
			return null;
		}
		BufferedReader bin=new BufferedReader(new FileReader(file));
		List<Student> list=new ArrayList<Student>();
		String line;
		while((line=bin.readLine())!=null) {
			line=line.trim();
			if(line.isEmpty()) {
				continue;
			}
			//把行信息解析为学生对象
			list.add(parseString(line));
		}
		bin.close();
		return list;
	}
	public static int deleteOne(int sid)throws Exception  {//返回0 表示删除失败 返回1 表示s删除1行成功
		//获取所有的学生
		List<Student> list=getAll();
		//删除和参数sid相同的学生
		for (int i = 0; i <list.size(); i++) {
			if(list.get(i).getSid().equals(sid)) {
				list.remove(i);
				break;
			}
		}
		//获取list对应的字符串
		StringBuffer stb=new StringBuffer();
		for (Student s : list) {
			stb.append(s);
			stb.append("\r\n");
		}
		writeString(stb.toString(),false);
		return 1;
	}
	public static int updateOne(Student s)throws Exception  {//返回0 表示删除失败 返回1 表示s删除1行成功
		     //获取所有的学生
				List<Student> list=getAll();
				//修改和参数sid相同的学生
				for (int i = 0; i <list.size(); i++) {
					if(list.get(i).getSid().equals(s.getSid())) {
						System.out.println("修改：：：");
						list.set(i, s);
						break;
					}
				}
				//获取list对应的字符串
				StringBuffer stb=new StringBuffer();
				for (Student stu : list) {
					stb.append(stu);
					stb.append("\r\n");
				}
				writeString(stb.toString(),false);
				return 1;
	}
	private static void writeString(String str,boolean append)throws Exception {
		//创建流与filePath关联
		FileWriter fout=new FileWriter(filePath, append);
		fout.write(str);
		fout.close();
	}
	private static Student parseString(String line) {
		String[] arr=line.split(":");
		return new Student(Integer.parseInt(arr[0]),
				          arr[1], 
				          arr[2], 
				          Float.parseFloat(arr[3]), 
				          Integer.parseInt(arr[4]), 
				          Boolean.parseBoolean(arr[5]));
	}
}
//4 创建一个Student类：sid sname sex score sage sdy(党员)
//通过一个文件：Student.txt作为数据库 来存储学生对象的信息：一行记录一个学生
//写方法：add(Student s);getOne(int sid);getAll();updateOne(Student s);deleteOne(int sid)
//分别实现 学生的添加、根据学号获取一个、获取所有、修改一个、根据学号删除一个
class Student{
	private Integer sid;
	private String sname;
	private String sex;
	private Float score;
	private Integer sage;
	private Boolean sdy;
	@Override
	public String toString() {
		return  sid + ":" + sname + ":" + sex + ":" + score + ":" + sage+ ":" + sdy ;
	}
	public Integer getSid() {
		return sid;
	}
	public void setSid(Integer sid) {
		this.sid = sid;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Float getScore() {
		return score;
	}
	public void setScore(Float score) {
		this.score = score;
	}
	public Integer getSage() {
		return sage;
	}
	public void setSage(Integer sage) {
		this.sage = sage;
	}
	public Boolean getSdy() {
		return sdy;
	}
	public void setSdy(Boolean sdy) {
		this.sdy = sdy;
	}
	public Student(Integer sid, String sname, String sex, Float score, Integer sage, Boolean sdy) {
		super();
		this.sid = sid;
		this.sname = sname;
		this.sex = sex;
		this.score = score;
		this.sage = sage;
		this.sdy = sdy;
	}
	public Student(String sname, String sex, Float score, Integer sage, Boolean sdy) {
		super();
		this.sname = sname;
		this.sex = sex;
		this.score = score;
		this.sage = sage;
		this.sdy = sdy;
	}
	public Student() {}
}

5.3 练习3

//1 写一个方法：把一个文本文件中的字符 分别存储到三个文件中：一个存储数字 一个存储字母 一个存储其他字符
public static void test01()throws Exception{
    //1 创建节点流 关联文件  创建高效流关联节点流
    BufferedReader bin=new BufferedReader(new FileReader("src/Test/Demo02.txt"));
    FileWriter outsz=new FileWriter("src/Test/Demo02_数字.txt");
    FileWriter outzm=new FileWriter("src/Test/Demo02_字母.txt");
    FileWriter outqt=new FileWriter("src/Test/Demo02_其他.txt");
    //2 选择读写方式
    String line;
    while((line=bin.readLine())!=null) {
        for (int i = 0; i < line.length(); i++) {
            char c=line.charAt(i);
            if(Character.isDigit(c)) {
                outsz.write(c);
                outsz.flush();
            }else if(Character.isLowerCase(c)||Character.isUpperCase(c)) {
                outzm.write(c);
                outzm.flush();
            }else {
                outqt.write(c);
                outqt.flush();
            }
        }
    }
    //3 关闭流
    bin.close();
    outqt.close();
    outzm.close();
    outsz.close();
}

5.4 练习4

//2 写一个方法：把一个文本文件中的字符进行更改：大写转化为小写 小写转化为大写 删除数字
//一个文件 不能同时关联两个流：
//创建一个新的文件  把转换后的字符串写道新文件中 删除原来的文件 对新文件重命名
public static void test02()throws Exception {
    //1 创建节点流 关联文件  创建高效流关联节点流
    File yuan=new File("src/Test/Demo02.txt");
    File muDi=new File("src/Test/Demo02_1.txt");
    BufferedReader bin=new BufferedReader(new FileReader(yuan));
    BufferedWriter bout=new BufferedWriter(new FileWriter(muDi));
    //2 选择读写方式
    String line;
    while((line=bin.readLine())!=null) {
        line=changeStr2(line);
        bout.write(line);
        bout.flush();
        bout.newLine();
        bout.flush();
    }
    //3 关闭流
    bin.close();
    bout.close();
    //4 删除源文件
    yuan.delete();
    //5 重命名新新文件
    muDi.renameTo(yuan);
}
private static String changeStr2(String str) {
    StringBuffer stb=new StringBuffer(str);
    for (int i = 0; i < stb.length(); i++) {
        char c=stb.charAt(i);
        if(Character.isLowerCase(c)) {
            stb.setCharAt(i,Character.toUpperCase(c));
        }else if(Character.isUpperCase(c)) {
            stb.setCharAt(i, Character.toLowerCase(c));
        }else if(Character.isDigit(c)) {
            stb.deleteCharAt(i);
            i--;
        }
    }
    return stb.toString();
}

6 PrintWriter

	 * PrintWriter:打印输出流
	 * 特点1：没有对应的输入流
	 * 特点2：可以作为节点流(关联的是文件) 还可以作为过滤流(关联其他流)  
	 * 
	 * 构造方法：
	 *    PrintWriter(File file) 
	 *    PrintWriter(String fileName) 
	 *    PrintWriter(OutputStream out) 
	 *    PrintWriter(OutputStream out, boolean autoFlush) 
	 *    PrintWriter(Writer out) 
	 *    PrintWriter(Writer out, boolean autoFlush) 
	 * 注意：如果autoFlush为true：：println、printf方法 会自动刷新
	 *    
	 *普通方法：
	 *     void close()  
	 *     void flush()  
	 *     void write(int c)  
	 *     void write(String s)  
	 *     void write(char[] buf)  
	 *特有方法：
	 *     void print(Object obj)  :::保持数据的原有状态 
	 *     void println(Object obj)

7 序列化

实体类

package day14_io;

import java.io.Serializable;
import java.util.UUID;

public class Teacher  implements Serializable {
	private Integer tid;
	private String tname;
	private float  tsalary;
	private char tsex;
	public Integer getTid() {
		return tid;
	}
	public void setTid(Integer tid) {
		this.tid = tid;
	}
	public String getTname() {
		return tname;
	}
	public void setTname(String tname) {
		this.tname = tname;
	}
	public float getTsalary() {
		return tsalary;
	}
	public void setTsalary(float tsalary) {
		this.tsalary = tsalary;
	}
	public char getTsex() {
		return tsex;
	}
	public void setTsex(char tsex) {
		this.tsex = tsex;
	}
	@Override
	public String toString() {
		return "Teacher [tid=" + tid + ", tname=" + tname + ", tsalary=" + tsalary + ", tsex=" + tsex + "]";
	}
	public Teacher(Integer tid, String tname, float tsalary, char tsex) {
		super();
		this.tid = tid;
		this.tname = tname;
		this.tsalary = tsalary;
		this.tsex = tsex;
	}
	public Teacher() {
		this.tname=UUID.randomUUID().toString().replace("-", "").substring(5, 11);
		this.tid=(int)(Math.random()*1000+1000);
		this.tsalary=(int)(Math.random()*30000+10000)/10.0f;
		this.tsex=Math.random()>0.5?'男':'女';
	}
	
}

功能实现

package day14_io;
....
public class Demo06ObjectStream {
	/*
	 * 序列化：实现对象信息在硬盘中的持久存储
	 * ObjectOutputStream:序列化流：把内存中对象的字节信息持久化保持到外部存储设备中
	 * ObjectInputStream:反序列化流：把外部存储设备中的字节信息 读到内存中 重构成对象
	 * 
	 * ObjectOutputStream：
	 *   构造方法：ObjectOutputStream(OutputStream out) 
	 *   普通方法：
	 *       void close()  
	 *       void flush()  
	 *       void writeObject(Object obj)  一次写一个对象：：
	 * ObjectInputStream：
	 * 构造方法：ObjectInputStream(InputStream in)     
	 * 普通方法： 
	 * 	     void close()  
	 *       Object readObject()  
	 *       
	 *       
	 * 注意1：序列化流和反序列化流操作的对象必须实现Serializable接口
	 * 注意2：反序列化流读到文件末尾：抛出异常EOFException
	 * */
	public static void main(String[] args)throws Exception{
		List<Teacher> list=new ArrayList<Teacher>();
//		for (int i = 0; i <10; i++) {
//			list.add(new Teacher());
//		}
//		testObjectOutputStream(list);//序列化
		list=testObjectInputStream();
		for (Teacher teacher : list) {
			System.out.println(teacher);
		}
		
		
	}
	//把参数list中的所有teacher 持久化保持到文件中
	public static void testObjectOutputStream(List<Teacher> list)throws Exception{
		 //1 创建节点流关联目的文件 创建序列化流关联节点流
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("src/day14_io/teacher.mm"));
		//2 选择写的方式
		for (Teacher teacher : list) {
			oos.writeObject(teacher);//NotSerializableException
			System.out.println(teacher);
		}
		//3 关闭流
		oos.close();
	}
	//通过反序列化流：读取文件中的信息到内存中 重构成对象
	public static List<Teacher> testObjectInputStream()throws Exception{
		 //1 创建节点流关联原文件 创建反序列化流关联节点流
		 ObjectInputStream ois=new ObjectInputStream(new FileInputStream("src/day14_io/teacher.mm"));
		 //2 选择读的方式：逐个对象的读写
		 List<Teacher> list=new ArrayList<>();
		 for (;true;) {
			 try {
				 Teacher t=(Teacher)ois.readObject();
				 list.add(t);
			 }catch(EOFException e) {
				 break;//读到EOFException说明到达文件末尾！
			 }
		}
		 //3 关闭流
		 ois.close();
		 return list;
	}
}