20155324 《Java程序设计》实验五 网络编程与安全

20155324 《Java程序设计》实验五 网络编程与安全

实验内容

任务一

• 编写MyBC.java实现中缀表达式转后缀表达式的功能

• 编写MyDC.java实现从上面功能中获取的表达式中实现后缀表达式求值的功能

参考：数据结构应用

栈的应用

栈 (Stack)是一种只允许在表尾插入和删除的线性表，有先进后出（FILO），后进先出(LIFO)的特点。允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)。

栈的一个应用是用来对四则运算表达式进行求值。

表达式Exp = S1 + OP + S2(S1 ，S2是两个操作数，OP为运算符)有三种标识方法：

OP + S1 + S2 为前缀表示法

S1 + OP + S2 为中缀表示法

S1 + S2 + OP 为后缀表示法

例如：Exp = a * b + (c - d / e) * f

前缀式: + * a b * - c / d e f

中缀式: a * b + c - d / e * f

后缀式: a b * c d e / - f * +

之前我也做了一份关于表达式后缀表达式的博客。

MyBC：

代码如下：

import java.util.*;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.Arrays;
public class MyBC {
    private static LinkedList<String> op1 = new LinkedList<>();
    private static LinkedList<String> op2 = new LinkedList<>();
    private static StringBuilder a = new StringBuilder();

    public StringBuilder houzhui(LinkedList<String> list) {
        Iterator<String> i = list.iterator();
        while (i.hasNext()) {
            String s = i.next();
            if (isOperator(s)) {
                if (op1.isEmpty()) {
                    op1.push(s);
                } else {
                    if (priority(op1.peek()) <= priority(s) && !s.equals(")")) {
                        op1.push(s);
                    } else if (!s.equals(")") && priority(op1.peek()) > priority(s)) {
                        while (op1.size() != 0 && priority(op1.peek()) >= priority(s)
                                && !op1.peek().equals("(")) {
                            if (!op1.peek().equals("(")) {
                                String operator = op1.pop();
                                a.append(operator).append(" ");
                                op2.push(operator);
                            }
                        }
                        op1.push(s);
                    } else if (s.equals(")")) {
                        while (!op1.peek().equals("(")) {
                            String operator = op1.pop();
                            a.append(operator).append(" ");
                            op2.push(operator);
                        }
                        op1.pop();
                    }
                }
            } else {
                a.append(s).append(" ");
                op2.push(s);
            }
        }
        if (!op1.isEmpty()) {
            Iterator<String> iterator = op1.iterator();
            while (iterator.hasNext()) {
                String operator = iterator.next();
                a.append(operator).append(" ");
                op2.push(operator);
                iterator.remove();
            }
        }
        return a;
    }

    private static boolean isOperator(String oper) {
        if (oper.equals("+") || oper.equals("-") || oper.equals("/") || oper.equals("*")
                || oper.equals("(") || oper.equals(")")) {
            return true;
        }
        return false;
    }

    private static int priority(String s) {
        switch (s) {
            case "+":
                return 1;
            case "-":
                return 1;
            case "*":
                return 2;
            case "/":
                return 2;
            case "(":
                return 3;
            case ")":
                return 3;
            default:
                return 0;
        }
    }
}

设置一个操作数栈，开始栈为空；

从左到右扫描后缀表达式，遇操作数，进栈；

若遇运算符，则从栈中退出两个元素，先退出的放到运算符的右边，后退出的放到运算符左边，运算后的结果再进栈，直到后缀表达式扫描完毕。

此时，栈中仅有一个元素，即为运算的结果。

Tset：

import java.util.LinkedList;
import java.util.*;

public class Test {
    public static void main(String[] args){
        LinkedList<String> list=new LinkedList<>();
        StringBuilder result1;
        int result2;
        String expression, again;
        System.out.println("请输入一个中缀表达式并以#结束");
        Scanner scanner=new Scanner(System.in);
        String s;
        while (!(s=scanner.next()).equals("#")) {
            list.add(s);
        }
        MyBC hz=new MyBC();
        result1 = hz.houzhui(list);
        System.out.println("后缀表达式： "+result1);
        MyDC evaluator = new MyDC();
        result2 = evaluator.evaluate(result1);
        System.out.println("That expression equals " + result2);
        System.out.println();

    }
}

任务二

• 结对编程：一人负责客户端，另一人负责服务器

• 注意责任归宿，要会通过测试证明自己没有问题

• 基于Java Socket实现客户端/服务器功能，传输方式用TCP

• 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器

• 服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端

• 客户端显示服务器发送过来的结果

匹配连接

1.运行服务器端代码；

2.显示“服务器已经启动后”运行客户端代码；

3.显示“已经建立连接”就证明双方已经连接好了；

4.客户端输入要传输的信息；

5.服务器端显示从客户端接受到的信息；

6.双方匹配成功，并在客户端显示“匹配成功”的消息。

创建了客户端和服务器，调用任务一中的中缀表达式转后缀表达式与后缀表达式求值的方法即可。运行结果如下：

任务三

• 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器

• 服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
  
  其他要求同任务二

1.建立一个Socket对象，用来建立一个端口号与客户端相连，获得网络输入流与输出流对象的引用。

2.使用服务器端RSA的私钥对DES的密钥进行解密，对秘钥进行解密之后使用DES对密文进行解密。

3.计算解密后的hash值来确定解密是否正确。

运行结果如下：

任务四

• 客户端和服务器用DH算法进行3DES或AES算法的密钥交换

• 其他要求同任务三

执行密钥协定的标准算法是DH算法（Diffie-Hellman算法），分为以下两步：

创建DH公钥和私钥；

创建共享密钥。

任务五

服务器接收到后缀表达式表达式后，进行解密，解密后计算明文的MD5值，和客户端传来的MD5进行比较，一致则调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端

其他要求同任务四

运行结果如下：

PSP(Personal Software Process)时间

步骤	耗时	百分比
需求分析	40min	16.70%
设计	80min	33.35%
代码实现	80min	33.35%
测试	20min	8.30%
分析总结	20min	8.30%

参考资料

• Java学习笔记(第8版)

• 《Java学习笔记(第8版)》学习指导

• ...