Java基础 IO流——第四部分

 

 

新博客地址：Temi

第一讲：IO流(对象的序列化)

一，对象序列化的概念：将堆内存中的对象存入硬盘，保留对象中的数据，称之为对象的持久化（或序列化）。

               ========被序列化对象必须实现 Serializable 接口，接口Serializable中没有方法，称之为标记接口===========

==============静态成员，和被transient 修饰的成员无法被序列化。静态成员属于类级别的，所以不能序列化这里的不能序列化的意思，是序列化信息中不包含这个静态成员域你这个测试成功，是因为你都在同一个机器（而且是同一个进程），因为你这个jvm已经把count加载进来了，所以你获取的是加载好的count，如果你是传到另一台机器或者你关掉程序重写写个程序读入test.obj，此时因为别的机器或新的进程是重新加载count的，所以count信息就是初始时的信息。====================

二，ObjectInputStream和ObjectOutputStream类的了解：

1. 1. ObjectOutputStream构造方法：public ObjectOutputStream(OutputStream out)  throws IOException
   2. ObjectInputStream  特有方法：public final Object  readObject()  throws IOException,  ClassNotFoundException            从 ObjectInputStream 读取对象。
   3. ObjectOutputStream 特有方法：public final void writeObject (Object obj)  throws IOException 将指定的对象写入 ObjectOutputStream。

三，序列化操作步骤：

1. 1. 被序列化对象实现Serializable接口。
   2. 确定类中的serialVersionUID。=========序列化运行时使用一个称为 serialVersionUID的版本号与每个可序列化类相关联，用于验证序列化对象的发送者和接收者是否为同一对象。如果接收者加载的该对象的类的 serialVersionUID与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为"serialVersionUID"的字段（该字段必须是静态 (static)、最终 (final)的 long 型字段）显式声明其自己的serialVersionUID=========
   3. 创建对象写入流，与文件关联。           ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:/obj.txt"));
   4. 通过写入writeObject(Object obj)方法，将对象作为参数传入，即可写入文件。oos.writeObject(obj);

四，代码练习：

 

import java.io.*;

public class ObjectStreamDemo {
        public static void main(String[] args) {
            //声明并实例化被序列化对象
            Person per = new Person("lisi",23,01,"ss");
            
            //序列化对象
            try {
                myObjectStream_Write(per);
            } catch (FileNotFoundException e) {
                System.out.println("文件没有找到"+e.toString());
            } catch (IOException e) {
                System.out.println("序列化发生错误！"+e.toString());
            }
            
            //接收读取的对象
            Person per2=null;
            
            //反序列化对象
            try {
                  per2 = (Person)myObjectStream_Reader();
            } catch (FileNotFoundException e) {
                 System.out.println("序列还文件不存在"+e.toString());
            } catch (ClassNotFoundException e) {
                System.out.println("类文件没有找到"+e.toString());
            } catch (IOException e) {
                System.out.println("读取发生错误"+e.toString());
            }
            
            System.out.println(per2);
        }
        
        
        //自定义序列化 方法，将对象序列化到硬盘上
        public static void myObjectStream_Write(Object obj) throws FileNotFoundException, IOException{
            
            //声明序列化输出流对像。并于文件相关联
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:/obj.txt"));
            
            //将对象序列化到硬盘上
            oos.writeObject(obj);
            
            //关闭流
            oos.close();
        }
        
        
        //自定义读取序列化对象方法
        public static Object myObjectStream_Reader() throws FileNotFoundException, IOException, ClassNotFoundException{
            
            //声明序列化输入流，并于文件关联
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:/obj.txt"));
            
            
            //读入被序列化的对象
            Object object = ois.readObject();
            
            //关闭流
            ois.close();
            
            return object;
            
        }
}

 

Person 类：

import java.io.Serializable;


//定义Person类实现Serializable接口，表明可以被序列化
public class Person implements Serializable{
       
    //定义serialVersionUID 表明版本号
    private static final long serialVersionUID = 1L;
    
    //定义类成员
    private String name;
    private int age;
    
    //transient修饰符修饰的成员不可以被序列化
    transient int id;
    
