区别

转发是服务器行为，重定向是客户端行为。为什么这样说呢，这就要看两个动作的工作流程：

转发过程：客户浏览器发送http请求—-》web服务器接受此请求–》调用内部的一个方法在容器内部完成请求处理和转发动作—-》将目标资源发送给客户；在这里，转发的路径必须是同一个web容器下的url，其不能转向到其他的web路径上去，中间传递的是自己的容器内的request。在客户浏览器路径栏显示的仍然是其第一次访问的路径，也就是说客户是感觉不到服务器做了转发的。转发行为是浏览器只做了一次访问请求。

重定向过程：客户浏览器发送http请求—-》web服务器接受后发送302状态码响应及对应新的location给客户浏览器–》客户浏览器发现是302响应，则自动再发送一个新的http请求，请求url是新的location地址—-》服务器根据此请求寻找资源并发送给客户。在这里location可以重定向到任意URL，既然是浏览器重新发出了请求，则就没有什么request传递的概念了。在客户浏览器路径栏显示的是其重定向的路径，客户可以观察到地址的变化的。重定向行为是浏览器做了至少两次的访问请求的。

重定向，其实是两次request

第一次，客户端request   A,服务器响应，并response回来，告诉浏览器，你应该去B。这个时候IE可以看到地址变了，而且历史的回退按钮也亮了。重定向可以访问自己web应用以外的资源。在重定向的过程中，传输的信息会被丢失。

举例

重定向格式，等于返回一个新的页面地址

response.sendRedirect("success.jsp"); //重定向，导致数据丢失

转发格式，等于服务器内部再发送一个请求

request.getRequestDispatcher("success.jsp").forward(request,response);//请求转发

使用重定向格式登录

login.jsp

check.jsp

check.jsp 请求接收login.jsp的数据，告诉login.jsp已经登录成功了，去success.jsp吧。

但是数据并没有传进来，login.jsp把数据给了check.jsp。check.jsp 并没有把数据给到success.jsp，所以我们取不到数据。

使用请求转发模式

只做一行改动

这次是服务器内部去请求信息。check.jsp没有返回给用户一个新的界面，而是在内部通知success.jsp显示，并将数据传递过去。

摘录来自 ： 链接 下面有我举的例子讲解。主要写这篇文章是要明确概念。

用户在页面上填写的表单信息都可以通过 GET 和 POST 这两种方法将数据传递到服务器上，当使用 GET 方法时，所有的信息都会出现在 URL 地址中，并且使用 GET 方法最多只能传递 1024 个字符，所以在传输量小或者安全性不那么重要的情况下可以使用 GET 方法。而对于 POST 方法而言，最多可以传输 2MB 字节的数据，而且可以根据需要调节。

首先，GET和POST都是HTTP协议中的两种发送请求的方法，由于HTTP的底层是TCP/IP。所以GET和POST的底层也是TCP/IP。GET和POST能做的事情是一样一样的。如果给GET加上request body，活着给POST带上url参数，技术上是完全行的通的。也就是说，GET和POST在本质上没什么区别。

但是如果真的一点区别都没有，那么这个问题也就不存在了，所以，两者之间最重大的区别就是：

GET产生一个TCP数据包；POST产生两个TCP数据包。

具体点说来就是：

对于GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数据）；

而对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200 ok（返回数据）。

这样看起来，因为POST需要两步，时间上消耗的要多一点，所以GET比POST更有效。那么可不可以用GET替换POST来优化网站性能？

1. GET与POST都有自己的语义，不能随便混用。

2. 如果网络环境好的话，发一次包的时间和发两次包的时间差别基本可以无视。如果网络环境差的话，两次包的TCP在验证数据包完整性上，有非常大的优点。

3. 并不是所有浏览器都会在POST中发送两次包，Firefox就只发送一次。

• GET在浏览器回退时是无害的，而POST会再次提交请求。
• GET产生的URL地址可以被Bookmark，而POST不可以。
• GET请求会被浏览器主动cache，而POST不会，除非手动设置。
• GET请求只能进行url编码，而POST支持多种编码方式。
• GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。
• GET请求在URL中传送的参数是有长度限制的，而POST么有。
• 对参数的数据类型，GET只接受ASCII字符，而POST没有限制。
• GET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。
• GET参数通过URL传递，POST放在Request body中。

