java IO流补充

心已赠人 2022-11-25 10:02 116阅读 0赞

## 异常 ##

**所有异常类的父类是Throwable类**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70]

已知直接子类：  
Error ，Exception  
程序的异常:**Throwable**  
严重问题:Error 我们不处理 这种问题一般都是很严谨的，比如说内存溢出  
问题:Exception  
编译时异常(**checked检查型异常**)：不是RuntimeException的异常，必须处理，不处理，编译不能通过  
小结：检查型异常一般在 编译期 就会被检查到，所以我们肯定会提前在方法内进行捕获处理，或者在方法头部申明并抛出  
运行异常（**Unchecked非检查型异常**）:RuntimeException 这个问题是我们代码不够严谨造成的  
注意：非检查型异常，往往无法提前预知，例如被除数是0、空指针等  
如果程序出了问题 我们不做任何处理 最终jvm会默认处理。将异常的名称、原因及出现的问题等信息输出控制台  
**异常处理要求**：  
如果可以正确处理异常，则应将其捕获并处理，否则应将其抛出

## File类 ##

File类是java. io包中的非流类，它以系统无关的方式描述文件对象的属性。File类只操作文件在磁盘上的属性，而**读写文件内容的功能则需要流类提供**  
File:文件和目录（文件夹）路径名的抽象表示形式  
File(File parent, String child)  
根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。  
File(String pathname)  
通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。  
File(String parent, String child)  
根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

//根据路径得到File对象
    	File file = new File("D:\\图书\\java.text");
    //根据一个目录和一个子文件得到File对象
    	File file1 = new File("D:\\图书","java.text");
    //根据一个父File对象和一个子文件得到File对象
    	File file2 = new File("D:\\图书");
    	File file3 = new File(file2,"java.text");

创建文件  
boolean mkdir()  
创建此抽象路径名指定的目录。  
boolean createNewFile()  
当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。

//在D盘目录下创建一个文件夹(存在这样的文件夹就不创建了)
    File file = new File("D:\\学习java");
    System.out.println("mkdir:"+file.mkdir());//mkdir:true
    //在D盘目录学习java下创建一个javatt.text这个文件(存在这样的文件就不创建了)
    File file2 = new File(file,"javatt.text");
    System.out.println("createNewFile:"+file2.createNewFile());

boolean mkdirs()  
创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。

//创建多级目录（创建多个文件夹）D:\\不学java了\\ranren
    	File file= new File("D:\\不学java了");
    	file.mkdir();
    	File file2 = new File("D:\\不学java了\\ranren");
    	System.out.println("创建多级目录："+file2.mkdir());
    	System.out.println("--------------");
    	File file3 = new  File("D:\\好无聊\\aa.text\\b.mp3");
    	System.out.println("创建多级目录："+file3.mkdirs());

注：如果创建文件夹或文件忘记盘符路径 默认在当前项目下  
java中的删除不经过回收站

File file = new File("a.text");
    	file.createNewFile();
    	System.out.println("删除："+file.delete());
    	File file2 = new File("111\\222\\333");
    	file2.mkdirs();
    	System.out.println("删除："+file2.delete());//111\\222
    File file3 = new File("111\\222");
    	File file4 = new File("111");
    	System.out.println("删除："+file3.delete());
    	System.out.println("删除："+file4.delete())；

获取功能

File file3 =new File("aaa\\a.text");
    	System.out.println("getAbsolutePath:"+file3.getAbsolutePath());//获取		绝对路径
    	System.out.println("getPath:"+file3.getPath());//获取相对路径
    	System.out.println("length:"+file3.length());//获取字节大小
    	System.out.println("getName:"+file3.getName());//获取名称
    	
    System.out.println("getName:"+file3.lastModified());//表示的文件最后一次被修改的时间。
    Date date = new Date(1596797423555L);
    SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String format = sd.format(date);
    System.out.println(format);

String\[\] list()  
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。  
File\[\] listFiles()  
返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

File f = new File("C:\\");
    String[] list = f.list();
    for(String s:list) {
    	System.out.println(s);
    }
    System.out.println("------------");
    File[] listFiles = f.listFiles();
    for(File f1:listFiles) {
    	System.out.println(f1.getName());
    	}

## IO流分类 ##