    //静态成员不可以被序列化
    static String country="aa";
    
    
    //定义构造方法
    public Person(String name,int age,int id,String country){
        this.name=name;
        this.age=age;
        this.id=id;
        this.country=country;
    }
    
    @Override
    public String toString(){
        return "name:"+name+"---"+"age:"+age+"----"+"id:"+id+"----"+"country"+country;
    }

}

 

 

第二讲：IO流(管道流)

一，管道流：PipedInputStream 和 PipedOutputStream  (输入输出可以直接进行连接，不用再借助数组或集合等容器进行临时存储。通过结合线程使用）

1. 1. public class PipedInputStream  extends InputStream      管道输入流应该连接到管道输出流；管道输入流提供要写入管道输出流的所有数据字节。
      1. 构造方法：public PipedInputStream()   创建尚未连接的 PipedInputStream。在使用前必须将其连接到 PipedOutputStream。
      2. 构造方法：public PipedInputStream(int pipeSize)  创建一个尚未连接的 PipedInputStream，并对管道缓冲区使用指定的管道大小。在使用前必须将其连接到 PipedOutputStream。
      3. 构造方法：public PipedInputStream(PipedOutputStream src,int pipeSize) throws IOException  创建一个 PipedInputStream，使其连接到管道输出流 src，并对管道缓冲区使用指定的管道大小。写入 src 的数据字节可用作此流的输入。
      4. 方法：public void connect(PipedOutputStream src) throws IOException    使此管道输入流连接到管道输出流 src。如果此对象已经连接到其他某个管道输出流，则抛出 IOException。
   2. public class PipedOutputStreamextends OutputStream     可以将管道输出流连接到管道输入流来创建通信管道。管道输出流是管道的发送端。
      1. 构造方法：public PipedOutputStream()       创建尚未连接到管道输入流的管道输出流。必须在使用之前将管道输出流连接到管道输入流（既可由接收者连接，也可由发送者连接）。
      2. 构造方法：public PipedOutputStream(PipedInputStream snk) throws IOException    创建连接到指定管道输入流的管道输出流。写入此流的数据字节稍后将用作 snk 的输入。
      3. 方法：public void connect(PipedInputStream snk)  throws IOException    将此管道输出流连接到接收者。如果此对象已经连接到其他某个管道输入流，则抛出 IOException。

二，操作步骤：

1. 1. 先创建一个读和写的两个类，实现Runnable接口，因为是两个不同的线程，覆盖run方法。========注：线程的异常要在内部处理=========
   2. 创建两个管道流，并用connect()方法将两个流连接。
   3. 将管道流绑定到线程。
   4. 创建线程并执行。

三，代码练习：

 

import java.io.*;

//定义一个类，实现启动一个线程，次线程包括一个读的管道刘
class Read implements Runnable{
    private PipedInputStream in;
    public Read(PipedInputStream in){
        this.in = in;
    }
    
    @Override
    
    //覆写方法
    public void run(){
        
           //接受输入数据
           byte buff[] = new byte[1024];
           
           
           //记录数据长度
           int len=0;
           
           
           //循环接受数据
           while(true){
               try{
                   
                   //尝试读取数据
                   len = in.read(buff);
                   
                   //判断是否结束
                   if("over".equals(new String(buff,0,len-2)))
                       break;
                   
                   //输出用户输入的内容
                   System.out.println("管道读取内容为："+new String(buff,0,len)+len);
               }catch(IOException e){
                   System.out.println("读取异常"+e.toString());
               }
           }
           
           //给出运行完毕提示
           System.out.println("运行完毕");
    }
}

//定义一个类，实现启动一个线程，此线程包括一个写的管道流
class Write implements Runnable{
    
    //声明管道流对象
    private PipedOutputStream out;
    
    //构造方法
    public Write(PipedOutputStream out){
        this.out = out;
    }
    
    @Override
    
    //覆写方法
    public void run(){
        
           //接受管道数据
           byte buff[] = new byte[1024];
           
           int len=0;
           
           
           //循环读取
           while(true){
               try{
                   len=System.in.read(buff);
                   
                   
                   //输出数据
                   out.write(buff, 0, len);
                   
                   //判断是否结束
                   if("over".equals(new String (buff,0,len-2)))
                       break;
               }catch(IOException e){
                   System.out.println("管道读取流发生异常"+e.toString());
               }
           }
           
           //给出结束提示
           System.out.println("运行完毕");
           
    }
}
public class PipedStreamDemo {
             public static void main(String[] args) {
                 
                        //创建 管道流对象作为参数
                        PipedInputStream pis = new PipedInputStream();
                        PipedOutputStream pos = null;
                        
                        //将管道流相连接
                        try {
                            pos = new PipedOutputStream(pis);
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        
                        //创建线程
                        Thread t1 = new Thread(new Read(pis));
                        Thread t2 = new Thread(new Write(pos));
                        
                        
                        //启动线程
                        t1.start();
                        t2.start();
            }
}

 

第三讲：IO流(RandomAccessFile)

一，RandomAccessFile 类的简单了解。

1. 1. 1. 类的声明：public class RandomAccessFileextends Object  implements DataOutput, DataInput, Closeable  此类的实例支持对随机访问文件的读取和写入。
      2. 类的说明：
         1. 该类不算是IO体系中的子类，而是直接继承Object，但是它是IO包成员，因为它具备读写功能，内部封装了一个数组，且通过getFilePointer方法获取指针位置，来对数组的元素进行操作，同时可通过seek方法改变指针的位置。
         2. 可以完成读写的原理：内部封装了字节输入流和输出流。
      3. 构造方法：public RandomAccessFile(File file, String mode) throws FileNotFoundException    创建从中读取和向其中写入（可选）的随机访问文件流，该文件由 File 参数指定。
      4. 构造方法：public RandomAccessFile(String name, String mode) throws FileNotFoundException   建从中读取和向其中写入（可选）的随机访问文件流 ====注：由构造方法可以看出该类只能操作文件。且操作文件包括模式=====
      5. 方法：public long length() throws IOException    按字节测量的此文件的长度。
      6. public void seek(long pos) throws IOException    设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。===注：可以向前和向后寻找====
      7. public int skipBytes(int n) throws IOException    尝试跳过输入的 n 个字节以丢弃跳过的字节。返回：跳过的实际字节数。===注：只可以往前跳不可以往后跳=====

=====注：关于读写模式的说明：如果模式为只读r，则不会创建文件，会去读一个已存在的文件，若文件不存在，则会出现异常。如果模式为读写rw，且该对象的构造函数要操作的文件不存在，会自动创建；如果存在，则不会覆盖。====

二，RandomAccessFile类的特点：

1. 1. 1. 同一个类既有读方法也有写方法。
      2. 只能操作文件。
      3. 可以实现对文件的随机读写。

三，代码练习：

package com.examp.ch18;
//需求：使用RandomAccessFileDemo进行读写操作

import java.io.*;
public class RandomAccessFileDemo {
    
    public static void main(String[] args)throws IOException {
        
        //创建文件对象
        File file =new File("E:/test.txt");

        //写数据
        writeFile(file);

        //读数据
        readFile(file);

    }

    //读取指定文件中的数据
    public static void readFile(File file)throws IOException{
        
        
        //创建随机读写对象，指定文件打开方式为只读
        RandomAccessFile raf=new RandomAccessFile(file,"r");
        
        //设置指针位置
        raf.seek(8);

        //读取四个字节存入
        byte[] by=new byte[4];
        
        
        //读数据
        raf.read(by);
        
        
        //将存入数据的字节数组转换为字符串
        String name=new String(by);
        
        
        //读取年龄
        int age=raf.readInt();
        
        System.out.println("name="+name+"age="+age);

        //关闭流对象
        raf.close();
    }

    //创建方法将数据写入指定文件中
    public static void writeFile(File file)throws IOException{
        
        //创建对象，文件打开方式为读写
        RandomAccessFile raf=new RandomAccessFile(file,"rw");
        
        //写入姓名
        raf.write("张三".getBytes());
        
        
        //写入年龄，这里调用了写一个int方法
        raf.writeInt(23);

        raf.write("李四".getBytes());
        raf.writeInt(100);
      
        //改变指针位置,改变第一个对象的值
        raf.seek(8*0);
        raf.write("小三".getBytes());
        raf.writeInt(3);

        
        //改变指针位置
        raf.skipBytes(8*2);
        raf.write("王五".getBytes());
        raf.writeInt(5);

        //关闭流
        raf.close();    
    }
}

 

 

第四讲：IO流(操作基本数据类型的流对象DataStream)

一，ByteArrayInputStream和ByteArrayOutputStream 类的简单了解：

1. 1. 1. ByteArrayInputStream 在构造时，需要接受数据源。。而且数据源是一个字节数组。
      2. ByteArrayOutputStream 在构造时，不需要指定数据源，因为在其内部已经封装的可变长度的字节数组。
      3. 这两个流对象操作的都是数组，没有使用系统资源，所以不需要关闭。
      4. 基本思想：用流的思想操作数组。
      5. ByteArrayOutputStream  方法：public void writeTo(OutputStream out)  throws IOException         将此 byte 数组输出流的全部内容写入到指定的输出流参数中。==注：此方法抛出异常。===

二，对应的字符操作类：CharArrayReader和CharArrayWriter

        对应的字符串操作类： StringReader和StringWriter

三，代码练习：

import java.io.*;

public class ByteArrayInputStreamDemo {
           public static void main(String[] args) {
               
               //定义字节操作输入流，源为一个字符串的字节数组形式
               ByteArrayInputStream bais=new ByteArrayInputStream("abcdef".getBytes());
               
               //定义字节操作输出流
               ByteArrayOutputStream baos=new ByteArrayOutputStream();
               
               //接受读入的内容
               int by=0;
               
               //循环读取写入内容
               while((by = bais.read())!=-1){
                   baos.write(by);
               }
               
               //输出字节操作流写入的内容
               System.out.println(baos.toString());
        }
}

 

第五讲：IO流(ByteArrayStream)

 

 

第六讲：IO流(转换流的字符编码)

一，字符概述：

1. 1. Java IO 操作中可以加入字符编码表的四个对象：
      1. 转换流：InuputStreamReader和OutputStreamWriter。
      2. 打印流：PrintStream和PrintWriter    =====注：只有输出流=====

二，编码表的由来：计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。这就是编码表。

1. 常见的编码表：ASCII：美国标准信息交换码表。用一个字节的7位表示
2. IOS8859-1：拉丁码表；欧洲码表。用一个字节的8位表示。====注：打头为 1======
3. GB2312：中国的中文编码表（早期）两个字节表示一个字符（6-7千字符）。====注：打头的是两个高位为1的两个字节编码。===
4. GBK：中国的中文编码表升级，融合了更多的中文文字字符。（两万字符左右）。====注：打头的是两个高位为1的两个字节编码。===
5. Unicode：国际标准码，融合了多种文字。所有文字都用两个字节来表示,Java语言使用的就是unicode。

6. UTF-8：最多用三个字节表示一个字符的编码表，根据字符所占内存空间不同，分别用一个、两个、三个字节来编码。

   1. UTF-8编码格式：一个字节：0开头。
   2.  两个字节：字节一  ---> 110    位数：10 ~ 6 。字节二  ---> 10     位数：5 ~ 0。
   3. 三个字节：字节一  ---> 110    位数：15 ~ 12。 字节二  ---> 10     位数：11 ~ 6。 字节三 ---> 10     位数：5 ~ 0。

 

三，代码练习：

import java.io.*;


public class EncodingStream {
             public static void main(String[] args) {
                 
                 //分别创建两个文件对象，用来存储两种编码格式的数据
                 File file_GBK = new File("E:/gbk.txt");
                 File file_UTF = new File("E:/utf.txt");
                 
                 //分别按照两种编码格式写入数据
                 try {
                    writeText_GBK(file_GBK);
                    writeText_UTF(file_UTF);
                } catch (IOException e) {
                    System.out.println("写入文件发生异常"+e.toString());
                }
                 
                 
                 //按照两种编码格式分别读取两个文件
                 try {
                     
                     //正常
                     System.out.println("正常：");
                    readText_GBK(file_GBK);
                    //乱码
                    System.out.println("乱码");
                    readText_GBK(file_UTF);
                    //正常
                    System.out.println("正常：");
                    readText_UTF(file_UTF);
                    //乱码
                    System.out.println("乱码");
                    readText_UTF(file_GBK);
                } catch (IOException e) {
                    System.out.println("读入文件发生错误"+e.toString());
                }
                 
            }
             
             
             //定义方法将数据按GBK编码写入文件
             public static void writeText_GBK(File file) throws IOException{
                 
                    //创建输出字符流，使用指定的文件，以及编码
                    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file),"gbk");
                    
                    
                    //写入内容
                    osw.write("黑马训练营");
                    
                    //刷新流
                    osw.flush();
                    //关闭流
                    osw.close();
             }
             
             
             //定义方法，将数据按照GBK编码从文件中读入
             public static void readText_GBK(File file) throws IOException{
                 
                    //创建文件读取字符流，使用指定的编码，以及文件
                    InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"gbk");
                    
                    //接受读入的字符
                    char ch[] = new char[1024];
                    
                    //标记读入的字符数
                    int  len=0;
                    
                    //循环读取打印
                    while((len=isr.read(ch))!=-1){
                        System.out.println(new String(ch,0,len));
                    }
                    //关闭流操作
                    isr.close();
             }
             
             
             //定义方法，将数据按照UTF-8编码写入指定的文件
             public static void writeText_UTF(File file) throws IOException{
                 
                    //创建输出字符流，使用指定的文件，以及编码
                    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file),"UTF-8");
                    
                    //写出数据
                    osw.write("黑马训练营");
                    
                    osw.flush();
                    
                    osw.close();
             }
             
             
             //定义方法，将数据按照UTF-8编码从指定文件读入
             public static void readText_UTF(File file)throws IOException{
                    //创建文件读取字符流，使用指定的编码，以及文件
                    InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"UTF-8");
                    
                    //定义数组接受字符
                    char ch[] = new char[1024];
                    
                    //标记
                    int len=0;
                    
                    //循环读取
                    while((len=isr.read(ch))!=-1){
                        System.out.println(new String(ch,0,len));
                    }
                    
                    isr.close();
             }
}

 

 