举例

使用get方法

定义两个Jsp文件，登陆界面。

这里form没有定义method，所以默认是get。比如我输入：

返回结果，可以看到链接里是有变量名和值的。

不知道你是否有这样的疑问，不是说get方法链接里只能使用ASCⅡ吗，怎么这里面有中文。

其实这里的”你好“是显示出的结果，url编码后其实还是ASCⅡ。

http://localhost:8080/JspProject/show.jsp?uname=%E4%BD%A0%E5%A5%BD&upwd=&uage=123

使用post方法

我们加上method

这次点击注册后变量名称消失

题外话

因为我做过一段CTF，post方法也不是完全安全，这里不是https链接。所以使用BrupSuit可以中途拦截达到欺骗的目的。

Output乱码解决

找到java.util.logging.ConsoleHandler.encoding = UTF-8

将其注释掉

#java.util.logging.ConsoleHandler.encoding = UTF-8

或者将UTF-8改为GBK

java.util.logging.ConsoleHandler.encoding = GBK

Tomcat Localhost Log 乱码解决

找到localhost.org.apache.juli.AsyncFileHandler.encoding = UTF-8

将其注释掉

#localhost.org.apache.juli.AsyncFileHandler.encoding = UTF-8

或者将UTF-8改为GBK

localhost.org.apache.juli.AsyncFileHandler.encoding = GBK

Tomcat Catania Log 乱码解决

找到catalina.org.apache.juli.AsyncFileHandler.encoding = UTF-8

将其注释掉

#catalina.org.apache.juli.AsyncFileHandler.encoding = UTF-8

或者将UTF-8改为GBK

catalina.org.apache.juli.AsyncFileHandler.encoding = GBK

页面乱码

-Dfile.encoding=UTF-8

JSP全称Java Server Pages，是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。标签通常以<%开头以%>结束。

详细介绍

JSP 处理

以下步骤表明了 Web 服务器是如何使用JSP来创建网页的：

• 就像其他普通的网页一样，您的浏览器发送一个 HTTP 请求给服务器。
• Web 服务器识别出这是一个对 JSP 网页的请求，并且将该请求传递给 JSP 引擎。通过使用 URL或者 .jsp 文件来完成。
• JSP 引擎从磁盘中载入 JSP 文件，然后将它们转化为 Servlet。这种转化只是简单地将所有模板文本改用 println() 语句，并且将所有的 JSP 元素转化成 Java 代码。
• JSP 引擎将 Servlet 编译成可执行类，并且将原始请求传递给 Servlet 引擎。
• Web 服务器的某组件将会调用 Servlet 引擎，然后载入并执行 Servlet 类。在执行过程中，Servlet 产生 HTML 格式的输出并将其内嵌于 HTTP response 中上交给 Web 服务器。
• Web 服务器以静态 HTML 网页的形式将 HTTP response 返回到您的浏览器中。
• 最终，Web 浏览器处理 HTTP response 中动态产生的HTML网页，就好像在处理静态网页一样。

一般情况下，JSP 引擎会检查 JSP 文件对应的 Servlet 是否已经存在，并且检查 JSP 文件的修改日期是否早于 Servlet。如果 JSP 文件的修改日期早于对应的 Servlet，那么容器就可以确定 JSP 文件没有被修改过并且 Servlet 有效。这使得整个流程与其他脚本语言（比如 PHP）相比要高效快捷一些。

总的来说，JSP 网页就是用另一种方式来编写 Servlet 而不用成为 Java 编程高手。除了解释阶段外，JSP 网页几乎可以被当成一个普通的 Servlet 来对待。

Jsp语法

由于Jsp将语句转化为Java代码，Java代码又被转化为HTML语言，所以输出换行时使用</br>。更改Jsp文件后直接刷新浏览器页面即可看到更新，因为当Jsp文件更改后，Jsp文件时间戳晚于Servlet（Java代码）。所以要重新编译生成。

<%!
   全局变量、定义方法
%>
<%
   局部变量、java语句
%>

<%=输出表达式 %>