按照数据流向:  
输入流：读入数据  
输出流：写出数据  
**按照数据类型：  
字节流  
字节输入流 InputStream  
字节输出流 OutputStream  
字符流  
字符输入流 Reader  
字符输出流 Writer**  
什么情况下使用哪种流呢？  
如果数据所在文件可以通过系统自带的记事本打开并读懂其内容 就用字符流，其他用字节流  
如果什么不知道 ，就用字节流  
通过查看api 发现该流对象是一个抽象类 不能实例化  
FileOutputStream(File file)  
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。  
FileOutputStream(String name)  
创建一个向具有指定名称的文件中写入数据的输出文件流。

//File file = new File("a.text");
    //FileOutputStream fos = new FileOutputStream(file);

创建字节输出流对象时：调用了系统功能去创建文件 创建了fos1对象 把fos1对象指向了这个文件
    		FileOutputStream fos1 = new FileOutputStream("a.text");
    	fos1.write("hello,IO流".getBytes());
    	fos1.close();

为什么一定要close()  
让对象流变成垃圾，这样就可以被垃圾回收器回收了  
通知系统去释放跟该文件相关资源。  
如何实现数据的追加写出

FileOutputStream fos2=new FileOutputStream("b.text",true);
    	for(int i=0;i<10;i++) {
    	fos2.write(("hello"+i).getBytes());
    	fos2.write("\r\n".getBytes());
    	}
    		fos2.close();
    ``

FileInputStream(File file)  
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。  
FileInputStream(String name)  
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定

FileInputStream fis = new FileInputStream("a.text");//自己要创建一个文件
    //		int fre= fis.read();
    //		while(fre!=-1) {
    //			System.out.print((char)fre);
    //			fre=fis.read();
    //		}
    //		fis.close();
    		//读 赋 判
    		int a=0;
    		while((a=fis.read())!=-1) {
    			System.out.print((char)a);//有中文不行
    		}
    		fis.close();

FileInputStream fis = new FileInputStream("e.text");
    	//数组的长度一般是1024或者1024的整数倍
    	byte[] b= new byte[1024];
    	int len= 0;
    	while((len=fis.read(b))!=-1) {
    		System.out.print(new String(b,0,len));
    	}
    	fis.close();

**用缓冲区类读写数据（高效的输入输出流）**  
**写**入数据：BufferedOutStream  
//写文件 是输出流,这里用字节缓冲输出流(BufferedOutputStream这里用了BufferedOutputStream**会自动给我们创建文件**)  
**读**出数据：BufferedInputStream  
//读文件 输入流,这里用了字节缓冲输入流(这里用了BufferedInputStream**不会自动给我们创建文件**)  
BufferedOutputStream(OutputStream out)  
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

// 创建字节输出流FileOutputStream对象并指定文件路径。
     //	FileOutputStream fos = new FileOutputStream("f.text");
    //	BufferedOutputStream bos1 = new BufferedOutputStream(fos);
    // 利用字节输出流创建高效字节输出流对象
    	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("f.text"));
    	// 调用高效字节输出流对象的write(byte[] buff)方法写出一个字节数组
    	bos.write("测试".getBytes());
    	bos.close();

BufferedInputStream(InputStream in)  
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("c.text"));//读在已经存在的文件下读取数据
    //	int a= 0;
    //	while((a=bis.read())!=-1) {
    //		System.out.print((char)a);
    //	}
    	//一次读取一个字节数组
    	byte[] b = new byte[1024];
    	int len=0;
    	while((len=bis.read(b))!=-1) {
    		System.out.print(bis.read(b, 0, len));
    	}
    	bis.close();.

下面是**字符流**  
字符输出流：OutputStreamWriter **写入数据**  
字符输入流：InputStreamReade**r读出数据**  
写入数据

OutputStreamWriter ost = new OutputStreamWriter(new FileOutputStream("k.text"));
    ost.write('a');
    ost.write(97);
    ost.write("学习java");
    
    char[] cbuf = {'a','b','c','d','e'};
    ost.write(cbuf);
    ost.write(cbuf, 2, 2);
    
    String str="学习java";
    ost.write(str, 2, 4);
    
    ost.flush();
    ost.close();

读出数据

InputStreamReader isr = new InputStreamReader(new FileInputStream("k.text"));
    //	int a =0;
    //	while((a=isr.read())!=-1) {
    //		System.out.print((char)a);
    //	}
    	//一次读取一个字符数组
    	char[] cbuf=new char[1024];
    	int a=0;
    	while((a=isr.read(cbuf))!=-1) {
    		System.out.print(new String(cbuf,0,a));
    	}
    	isr.close();

