JavaSE笔记20：IO流（一）

最新推荐文章于 2024-05-18 16:42:38 发布
最新推荐文章于 2024-05-18 16:42:38 发布
阅读量128 收藏 1
点赞数
分类专栏： java JavaSE 文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwq_666/article/details/109678704
版权
java 同时被 2 个专栏收录
28 篇文章 1 订阅
订阅专栏
JavaSE
28 篇文章 0 订阅
订阅专栏

IO流（一）

下一篇：IO流（二）

概述

在这里插入图片描述

I：Input

O：Output

通过IO可以完成硬盘文件的读和写

*java中所有的流都是在：java.io.下

流的分类

分类方式：

  1. 按照流的方向进行分类：

    （1）以内存作为参照物，往内存中去，叫做输入（Input），或者叫做读（Read）

    （2）从内存中出来，叫做输出（Output），或者叫做写（Write）

  2. 按照读取数据方式不同进行分类

    （1）有的流按照字节的方式读取数据，一次读取一个字节，等同于一次读取8个二进制位

    这种流是万能的，什么类型的文件都可以读取。

    ​ 假设文件file.txt，采用字节流的话是这样读的：

    ​ a中国bc张三fe

    ​ 第一次读：一个字节，正好读到’a’

    ​ 第二次读：一个字节，正好读到‘中’字符的一半

    ​ 第三次读：一个字节，正好读到‘中’字符的另外一半

    （2）有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取：图片、声音、视频等文件，只能读取纯文本文件，连word文件都无法读取。

    ​ 假设文件file.txt，采用字符流的话是这样读的：

    ​ a中国bc张三fe

    ​ 第一次读：‘a’字符（‘a’字符在Windows系统中占用1个字节）

    ​ 第二次读：‘中’字符（‘中’字符在Windows系统中占用2个字节）

综上所述，流的分类有：输入流、输出流、字节流、字符流

流的四大家族

四大家族的首领：

  1. java.io.InputStream 字节输入流
  2. java.io.OutpuStream 字节输出流
  3. java.io.Reader 字符输入流
  4. java.io.Writer 字符输出流

四大家族的首领都是抽象类（abstract class）

注意：在java中只要“类名”以Stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流

流的close和flush方法

  1. 所有的流都实现了：java.io.Closeable接口，都是可以关闭的，都有close()方法

    养成好习惯：避免造成耗费资源，用完流一定要关闭

  2. 所有的输出流都实现了：java.io.Flushable接口，都是可刷新的，都有flush()方法

    养成好习惯：输出流在最终输出之后，一定要记得flush()刷新，刷新的作用就是清空管道

    注意：如果没有flush()可能会导致丢失数据

java.io包下需要掌握的流有个16：

文件专属：

  1. java.io.FileInputStream

  2. java.io.FIleOutputStream

  3. java.io.FileReader

  4. java.io.FileWriter

转换流：

  1. java.io.InputStreamReader
  2. java.io.OutputStreamWriter

缓冲流专属：

  1. java.io.BufferedReader
  2. java.io.BufferedWriter
  3. java.io.BufferedInputStream
  4. java.io.BufferedOutputStream

数据流专属：

  1. java.io.DataInputStream
  2. java.io.DataOutputStream

标准输出流：

  1. java.io.PrintWriter
  2. java.io.PrintStream

对象专属流：

  1. java.io.ObjectInputStream
  2. java.io.ObjectOutputStream

FileInputStream

package se4.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * java.io.FIleInputStream:
 * 1.文件字节输入流，万能的，任何类型的文件都可以采用这个流来读
 * 2.字节的方式，完成输入的操作，完成读的操作（硬盘--->内存）
 */