第七讲：字符编码

一，编码和解码：

1. 1. 编码：字符串变成字节数组       String  --->  byte[]  ：srt.getBytes(charsetName)
   2. 解码：字节数组变成字符串         byte[]   --->  String ：newString(byte[],charsetName)

二，编码和解码的字符集转换注意事项：

1. 1. 1. 如果编码失败，解码就没意义了。
      2. 如果编码成功，解码出来的是乱码，，则需对乱码通过再次编码（用解错码的编码表），然后再通过正确的编码表解码。针对于IOS8859-1是通用的。
      3. 如果用的是GBK编码，UTF-8解码，此时通过再次编码后解码的方式，就不能成功了，因为UTF-8也支持中文，在UTF-8解的时候，会将对应的字节数改变，所以不会成功。

 

三，代码练习：

import java.util.Arrays;

public class EncodingDemo {
            public static void main(String args[]) throws Exception{
                
                //创建一个字符串
                String s="您好";
                //获得字符串的GBK 码表
                byte[] b1 = s.getBytes("gbk");
                //输出码表
                System.out.println(Arrays.toString(b1));
                //重新编码
                String s1 = new String(b1,"gbk");
                
                System.out.println("s1="+s1);
                
                //获取字符串的ISO8859-1码表
                byte[] b2 = s1.getBytes("ISO8859-1");
                //输出码表
                System.out.println(Arrays.toString(b2));
                //重新编码
                String s2 = new String (b2,"gbk");
                
                System.out.println(s2);
            }
}

 