输出

JSP隐含对象

不需要创建对象可以直接使用。

JSP支持九个自动定义的变量，江湖人称隐含对象。这九个隐含对象的简介见下表：

JDBC工具类搭建

使用Log4j记录JDBC的日志信息

会安装会用就可，不必纠结怎么实现的，点击下载Log4j.jar

首先将Log4j添加依赖

在src目录下创建文件，.properties是一种主要在Java相关技术中用来存储应用程序的可配置参数的文件的文件扩展名。

添加如下代码，用于生成日志的格式

# DEBUG\u8BBE\u7F6E\u8F93\u51FA\u65E5\u5FD7\u7EA7\u522B\uFF0C\u7531\u4E8E\u4E3ADEBUG\uFF0C\u6240\u4EE5ERROR\u3001WARN\u548CINFO \u7EA7\u522B\u65E5\u5FD7\u4FE1\u606F\u4E5F\u4F1A\u663E\u793A\u51FA\u6765
log4j.rootLogger=DEBUG,Console,RollingFile

#\u5C06\u65E5\u5FD7\u4FE1\u606F\u8F93\u51FA\u5230\u63A7\u5236\u53F0
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern= [%-5p]-[%d{yyyy-MM-dd HH:mm:ss}] -%l -%m%n
#\u5C06\u65E5\u5FD7\u4FE1\u606F\u8F93\u51FA\u5230\u64CD\u4F5C\u7CFB\u7EDFD\u76D8\u6839\u76EE\u5F55\u4E0B\u7684log.log\u6587\u4EF6\u4E2D
log4j.appender.RollingFile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.RollingFile.File=D://log.log
log4j.appender.RollingFile.layout=org.apache.log4j.PatternLayout
log4j.appender.RollingFile.layout.ConversionPattern=%d [%t] %-5p %-40.40c %X{traceId}-%m%n

添加基本配置，注意导入的包名，是使用Log4j中的 logger

在catch中添加这句输出bug信息，和安卓的LogCat用法很像

展示bug的方式也一模一样，栈跟踪日志。我没开数据库所以没连接上。

完善JDBC的调用

我们之前是在JDBC类中连接数据库，在connection中定义了连接数据库的信息

创建dp.properties文件，存储数据库连接信息，我创建了一个dp.properties文件，里面记录：

dp.username=root
dp.password=1qazxsw2
dp.url=jdbc:mysql://127.0.0.1:3306/test

这里注意，如果是使用intellij的话，需要建立一个根文件夹，并标记为资源文件，否则无法读取。

然后再创建一个propertiesTool.java文件