**将D盘下的e.text文件复制到D盘下的f.text**

public static void main(String[] args) throws IOException {
            //读出D:e.text的数据
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D://e.text"));
    
            //将读出的数据写入到D:f.text
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D://f.text"));
            int a =0;
            byte[] b = new byte[1024];
            while((a=bis.read(b))!=-1){
    
                bos.write(b,0,a);
            }
    
            bis.close();
            bos.close();
        }

**用带缓冲区的字符流类读写数据**  
写入数据：BufferedWriter  
读出数据：BufferedReader

//	BufferedWriter  bw = new BufferedWriter(
    //			new OutputStreamWriter
    //			(new FileOutputStream("m.text")));
    BufferedWriter bw = new BufferedWriter(new FileWriter("m.text"));
    //	bw.write("hello");
    //	bw.newLine();
    //	bw.write("world");
    //	bw.close();
    //	
    	BufferedReader br =new BufferedReader(
    			new InputStreamReader(
    					new FileInputStream("m.text")));
    //BufferedReader br = new BufferedReader(new FileReader("m.text"));
    //	int a=0;
    //	while((a=br.read())!=-1) {
    //		System.out.print((char)a);
    //	}
    	char[] cbuf=new char[1024];
    	int a=0;
    	while((a=br.read(cbuf))!=-1) {
    		System.out.print(new String(cbuf,0,a));
    	}
    	br.close();
    System.out.println("-------------------------");
    BufferedReader bd = new BufferedReader(new FileReader("D:\\项目实战\\缓冲流测试.txt"));
    	BufferedWriter bw =new BufferedWriter(new FileWriter("D:\\项目实战\\测试io流\\字符缓冲流测试数据.txt"));
    	String c;
    	//int count=0;
    	int line=1;
    	while((c=bd.readLine()) != null) {
    		/* System.out.println(c); */
    		//count++;
    		bw.write((line++)+"、"+c);
    		bw.newLine();//通用换行符
    
    	}
    	//System.out.println(count);
    	bd.close();
    	bw.close();

**高效字符流和集合的综合使用**  
1. 在项目根目录下新建一个文件：data.txt,键盘录入3个字符串验证码，并存入data.txt中，要求一个验证码占一行；  
2. 键盘录入一个需要被校验的验证码，如果输入的验证码在data.txt中存在：在控制台提示验证成功，如果不存在控制台提示验证失败

public static void main(String[] args) throws IOException {
            //键盘录入3个字符串并写入项目根路径下的data.txt文件中,要求一个验证码占一行
           // writeData();
            //验证码验证
            verifyCode();
        }
    
        private static void verifyCode() throws IOException {
            //将数据读出来保存到集合里面去
            List<String> list = new ArrayList<String>();
            BufferedReader bufferedReader = new BufferedReader(new FileReader("data.txt"));
    
            *String line = null;
            //循环读取每一行
            while(null!=(line = bufferedReader.readLine())) {
                System.out.println(line);
                list.add(line);
            }*
            System.out.println("请输入一个验证码");
            Scanner scanner = new Scanner(System.in);
           String s =  scanner.nextLine();
           if(list.contains(s)){
               System.out.println("验证码实现成功");
           }else{
               System.out.println("验证码实现失败");
           }
    
            bufferedReader.close();
    
        }
    
        private static void writeData() throws IOException {
            Scanner scanner = new Scanner(System.in);
            //将数据写入data.txt(OutputStreamWriter)
            Writer os = new FileWriter("data.txt");
            //这里data.txt里的数据
            //a8j9
    		//23ba
    		//j8ai
            BufferedWriter osw = new BufferedWriter(os);
            for(int i=0;i<3;i++){
                System.out.println("第"+(i+1)+"行字符串");
                String s = scanner.nextLine();
                osw.write(s);
                osw.newLine();
            }
    
            osw.close();
        }
    a8j9
    23ba
    j8ai
    请输入一个验证码
    23ba
    验证码实现成功

## 转化流 ##

**转化输入流**：InputStreamReader**读出数据**  
**转化输出流**:OutputStreamWriter**写入数据**  
OutputStreamWriter(OutputStream out, Charset cs)  
创建使用给定字符集的 OutputStreamWriter。  
InputStreamReader(InputStream in, Charset cs)  
创建使用给定字符集的 InputStreamReader。