public class FileInputStreamTest01 {
    public static void main(String[] args) {
        //创建文件字节输入流对象
        FileInputStream fis = null;
        try {
            //以下都是采用绝对路径的方式
            //文件路径：E:\学习资料\老杜Java系列\File（IDEA会自动把\变成\\,因为java中\表示转义）
            fis = new FileInputStream("E:\\学习资料\\老杜Java系列\\File\\temp.txt");
            //开始读,temp.txt文件内容：abcdef
            int readData = fis.read();//这个方法的返回值是：读取到的“字节”本身
            System.out.println(readData);//97
            int readData2 = fis.read();
            System.out.println(readData2);//98
            int readData3 = fis.read();
            System.out.println(readData3);//99
            int readData4 = fis.read();
            System.out.println(readData4);//100
            int readData5 = fis.read();
            System.out.println(readData5);//101
            int readData6 = fis.read();
            System.out.println(readData6);//102
            //已经读到文件的末尾了，再读的时候读取不到任何数据，返回-1
            int readData7 = fis.read();
            System.out.println(readData7);//-1
            int readData8 = fis.read();
            System.out.println(readData8);//-1

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //在finally语句块当中确保流一定关闭
            if (fis == null) {//避免空指针异常
                //关闭流的前提是：流不是空的。流是null的时候没必要关闭
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package se4.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
//对上一个程序进行改进
public class FileInputStreamTest02 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("E:\\学习资料\\老杜Java系列\\File\\temp.txt");
           /*
           while (true){
                int readData = fis.read();
                if (readData == -1){
                    break;
                }
                System.out.print(readData + " ");
            }//输出结果：97 98 99 100 101 102
           */
            //改造while循环
            int readData = 0;
            while ((readData = fis.read()) != -1){
                System.out.print(readData + " ");
            }//输出结果：97 98 99 100 101 102

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis == null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

分析以上两个程序的缺点：一次读取一个字节byte，这样内存和硬盘交互太频繁，基本上时间/资源都耗费在交互上面了。（不需要掌握上面的两个程序）

package se4.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * int read(byte[] b)
 * 一次最多读取b.length个字节
 * 减少硬盘和内存的交互，提高程序的执行效率
 * 往byte[]数组当中读
 */
public class FileInputStreamTest03 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("E:\\学习资料\\老杜Java系列\\File\\temp.txt");
            //开始读，采用byte数组，一次读取多个字节，最多读取数组.length个字节
            byte[] bytes = new byte[4];//准备一个4个长度的byte数组，一次最多读取4个字节
            //这个方法的返回值是：读取到的是字节数量（不是字节本身）
            int readCount = fis.read(bytes);
            //第一次读到了4个字节
            System.out.println(readCount);//4
            //下一行是将字节数组全部转换成字符串
            //System.out.println(new String(bytes));//abcd
            //不应该全部转换，应该是读取到了多少个字符就转换多少个，修改如下
            System.out.println(new String(bytes,0,readCount));//abcd

            //第二次只能读到2个字节
            readCount = fis.read(bytes);
            System.out.println(readCount);//2
            //System.out.println(new String(bytes));//efcd
            //不应该全部转换，应该是读取到了多少个字符就转换多少个，修改如下
            System.out.println(new String(bytes,0,readCount));//ef

            //1个字节都没有读到，返回-1
            readCount = fis.read(bytes);
            System.out.println(readCount);//-1

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis == null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

最终版，需要掌握

package se4.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
最终版，需要掌握
 */
public class FileInputStreamTest04 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("E:\\学习资料\\老杜Java系列\\File\\temp.txt");
            //准备一个byte数组
            byte[] bytes = new byte[4];
            /*太low，不建议这样写
            while (true){
                int readCount = fis.read(bytes);
                if (readCount == -1){
                    break;
                }
                //把byte数组转换成字符串，读到多少个转换多少个
                System.out.print(new String(bytes,0,readCount));//abcdef
            }*/

            int readCount = 0;
            while ((readCount = fis.read(bytes)) != -1){
                System.out.print(new String(bytes,0,readCount));
            }//输出结果：abcdef

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis == null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileInputStream类的其他常用方法

int available()；
package se4.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
FileInputStream类的其他常用方法
    int available()：返回流当中剩余的没有读到的字节数量
    long skip(long n)：跳过几个字节不读
temp.txt文件内容为：abcdef
 */
public class FileInputStreamTest05 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("E:\\学习资料\\老杜Java系列\\File\\temp.txt");
            System.out.println("总字节数量：" + fis.available());//6
            //读1个字节
            //int readByte = fis.read();
            //还剩下可以读的字节数量是：5
            //System.out.println("剩下" + fis.available() + "个字节没有读");
            //这个方法有什么用？如下
            byte[] bytes = new byte[fis.available()];//这种方式不适合太大的文件，因为byte数组不能太大
            //不需要循环了
            //直接读一次就行了
            int readCount = fis.read(bytes);//6
            System.out.print(new String(bytes));//abcdef

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis == null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
long skip(long n)；
package se4.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
FileInputStream类的其他常用方法
    int available()：返回流当中剩余的没有读到的字节数量
    long skip(long n)：跳过几个字节不读
temp.txt文件内容为：abcdef
 */
public class FileInputStreamTest06 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("E:\\学习资料\\老杜Java系列\\File\\temp.txt");
            System.out.println("总字节数量：" + fis.available());//6
            //skip跳过几个字节不读取
            //跳过3个字节
            fis.skip(3);
            System.out.println(fis.read());//100

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis == null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileOutputStream

package se4.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * 文件字节输出流，负责写
 * 从内存到硬盘
 */
public class FileOutputStreamTest01 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //myfile文件不存在的时候会自动新建！
            //这种方式谨慎使用，这种方式会先将原文件清空，然后重新写入
            fos = new FileOutputStream("E:\\学习资料\\老杜Java系列\\File\\myfile.txt");
            //开始写
            byte[] bytes = {97,98,99,100};
            //将byte数组全部写出！
            fos.write(bytes);//abcd
            //将byte数组的一部分写出！
            fos.write(bytes,0,2);//再写出ab

            //以追加的方式在文件末尾写入，不会清空原文件的内容
            fos = new FileOutputStream("E:\\学习资料\\老杜Java系列\\File\\myfile.txt",true);
            //字符串
            String s = "卧槽~";
            //将字符串转换成byte数组
            byte[] bs = s.getBytes();
            fos.write(bs);//不会清空前面的内容，会在后面加上卧槽~

            //写完之后，最后一定要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos == null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件的拷贝

package se4.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * 使用FileInputStream和FileOutputStream完成文件的拷贝
 * 拷贝过程应该是一边读、一边写
 * 使用以上的字节流拷贝文件的时候，文件类型随意，万能的，什么样的文件都能拷贝
 */
public class Copy01 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //创建一个输入流
            fis = new FileInputStream("E:\\download\\music\\虞兮叹.mp3");
            //创建一个输出流
            fos = new FileOutputStream("E:\\学习资料\\老杜Java系列\\File\\虞兮叹.mp3");

            //最核心：一边读，一边写
            byte[] bytes = new byte[1024 * 1024];//1MB(一次最多拷贝1MB)
            int readCount = 0;
            while ((readCount = fis.read(bytes))!= -1){
                fos.write(bytes,0,readCount);
            }
            //刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //分开try，不要一起try
            //一起try的时候，其中一个出现异常可能会影响到另一个流的关闭
            if (fis == null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos == null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileReader

package se4.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * FIleReader:
 *  文件字符输入流，只能读取普通文本
 *  读取文本内容时，比较方便、快捷
 */
public class FileReaderTest {
    public static void main(String[] args) {
        FileReader reader = null;
        try {
            //创建文件字符输入流
            reader = new FileReader("E:\\学习资料\\老杜Java系列\\File\\temp.txt");
            //开始读
            char[] chars = new char[4];//一次读取4个字符
            int readCouunt = 0;
            while ((readCouunt = reader.read(chars)) != -1){
                System.out.print(new String(chars,0,readCouunt));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader == null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileWriter

package se4.io;

import java.io.FileWriter;
import java.io.IOException;
/**
 * FileWriter：
 *  文件字符输出流，写
 *  只能输出普通文本
 */
public class FileWriterTest {
    public static void main(String[] args) {
        FileWriter out = null;
        try {
            //创建文件字符输出流对象
            out = new FileWriter("E:\\学习资料\\老杜Java系列\\File\\myfile2.txt");
            //out = new FileWriter("E:\\学习资料\\老杜Java系列\\File\\myfile2.txt",true);不清空，在末尾追加

            //开始写
            char[] chars = {'我','是','中','国','人'};
            out.write(chars);//我是中国人
            out.write(chars,2,3);//中国人
            out.write("\n");//换行符
            out.write("我是一名java软件工程师！");//我是一名java软件工程师！

            //刷新
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

普通文本文件的拷贝

package se4.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 使用FileReader和FileWriter拷贝
 * 只能拷贝“普通文本”文件
 */
public class Copy02 {
    public static void main(String[] args) {
        FileReader in = null;
        FileWriter out = null;
        try {
            //读
            in = new FileReader("C:\\Users\\QD\\Desktop\\个人博客地址.txt");
            //写
            out = new FileWriter("E:\\学习资料\\老杜Java系列\\File\\个人博客地址.txt");
            //一边读、一边写
            char[] chars = new char[1024 * 512];//1MB
            int readCount = 0;
            while ((readCount = in.read(chars)) != -1){
                out.write(chars,0,readCount);
            }
            //刷新
            out.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
最爱琴女E
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JavaSE笔记11111
10-15
JavaSE笔记涵盖 面向对象的三大特征:继承,多态,封装 单列集合与双列集合:collection & map IO流:InputStream字节输入流,OutputStream字节输出流,Reader字符输入流,Writer字符输出流; 多线程&线程池; 反射&动态代理等
javaSE经典笔记( 完整）
05-19
javaSE笔记、经典、全面 基本操作 Java基础 面向对象 多线程 String类 集合 IO GUI socket网络编程 正则表达式
JavaSE笔记21：IO流（二）
qwq_666的博客
11-14 98
IO流（二） 上一篇：IO流（一） 缓冲流（了解） BufferedReader package se4.io; import java.io.BufferedReader; import java.io.FileReader; /** * BUfferedReader： * 带有缓冲区的字符输入流 * 使用这个流的时候不需要自定义char数组，或者说不需要自定义byte数组。自带缓冲。 */ public class BufferedReaderTest01 { public sta
JavaSE笔记22：IO流（三）
qwq_666的博客
11-15 89
IO流（三） 上一篇：IO流（二） 序列化与反序列化 java.io.NotSerializableException: se4.bean.Student Student对象不支持序列化！ 参与序列化和反序列化的对象，必须实现Serializable接口 注意：通过源代码发现，Serializable接口只是一个标志接口： public interface Serializable { } 这个接口当中什么代码都没有 作用：起到标识的作用，标志的作用，java虚拟机看到这个类实现了这个接口，可能会对这个类
JavaSE基础20笔记IO流
欢迎大家互相交流分享
01-28 122
21.01_IO流(字符流FileReader) 1.字符流是什么 字符流是可以直接读写字符的IO流 字符流读取字符, 就要先读取到字节数据, 然后转为字符. 如果要写出字符, 需要把字符转为字节再写出. 2.FileReader FileReader类的read()方法可以按照字符大小读取​ FileReader fr = new FileReader("aaa.txt"); ...
JavaSE个人学习笔记03：IO流
hotace_c的博客
08-23 516
03 IO流 IO的API方法少且较为固定，有一定的规律，需要熟悉掌握并学会使用特定情况下所使用的代码。 详情参考JDK最新版本的API官方文档，此处只做简单介绍。 概念IO流即输出流和输入流将外设的数据读取到内存中：输入 将内存的数据读取到外设中：输出字符流与字节流 字节流是由字节组成的，不仅可以操作字符，还可以操作其他媒体文件，处理的最小单位是byte. 字符流是由字符组成的，只
JavaSE基础21笔记IO流
欢迎大家互相交流分享
01-28 187
22.01_IO流(序列流)(了解) 1.什么是序列流 序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推. 2.使用方式 整合两个: SequenceInputStream(InputStream, InputStream) FileInputStream fis1 = new FileInput...
JavaSE基础19笔记IO流
欢迎大家互相交流分享
01-28 130
20.01_IO流(IO流概述及其分类) 1.概念 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的类都在IO包中 流按流向分为两种：输入流，输出流。 流按操作类型分为两种： 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的 字符流 : 字符流只能操作纯字符数据，比较方便。 2.IO流常用父类 字节流的抽象父...
JavaSE学习笔记(七)：IO流
weixin_46476301的博客
04-26 155
目录 一、File类的使用 1.File类的理解 2.File的实例化 2.1常用构造器 2.2 路径的分类 2.3 路径分隔符 3.File类的常用方法 二、使用步骤 最后 一、File类的使用 1.File类的理解 * 1. File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹) * 2. File类声明在java.io包下 * 3. File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法， * 并未涉及到写入或读取文件内...
JavaSE笔记15.1-IO流-概述
qq_38503984的博客
08-18 103
JavaSE笔记15.1-IO流-概述一. 流的概念二. 流的分类1. 输入流和输出流2. 字节流和字符流3. 节点流和处理流三. IO流类图结构 一. 流的概念 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。 IO流用来处理设备（内存、硬盘等）之间的数据传输。 二. 流的分类 根据数据流向分类：输入流、输出流 根据数据单元分类：字节流、字符流 根据功能分类：节点流、处理流 1. 输入流和输出流 输入流：程序从数据源中读取数据 输出流：将数据从程序中写到预期的目的地 2. 字节流和字符
JavaSE笔记26：反射机制（一）
qwq_666的博客
12-01 97
反射机制（一） 概述 通过java语言中的反射机制可以操作字节码文件（可以读和修改字节码文件）。 作用：可以让程序更加灵活 反射机制的相关类在：java.lang.reflect.* 相关的主要的类有： java.lamg.Class 代表字节码文件，代表一个类型 java.lang.reflect.Method 代表字节码中的方法字节码，代表类中的方法 java.lang.reflect.Constructor 代表字节码中的构造方法字节码，代表类中的构造方法 java.lang.refle
JavaSE精华笔记.zip
01-06
Java基础部分笔记，包含IO流、多线程、网络编程、Lambda表达式，适合巩固基础以及新手查看，都是Java基础的精华
javaSE基础笔记整合
03-26
函数，数组，集合，String，集合，IO，Lambda
JavaSE学习笔记.docx
12-20
Java学习笔记 初识Java编程、Java基本数据类型、运算符、流程控制、数组、方法、面相对象、Java常用类库、集合、异常处理、多线程、IO流、网络编程、Java的反射机制、泛型、枚举、注解、配置文件操作、发送邮件、...
jar包增量更新分析
junlaiyan的专栏
05-16 261
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
最新发布
博主是个二次元死肥宅~
05-18 678
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 621
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 905
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
动力节点javase笔记
09-07
动力节点Javase笔记是一份非常重要的学习资料。首先，这份笔记涵盖了JavaSE相关的基本概念和知识点。它可以帮助学习者系统地掌握JavaSE的核心语法、面向对象编程、异常处理、集合框架等基础知识。 其次，动力节点...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值