package tools.db;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class propertiesTool {
    private static Properties properties = new Properties();
    static {
        InputStream inputStream = propertiesTool.class.getClassLoader().getResourceAsStream("db.properties");//将db.properties变为javaIO流对象
        try {
            properties.load(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

这样就可以读取到dp.properties里面的信息了

调用

返回值

没有报错，实现成功

以为是CTF的内容，没想到Java也讲了。sql注入通过输入特殊的字符，达到一些特殊目的。

执行语句

实际执行的sql语句

delete from student where id='1' or '1'='1'

等于删除了数据库的所有内容，因为 or后面的语句恒为true

如何防止SQL注入

使用PreparedStatement拼接语句

这样就可以避免注入了，在测试之前，先封装一下这个方法，使用动态变量可以添加多个数值。

主方法中添加之前的注入语句

若执行成功了任何一行，返回true

看来这样就可以避免注入了

更新了之前JDBC类中的select和update方法，使用prepareStatement方法

上一节创建了一个SelectSql方法，实现了查询。但如果想实现自定义的查询，需要重写自定义JDBC类中的SelectSql方法，首先我们想这样写：

ResultSet SelectSql(String sql){
        Connection connection=null;
        Statement search=null;
        ResultSet rs = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://127.0.0.1:3306/test";
            connection = DriverManager.getConnection(url, "root", "1qazxsw2");
            search=connection.createStatement();
            rs = search.executeQuery(sql);
            return rs;
        } catch (Exception throwables) {
            throwables.printStackTrace();
            if(rs!=null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(search!=null){
                try {
                    search.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

    }

这个方法返回Result方法，看似没有问题，但实际运行时会报错，因为在执行时，rs已经被关闭了。

使用接口实现

定义一个名为IRowMapper的接口

在SelectSql中，通过调用接口里的方法实现查询。

在主方法里写出一个实现接口的类

之后我们就可以传递接口实例，去实现Select了

执行结果

这样就解决了自定义查询的问题！每次把自定义查询的内容写在接口的实例里就好。

改进

把资源释放写成方法，实现代码复用

为select重载一个close（select里有一个ResultSet）

调用此方法关闭Statment和connection，ResultSet

继续优化

可以看到这四行在查询和更新方法中是重复使用的

创建方法返回connection对象

在每次连接数据库时，调用此方法即可

exist方法

写一个exist方法，便于查询数据库中是否已经存入某个数据

查询失败

查询成功

学生管理系统

用以上的知识就可以简单的创建一个学生管理系统，实现方法已经讲解了，这里直接放代码，有兴趣的可以看看

package com.cztcode.student;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

import Test.IRowMapper;
import Test.JDBC;

public class main {

    public static void main(String[] args) {
        System.out.println("*********************************");
        System.out.println("*\t\t\t\t*");
        System.out.println("*\t欢迎使用学生信息管理系统\t*");
        System.out.println("*\t\t\t\t*");
        System.out.println("*********************************");
        while (true) {
            menu();
        }
    }


    static void menu() {
        System.out.println("1、添加学生信息");
        System.out.println("2、删除学生信息");
        System.out.println("3、修改学生信息");
        System.out.println("4、查询学生信息");
        System.out.println("请输入操作，以Enter键结束:");
        Scanner in;
        in = new Scanner(System.in);
        String id, name, sex, address,sql;
        int option = in.nextInt();
        switch (option) {
            case 1:
                System.out.println("输入学生信息: id 姓名 性别 地址 ");
                id = in.next();
                if (check(id)) {
                    System.out.println("已经添加过,重新选择");
                    break;
                }
                name = in.next();
                sex = in.next();
                address = in.next();
                sql = "insert into student (id,name,sex,address)values('"+id+"','"+name+"','"+sex+"','"+address+"')";
                JDBC.UpdateSql(sql);
                break;
            case 2:
                System.out.println("请输入id");
                id=in.next();
                if (!check(id)) {
                    System.out.println("没有此学生");
                    break;
                }
                sql="delete  from student where id='"+id+"'";
                JDBC.UpdateSql(sql);
                System.out.println("已删除");
                break;
            case 3:
                System.out.println("请输入id");
                id=in.next();
                if (!check(id)) {
                    System.out.println("没有此学生");
                    break;
                }
                name = in.next();
                sex = in.next();
                address = in.next();
                sql = "insert into student (id,name,sex,address)values('"+id+"','"+name+"','"+sex+"','"+address+"')";
                JDBC.UpdateSql(sql);
                System.out.println("修改成功");
                break;
            case 4:
                System.out.println("请输入id");
                id=in.next();
                if (!check(id)) {
                    System.out.println("没有此学生");
                    break;
                }
                sql="select * from student where id='"+id+"'";
                JDBC.SelectSql(sql,new RowMapper());
                System.out.println("查询完毕");
                break;
            default:
                System.out.println("I'm Sorry,there is not the " + option + " option,please try again.");
        }
    }

    static boolean check(String id) {
        String sql = "select * from student where id='"+id+"'";
        return JDBC.exist(sql);
    }
}
class RowMapper implements IRowMapper {
    public void rowMapper(ResultSet rs) {
        try {
            while (rs.next()) {
                System.out.print(rs.getString("id") + " ");
                System.out.print(rs.getString("name") + " ");
                System.out.print(rs.getString("sex") + " ");
                System.out.println(rs.getString("address"));
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

大家都知道JDBC是面向关系型数据库的，全称Java Database Connectivity。可是Java怎么能使用JDBC呢，小编也很好奇，但事实就是这样，大家有什么想法在留言区评论吧！（狗头保命）????

创建数据库

首先使用Navicat Premium 15 创建一个表，先存进去一点数据方便一会调用。

运行两个查询语句

insert into user_info (id,name) VALUES ('123','陈泽曈')
insert into user_info (id,name) VALUES ('456','老高')

可以看到已经添加进来了。

添加依赖

添加mysql-connector-java-5.1.44-bin.jar包

选择添加到lib文件夹下

可以去 文件–项目结构中选择添加依赖

也可以右键添加为库

连接数据库

使用JDBC应用程序向表中查询数据记录需要以下步骤：

• 导入包：需要包含包含数据库编程所需的JDBC类的包。 大多数情况下，使用import java.sql.*就足够了。
• 注册JDBC驱动程序：需要初始化驱动程序，以便可以程序中打开数据库的通信通道。
• 打开连接：需要使用DriverManager.getConnection()方法来创建一个Connection对象，它表示与数据库服务器的物理连接。
• 执行查询：需要使用类型为Statement的对象来构建和提交SQL语句，以在选择的数据库的表中查询数据记录。
• 提取数据：执行SQL查询后，可以从表中获取记录。
• 释放资源：关闭Statement和connection

数据库的查询

package Test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class Test {
    public static void main(String[] args) {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url="jdbc:mysql://127.0.0.1:3306/test";
            Connection connection= DriverManager.getConnection(url,"root","1qazxsw2");
            System.out.println("连接成功!");
            Statement search=connection.createStatement();
            String sql="SELECT * FROM user_info";
            ResultSet rs = search.executeQuery(sql);
            while(rs.next()){
                System.out.println(rs.getString("id"));
                System.out.println(rs.getString("name"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意导入sql包，这里捕获异常直接用通用的Exception，不然要使用两个try/catch捕获异常。一个为forName，一个为getConnection抛出。

• Statement 用于执行静态SQL语句并返回其生成的结果的对象
• ResultSet 对象保持一个光标指向其当前的数据行

输出为：

数据库的修改

几个操作语法很相似，就直接给出例子了。

executeUpdate:执行给定的SQL语句，这可能是INSERT ， UPDATE ，或DELETE语句，或者不返回任何内容，如SQL DDL语句的SQL语句。

删除数据

先插入一个id=0的数据

 int result = search.executeUpdate("delete from user_info where id=0");
            if(result >0){
                System.out.println("ok");
            }

使用这句话删除id为0的数据行

出现了OK，数据库中也删除成功。

添加数据

int result1 = search.executeUpdate("insert into user_info (id,name)values('789','hello')");
            if (result1 > 0) {
                System.out.println("添加成功");
            }

执行结果

更新数据

这次把数据库连接语句做了封装，写进了一个类。使用时传递语句就好。

JDBC类

package Test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class JDBC {
    boolean UpdateSql(String sql){
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://127.0.0.1:3306/test";
            Connection connection = DriverManager.getConnection(url, "root", "1qazxsw2");
            Statement exe=connection.createStatement();
            int result=exe.executeUpdate(sql);
            return result>0;
        } catch (Exception e) {
            e.printStackTrace();
        }
    return  false;
    }
}

释放资源

使用完Statement和connection后，要进行资源的释放，那么问题来了，应该怎样设置释放的逻辑呢。

如果将close添加到这里，当sql语句出错时，会跳转到catch语句，无法释放。所以要添加到finally里。

当exe或者connection中为null时，不用关闭，因为本来就没有创建成功，当为null时关闭。注意不能写到一个if中一起关闭，因为有可能statement创建失败，而在一个if中时则无法关闭connection。

注：查询也可以封装到方法里

boolean SelectSql(String sql){
        Connection connection=null;
        Statement search=null;
        ResultSet rs = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://127.0.0.1:3306/test";
            connection = DriverManager.getConnection(url, "root", "1qazxsw2");
            search=connection.createStatement();
            rs = search.executeQuery(sql);
            while(rs.next()){
                System.out.println(rs.getString("id"));
                System.out.println(rs.getString("name"));
            }
        } catch (Exception throwables) {
            throwables.printStackTrace();
            if(rs!=null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(search!=null){
                try {
                    search.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

Java使用JDBC（中）

Java中有普通代码块，静态代码块，构造代码块，它们的执行顺序是怎样的呢？

普通代码块：

在方法或语句中出现的{}就称为普通代码块。普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定–“先出现先执行”

构造代码块：

直接在类中定义且没有加static关键字的代码块称为{}构造代码块。
构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。

静态代码块:

在java中使用static关键字声明的代码块。静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。如果类中包含多个静态代码块，那么将按照”先定义的代码先执行，后定义的代码后执行”。

注意：

• 静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问。
• 静态代码块不能存在于任何方法体内。

执行顺序

比如下面这个程序

package Test;

public class Test {
    public Test(){//构造函数
        System.out.println("构造函数");
    }

    {//构造代码块,在类中
        System.out.println("构造代码块");
    }
    void a(){
        {//方法中,普通代码块
            System.out.println("普通代码块");
        }
    }
    static {//静态代码块
        System.out.println("静态代码块");
    }
    public static void main(String[] args) {
        new Test().a();
    }
}

执行结果为：

• 静态代码块
• 构造代码块
• 构造函数
• 普通代码块

使用HashSet试验建立学生管理系统。

主程序

package com.cztcode.student;

import java.util.HashSet;
import java.util.Scanner;

public class main {
    private static HashSet<Student> set = new HashSet<Student>();

    public static void main(String[] args) {
        System.out.println("*********************************");
        System.out.println("*\t\t\t\t*");
        System.out.println("*\t欢迎使用学生信息管理系统\t*");
        System.out.println("*\t\t\t\t*");
        System.out.println("*********************************");
        while (true) {
            menu();
        }

    }

    static void menu() {
        System.out.println("1、添加学生信息");
        System.out.println("2、删除学生信息");
        System.out.println("3、修改学生信息");//地址传递
        System.out.println("4、查询学生信息");//name
        System.out.println("请输入操作，以Enter键结束:");
        Scanner in;
        in = new Scanner(System.in);
        int option = in.nextInt();
        switch (option) {
            case 1:
                System.out.println("添加");
                System.out.println("依次输入 姓名 学号 电话 性别");
                Student Tstu = new Student(in.next(), in.next(), in.next(), in.next());
                if (set.contains(Tstu)) {
                    System.out.println("已经添加过");
                } else {
                    set.add(Tstu);
                }
                break;
            case 2:
                System.out.println("输入学号");
                String id2 = in.next();
                if (!set.contains(id2)) {
                    System.out.println("未查询到");
                    return;

                } else {
                    set.remove(id2);
                }
                break;
            case 3:
                System.out.println("输入学号");
                String id3 = in.next();
                if (!set.contains(id3)) {
                    System.out.println("未查询到");
                    return;

                } else {
                    for (Student stu : set) {
                        if (stu.getSno().equals(id3)) {
                            System.out.println("依次输入 姓名 学号 电话 性别");
                            stu.setName(in.next());
                            stu.setSex(in.next());
                            stu.setSno(in.next());
                            stu.setTel(in.next());
                            System.out.println("添加成功");
                            return;
                        }
                    }
                }
                break;
            case 4:
                System.out.println("输入学号");
                String id = in.next();
                if (!set.contains(id)) {
                    System.out.println("未查询到");
                    return;

                } else {
                    for (Student stu : set) {
                        if (stu.getSno().equals(id)) {
                            System.out.println(in.next());
                            return;
                        }
                    }
                }

                break;
            default:
                System.out.println("I'm Sorry,there is not the " + option + " option,please try again.");
        }
    }

}

Student类

package com.cztcode.student;

import java.util.Objects;

public class Student {
    private String name;
    private String sno;
    private String tel;
    private String sex;

    Student(String string){
        this.sno=string;
    };

    @Override
    public int hashCode() {
        return Objects.hash(sno);
    }

    public Student(String name, String sno, String tel, String sex) {
        super();
        this.name = name;
        this.sno = sno;
        this.tel = tel;
        this.sex = sex;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSno() {
        return sno;
    }
    public void setSno(String sno) {
        this.sno = sno;
    }
    public String getTel() {
        return tel;
    }
    public void setTel(String tel) {
        this.tel = tel;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return sno.equals(student.sno);
    }



}

主要使用了set的几个方法。