//	OutputStreamWriter os= new OutputStreamWriter(
    //	new FileOutputStream("g.text"), "GBK");
    //	os.write("你好！");
    //	os.close();
    	
    //	InputStreamReader is = new InputStreamReader(
    //			new FileInputStream("g.text"), "UTF-8");//��ã�
    	InputStreamReader is = new InputStreamReader(
    			new FileInputStream("g.text"), "GBK");//你好
    //        int a=0;
    //        while((a=isr.read())!=-1){
    //            System.out.print((char)a);
    //        }
    
           char[] b = new char[1024];
            int a = 0;
            while((a=isr.read(b))!=-1){
                System.out.println(new String(b,0,a));
            }

## 对象流 ##

序列化流：ObjectOutputStream(对象—流数据)  
反序列流：ObjectInputStream（流数据—对象）  
(1)序列化： 将数据结构或对象转换成二进制串的过程  
2）反序列化：将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程  
3）在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存  
4）也可能需要把对象通过互联网络传递到千里之外的其他计算机内存中去  
5）**当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送**  
6）互联通讯的双方需要采用约定的协议，序列化和反序列化属于通讯协议的一部分  
学生类

*  java.io.NotSerializableException:
 *  java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。

public class Student implements Serializable{
    /**每次修改java文件的内容时候 class文件的id值都会改变
    	 * 只要让它的id值固定就行
    	 * 
    	 */
    	private static final long serialVersionUID = 4790571015701387250L;
    	private String name;
    	private *transien*t int age;//让成员变量不被序列化
    	public Student(String name, int age) {
    		super();
    		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 [getName()=" + getName() + ", getAge()=" + getAge() + "]";
    	}

public static void main(String[] args) throws IOException, ClassNotFoundException {
    	//wrtite();
    	read();
    }
    private static void read() throws IOException, ClassNotFoundException{
    	// TODO Auto-generated method stub
    	ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.text"));
    	
    			Object readObject = ois.readObject();
    			System.out.println(readObject);
    			ois.close();
    	
    }
    
    private static void wrtite() throws IOException {
    	// TODO Auto-generated method stub
    	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.text"));
    	Student s=new Student("王五",20);
    	oos.writeObject(s);
    	oos.close();
    }

**什么情况下需要序列化**  
当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；  
当你想用套接字在网络上传送对象的时候；  
当你想通过RMI传输对象的时候

**transient 修饰的属性，是不会被序列化的**  
静**态static的属性，他不序列化**  
注意：**看到类实现了序列化接口的时候 ，可以自动产生一个序列id的值，而且产生这个值以后，我们对类进行任何改动 它读取以前的数据是没有问题的**  
serialVersionUID 的值到底怎么设置才可以。  
不同的serialVersionUID的值，会影响到反序列化，也就是数据的读取  
序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。  
如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 “serialVersionUID” 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID：  
如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，强烈建议 所有可序列化类都显式声明 serialVersionUID 值，原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException

## java.util.zip的认识 ##

zip:压缩包  
提供一个压缩包解压的功能和文件压缩成压缩包的功能  
**java.util.zip.ZipEntry**  
1、获取压缩包的文件名  
public String getName()返回条目的名称。  
2、public long getSize()返回条目数据的未压缩大小。  
3、public long getTime()返回条目的最后修改时间。

import java.io.*;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.zip.ZipEntry;
    import java.util.zip.ZipInputStream;
    public class ZipDemo3 {
        /**
         * 获取压缩包里的每个文件的名称
         */
        public static void main(String[] args) throws IOException {
            ZipInputStream zipInputStream = new  ZipInputStream (
                    new BufferedInputStream(new FileInputStream("D:\\作业提交\\yasuo1212_03.zip")));
    
            //获取压缩包里面的文件名
           ZipEntry zipEntry =  zipInputStream.getNextEntry();
           while(zipEntry!=null){
                System.out.println("压缩包里面文件名称"+zipEntry.getName());
               System.out.println("压缩包里面文件的大小"+zipEntry.getSize());//-1
               long time = zipEntry.getTime();//1605250736000
               SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
               System.out.println("压缩包最后修改时间"+sdf.format(new Date(time)));
                zipEntry=zipInputStream.getNextEntry();//赋值之后要及时更新zipEntry，不然死循环
           }
    
        }
    }

## 指定文件夹下的所有文件压缩成zip包 ##

1、要实现文件夹下的文件压缩。需要知道**待压缩文件夹存放的位置（路径）**，**压缩后文件夹的位置（路径）**，**以及压缩后重命名**

/**
     * 将指定的文件夹下的文件压缩
     */
    public class ZipDemo {
        public static void main(String[] args) throws IOException {
            String oldPath = "D:\\作业提交\\项目代码实践\\压缩测试使用";
            String newPath ="D:\\作业提交";
            String fileName ="yasuo1212_03";
            if(test(oldPath,newPath,fileName)){
                System.out.println("压缩成功");
            }else{
                System.out.println("压缩失败");
            }
        }
    