第八讲：字符编码-联通

一，对于中文的”联通“，这两个字比较特别，它的二进制位正好是和在UTF-8中两个字节打头的相同，所以在文本文件中，如果单独写“联通”或者和满足UTF-8编码格式的字符一起保存时，记事本就会用UTF-8来进行解码动作，这样显示的就会是乱码。

    解决办法：在联通前面加上任意中文字符。

二，代码练习:

 

import java.io.UnsupportedEncodingException;

public class LianTongDemo {
            public static void main(String[] args) throws UnsupportedEncodingException {
                   String s = "联通";
                   
                   byte[] bytes = s.getBytes("gbk");
                   
                   for(byte b : bytes){
                       System.out.println(Integer.toBinaryString(b&255));
                   }
            }
}

 

第九讲：练习

一，需求分析:

                  有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括姓名，三门课成绩输入的格式：如：张三，30,40,60计算出总成绩，并把学生的信息和计算出的总分数由高低顺序存放在磁盘文件“stuinfo.txt”中

二，思路：

1. 1. 描述对象
   2. 定义一个可操作学生对象的工具类。 
   3. 通过获取键盘录入一行数据，并将该行中的信息取出封装成学生对象。
   4. 因为学生有很多，那么就需要存储，使用到集合。因为要对学生的总分排序。所以可以使用TreeSet。
   5. 将集合的信息写入到一个文件中。

三，代码练习：

 

import java.io.*;
import java.util.*;


//学生类实现Comparable接口
class Student implements Comparable<Student>{
    private String name;
    private int sx,yy,yw,sum;
    Student(String name,int sx,int yw,int yy){
        this.name=name;
        this.sx=sx;
        this.yw=yw;
        this.yy=yy;
        sum=sx+yw+yw;
    }

    //获取总成绩
    public int getSum(){
        return sum;
    }

    //获取姓名
    public String getName()
    {
        return name;
    }

    //复写compareTo方法
    public int compareTo(Student s)    {
        
        int num=new Integer(this.sum).compareTo(new Integer(s.sum));
        if(num==0)
            return this.name.compareTo(s.name);
        return num;
    }
    
    //复写hashCode
    public int hashCode(){
        
        return name.hashCode()+sum*33;
    }

    //复写equals
    public boolean equals(Object obj){
        
        if(!(obj instanceof Student))
            throw new ClassCastException("类型不匹配");
        Student s=(Student)obj;
        return this.name.equals(s.name)&&this.sum==s.sum;
    }

    
    //复写toString
    public String toString(){
        return "Student["+name+","+sx+","+yw+","+yw+"]";
    }
}

//学生工具类
class StudentTools{
    //从键盘读取学生信息方法,以学生自身排序方式存入集合中
    public static Set<Student> getStudentInfo_1()throws IOException
    {
         return getStudentInfo_2(null);
    }