        private static boolean test(String oldPath,String newPath,String fileName) throws IOException {
            //判断文件路径是否有文件夹存在
            File file = new File(oldPath);
            if(!(file.exists())){
                System.out.println("待压缩的文件夹不存在");//没有就创建文件夹,(后续 。。还要创建文件)这里直接从电脑路径copy，所有直接有了
            }else{
                System.out.println("文件夹存在");
                //文件压缩后的。。.zip格式(例如D:\制作网页\AdobeDreamweaverCS6.zip)
    
                File zipFile = new File(newPath+"/"+fileName+".zip");
                if(zipFile.exists()){
                    System.out.println("压缩后的文件夹已经存在");
                }else{
                    //开始压缩前判断文件夹是否有文件
                    File[] files = file.listFiles();
                    //如果没有就不压缩
                    if(files==null||files.length<1){
                        System.out.println("带压缩的文件夹里面没有文件,不需要压缩");
                        return false;
                    }
                    //开始压缩
                    FileOutputStream fos = new FileOutputStream(zipFile);
                    ZipOutputStream zipOutputStream = new ZipOutputStream(new BufferedOutputStream(fos));
                    byte[] bytes = new byte[1024*1024];
                    for(int i=0;i<files.length;i++){
                        ZipEntry zipEntry=new ZipEntry(files[i].getName());
                        zipOutputStream.putNextEntry(zipEntry);
                        //把待压缩的文件并写入压缩包里
                        FileInputStream fileInputStream = new FileInputStream(files[i]);
                        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream,1024*1024);
                        int read =0;
                        while ((read=bufferedInputStream.read(bytes,0,1024*1024))!=-1){
                            zipOutputStream.write(bytes,0,read);
                        }
                        bufferedInputStream.close();
                        fileInputStream.close();
                    }
    
                    zipOutputStream.close();
                    fos.close();
                    return true;
    
                }
    
            }
    
                return false;
        }
    }

## 将压缩包里面的文件解压出来 ##

import java.io.*;
    import java.util.zip.ZipEntry;
    import java.util.zip.ZipInputStream;
    public class ZipDemo1 {
    
        public static void main(String[] args) {
            test();
        }
    
        private static void test() {
            try {
                File zipFile = new File("D:\\作业提交\\yasuo1212_03.zip");
                ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFile));
                ZipEntry zipEntry = null;
                while((zipEntry = zis.getNextEntry()) != null) {
                    //System.out.println("zipEntry.getName:" + zipEntry.getName());
                    int index = zipEntry.getName().lastIndexOf("/");
                    String newFileName = zipEntry.getName().substring(index == -1?0:index+1);//去掉压缩包里的文件夹，这里只要文件名
    //                File newFile = new File("D:\\解压之后的测试"+newFileName);
    //                FileOutputStream fos = new FileOutputStream(newFile);//这放在项目目录下了
                    FileOutputStream fos= new FileOutputStream(new String("D:\\解压之后的测试"+newFileName));//存放在自己盘中
                    int len = 0;
                    byte[] b = new byte[1024];
                    while((len = zis.read(b)) > 0) {
                        fos.write(b, 0, len);
                        fos.flush();
                    }
                    fos.close();
                }
                zis.closeEntry();
                zis.close();
                System.out.println("解压完成。");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    
    }

## 优雅的关闭流的方式 ##

**try-with-resource**  
public abstract class Reader implements Readable, Closeable  
public interface Closeable extends AutoCloseable

try(
                    FileReader fr = new FileReader("D:\\idea代码");
                    BufferedReader br = new BufferedReader(fr)
            ){
                String s = "";
                while((s = br.readLine()) != null){
                    System.out.println(s);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70]: /images/20221124/474b1aeb0ec642a8bd487c20d5917f6d.png