    //从键盘读取学生信息方法，以比较器排序方式存入集合中
    public static Set<Student> getStudentInfo_2(Comparator<Student> cmp)throws IOException
    {
        //键盘录入
        BufferedReader bis=
            new BufferedReader(new InputStreamReader(System.in));
        String info=null;

        //定义一个集合，用来存储学生对象
        Set<Student> set=null;//---------
        if(cmp==null)
            set=new TreeSet<Student>();
        else
            set=new TreeSet<Student>(cmp);

        //读取数据
        while((info=bis.readLine())!=null)
        {

            if("over".equals(info)) 
                break;

            String[] in=info.split(",");
            //将学生对象存入集合中
            set.add(new Student(in[0],Integer.parseInt(in[1]),
                                    Integer.parseInt(in[2]),
                                    Integer.parseInt(in[3])));
        }
        bis.close();//关流

        return set;
    }

    //把学生信息按照指定属性写入指定文件中
    public static void writeToFile(Set<Student> set,File file)throws IOException
    {
        //关联文件
        BufferedWriter bw=new BufferedWriter(new FileWriter(file));

        //遍历
        for (Student stu : set)
        {
            //将学生信息写入指定文件中
            bw.write(stu.toString()+"\t");
            bw.write(stu.getSum()+"");
            bw.newLine(); 
            bw.flush();
        
        }
        
        bw.close();//关流
    }
}


public class  StudentInfoTest
{
    public static void main(String[] args) 
    {
        //定义一个翻转自身比较性的比较器
        Comparator<Student> cmp=Collections.reverseOrder();
        try
        {
            //指定文件
            File file =new File("stdinfo.txt");
    
            //调用学生工具类的获取信息方法，将信息存入集合中
            Set<Student> set=StudentTools.getStudentInfo_2(cmp);


            //将学生信息写入指定文件中
            StudentTools.writeToFile(set,file);
        }
        catch (IOException e)
        {
            throw new RuntimeException("学生信息获取写入失败");
        }    
    }
}