2017-2018-2 20165205 实验五《网络编程与安全》实验报告

最新推荐文章于 2023-10-09 15:58:21 发布
最新推荐文章于 2023-10-09 15:58:21 发布
阅读量110 收藏
点赞数
文章标签： java 网络
原文链接：http://www.cnblogs.com/mushroomissmart/p/9123497.html
版权
2017-2018-2 20165205 实验五《网络编程与安全》实验报告

实验内容

  1. 实验五 网络编程与安全-1

    两人一组结对编程：

    1. 参考http://www.cnblogs.com/rocedu/p/6766748.html#SECDSA
    2. 结对实现中缀表达式转后缀表达式的功能 MyBC.java
    3. 结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能,调用MyDC.java
    4. 上传测试代码运行结果截图和码云链接

    首先实现MyBC.java（后缀转中缀）

     public class MyBC {
 public static String toPostfix(String expr){
 MyStack<String> stack = new MyStack<>(expr.length());//expr抓取字段（）
 String postfix = "";//赋空值
 int i = 0;
 while(i<expr.length()){//
     char ch = expr.charAt(i);//取第i个字符
     switch (ch){
         case  '+':
         case  '-':while(!stack.isEmpty() && !stack.get().equals("("))
             postfix += stack.pop();
             //postfix += " ";
             stack.push(ch + "");
             i++;
             break;
         case '*':
         case '/':while (!stack.isEmpty() && (stack.get().equals("*")||stack.get().equals("/")))
             postfix += stack.pop();
             //postfix += " ";
             stack.push(ch + "");
             i++;
             break;
         case '(':stack.push(ch + "");
             i++;
             break;
         case ')':String out = stack.pop();
             while(out!=null && !out.equals("(")){
                 postfix += out;
                 out = stack.pop();
                 //postfix += " ";
             }
             i++;
             break;
         default:while(i < expr.length() && ch>='0' && ch<='9'){
             postfix += ch;
             i++;
             if(i<expr.length())
                 ch = expr.charAt(i);
         }
             postfix += " ";
     }
 }
 while (!stack.isEmpty())
     postfix += stack.pop();
 return postfix;
 }
 }

然后加入建立栈的MyStack.java

 interface SStack<T> {//栈接口，栈数据抽象类型
boolean isEmpty();//判断是否空栈
void push(T x);//元素x入栈
T pop();//出栈，返回当前栈顶元素
T get();//取栈顶元素
}
public class MyStack<T> implements SStack<T> {
private Object element[];//储存数据数组
private int top;//栈顶元素下标
public MyStack(int size){//容纳大小为size的栈
    this.element = new Object[Math.abs(size)];
    this.top = -1;
}
public MyStack() {
    this(64);//栈大小为64
}
public boolean isEmpty() {
    return this.top == -1;//空栈栈顶元素为-1
}
public void push(T x) {//元素x入栈
    if(x==null)
        return;//栈空时不如栈
    if(this.top == element.length-1){//栈满时，申请更大空间
        Object[] temp = this.element;
        this.element = new Object[temp.length*2];
        for(int i = 0; i < temp.length; i++)
            this.element[i] = temp[i];
    }
    this.top++;
    this.element[this.top] = x;
}
public T pop() {
    return this.top==-1 ? null:(T)this.element[this.top--];//弹栈
}
public T get() {
    return this.top==-1 ? null:(T)this.element[this.top];//取元素
}
}

最后不要忘记加入MyDC.java(求后缀表达式的值）

import java.util.Stack;
/**
* Created by dell on 2017/5/24.
*/
public class MyDC {
/** constant for addition symbol */
private final char ADD = '+';
/** constant for subtraction symbol */
private final char SUBTRACT = '-';
/** constant for multiplication symbol */
private final char MULTIPLY = '*';
/** constant for division symbol */
private final char DIVIDE = '/';

public int value(String postfix){
    Stack<Integer> stack = new Stack();
    int i = 0, result = 0;
    while(i < postfix.length()){
        char ch = postfix.charAt(i);
        if(ch>='0' && ch<='9'){
            result = 0;
            while(ch!=' '){
                result = result*10 + Integer.parseInt(ch+"");
                i++;
                ch = postfix.charAt(i);
            }
            i++;
            stack.push(new Integer(result));
        }
        else{
            int y = stack.pop().intValue();
            int x = stack.pop().intValue();
            switch (ch){
                case ADD:
                    result = x + y;
                    break;
                case SUBTRACT:
                    result = x - y;
                    break;
                case MULTIPLY:
                    result = x * y;
                    break;
                case DIVIDE:
                    result = x / y;
            }
            stack.push(new Integer(result));
            i++;
        }
    }
    return stack.pop().intValue();
}
}

到此，已经把所以代码编写完成，最后加入测试代码

import java.util.Scanner;

public class MyDCtest {
public static void main(String [] args) {
    String expression;
    int result;
    try
    {
        Scanner in = new Scanner(System.in);
        MyDC evaluator = new MyDC();
        System.out.println ("Enter a valid infix expression: ");
        expression = in.nextLine();
        String postfix = MyBC.toPostfix(expression);
        System.out.println ("The postfix expression is :" + postfix);
        result = evaluator.value (postfix);
        System.out.println ("That expression equals :" + result);
    }
    catch (Exception IOException)
    {
        System.out.println("Input exception reported");
    }
}
}

之后运行MyDCtest就可以了
1296460-20180601204354961-513250756.png

实验五 网络编程与安全-2

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

  1. 注意责任归宿，要会通过测试证明自己没有问题
  1. 基于Java Socket实现客户端/服务器功能，传输方式用TCP
  1. 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能
    转化为后缀表达式，把后缀表达式通过网络发送给服务器
  1. 服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
  1. 客户端显示服务器发送过来的结果
  1. 上传测试结果截图和码云链接

我在本实验中负责服务端；
编写服务端代码Service.java

import java.net.*;
import java.io.*;
public class Service{
public static void main(String srgs[]) {
    ServerSocket sc = null;
    Socket socket=null;
    try {
        MyDC evaluator = new MyDC();
        sc= new ServerSocket(2018);//创建服务器套接字
        System.out.println("端口号:" + sc.getLocalPort());
        System.out.println("服务器已经启动...");
        socket = sc.accept();   //等待客户端连接
        System.out.println("已经建立连接");
        //获得网络输入流对象的引用
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        获得网络输出流对象的引用
        PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),true);
        String aline=in.readLine();//读取客户端传送来的数据
        System.out.println("从客户端接收到信息为："+aline); //通过网络输出流返回结果给客户端
        int result = evaluator.value(aline);
        out.println("Echo:" + result);
        out.close();
        in.close();
        sc.close();
    } catch (Exception e) {
        System.out.println(e);
    }
}
    }

之后运行Service.java

1296460-20180601204822054-10155791.png

实验五 网络编程与安全-3

加密结对编程：1人负责客户端，一人负责服务器

  1. 注意责任归宿，要会通过测试证明自己没有问题
  2. 基于Java Socket实现客户端/服务器功能，传输方式用TCP
  3. 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器
  4. 服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
  5. 客户端显示服务器发送过来的结果
  6. 上传测试结果截图和码云链接

在本任务中我负责服务端，但是因为我在这个代码的基础上做了后两个实验，所以代码我贴在了检查点5里。

1296460-20180601205053119-1991096203.png

实验五 网络编程与安全-4

密钥分发结对编程：1人负责客户端，一人负责服务器

  1. 注意责任归宿，要会通过测试证明自己没有问题
  2. 基于Java Socket实现客户端/服务器功能，传输方式用TCP
  3. 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文发送给服务器
  4. 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
  5. 服务器接收到后缀表达式表达式后，进行解密，然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
  6. 客户端显示服务器发送过来的结果
  7. 上传测试结果截图和码云链接

在这个检查点里添加了DH算法的密钥Key_DH.java

import java.io.*;
import java.math.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import javax.crypto.interfaces.*;

public class Key_DH{

private static final byte skip1024ModulusBytes[] = {
        (byte)0xF4, (byte)0x88, (byte)0xFD, (byte)0x58,
        (byte)0x4E, (byte)0x49, (byte)0xDB, (byte)0xCD,
        (byte)0x20, (byte)0xB4, (byte)0x9D, (byte)0xE4,
        (byte)0x91, (byte)0x07, (byte)0x36, (byte)0x6B,
        (byte)0x33, (byte)0x6C, (byte)0x38, (byte)0x0D,
        (byte)0x45, (byte)0x1D, (byte)0x0F, (byte)0x7C,
        (byte)0x88, (byte)0xB3, (byte)0x1C, (byte)0x7C,
        (byte)0x5B, (byte)0x2D, (byte)0x8E, (byte)0xF6,
        (byte)0xF3, (byte)0xC9, (byte)0x23, (byte)0xC0,
        (byte)0x43, (byte)0xF0, (byte)0xA5, (byte)0x5B,
        (byte)0x18, (byte)0x8D, (byte)0x8E, (byte)0xBB,
        (byte)0x55, (byte)0x8C, (byte)0xB8, (byte)0x5D,
        (byte)0x38, (byte)0xD3, (byte)0x34, (byte)0xFD,
        (byte)0x7C, (byte)0x17, (byte)0x57, (byte)0x43,
        (byte)0xA3, (byte)0x1D, (byte)0x18, (byte)0x6C,
        (byte)0xDE, (byte)0x33, (byte)0x21, (byte)0x2C,
        (byte)0xB5, (byte)0x2A, (byte)0xFF, (byte)0x3C,
        (byte)0xE1, (byte)0xB1, (byte)0x29, (byte)0x40,
        (byte)0x18, (byte)0x11, (byte)0x8D, (byte)0x7C,
        (byte)0x84, (byte)0xA7, (byte)0x0A, (byte)0x72,
        (byte)0xD6, (byte)0x86, (byte)0xC4, (byte)0x03,
        (byte)0x19, (byte)0xC8, (byte)0x07, (byte)0x29,
        (byte)0x7A, (byte)0xCA, (byte)0x95, (byte)0x0C,
        (byte)0xD9, (byte)0x96, (byte)0x9F, (byte)0xAB,
        (byte)0xD0, (byte)0x0A, (byte)0x50, (byte)0x9B,
        (byte)0x02, (byte)0x46, (byte)0xD3, (byte)0x08,
        (byte)0x3D, (byte)0x66, (byte)0xA4, (byte)0x5D,
        (byte)0x41, (byte)0x9F, (byte)0x9C, (byte)0x7C,
        (byte)0xBD, (byte)0x89, (byte)0x4B, (byte)0x22,
        (byte)0x19, (byte)0x26, (byte)0xBA, (byte)0xAB,
        (byte)0xA2, (byte)0x5E, (byte)0xC3, (byte)0x55,
        (byte)0xE9, (byte)0x2F, (byte)0x78, (byte)0xC7
};
// The SKIP 1024 bit modulus
private static final BigInteger skip1024Modulus
        = new BigInteger(1, skip1024ModulusBytes);
// The base used with the SKIP 1024 bit modulus
private static final BigInteger skip1024Base = BigInteger.valueOf(2);
public static void main(String args[ ]) throws Exception{
    DHParameterSpec DHP=
            new DHParameterSpec(skip1024Modulus,skip1024Base);

    KeyPairGenerator kpg= KeyPairGenerator.getInstance("DH");
    kpg.initialize(DHP);
    KeyPair kp=kpg.genKeyPair();

    PublicKey pbk=kp.getPublic();
    PrivateKey prk=kp.getPrivate();
    // 保存公钥
    FileOutputStream  f1=new FileOutputStream(args[0]);
    ObjectOutputStream b1=new  ObjectOutputStream(f1);
    b1.writeObject(pbk);
    // 保存私钥
    FileOutputStream  f2=new FileOutputStream(args[1]);
    ObjectOutputStream b2=new  ObjectOutputStream(f2);
    b2.writeObject(prk);
}
}

接着加入Key_Agree.java

import java.io.*;
import java.math.*;
import java.security.*;
import java.security.spec.* ;
import javax.crypto.*;
import javax.crypto.spec.*;
import javax.crypto.interfaces.*;

public class Key_Agree{
public static void main(String args[ ]) throws Exception{
    // 读取对方的DH公钥
    FileInputStream f1=new FileInputStream(args[0]);
    ObjectInputStream b1=new ObjectInputStream(f1);
    PublicKey  pbk=(PublicKey)b1.readObject( );
//读取自己的DH私钥
    FileInputStream f2=new FileInputStream(args[1]);
    ObjectInputStream b2=new ObjectInputStream(f2);
    PrivateKey  prk=(PrivateKey)b2.readObject( );
    // 执行密钥协定
    KeyAgreement ka=KeyAgreement.getInstance("DH");
    ka.init(prk);
    ka.doPhase(pbk,true);
    //生成共享信息
    byte[ ] sb=ka.generateSecret();
    for(int i=0;i<sb.length;i++){
        System.out.print(sb[i]+",");
    }
    SecretKeySpec k=new  SecretKeySpec(sb,"DESede");
}
}

1296460-20180601205329361-1030369886.png

实验五 网络编程与安全-5

完整性校验结对编程：1人负责客户端，一人负责服务器

  1. 注意责任归宿，要会通过测试证明自己没有问题
  2. 基于Java Socket实现客户端/服务器功能，传输方式用TCP
  3. 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文和明文的MD5値发送给服务器
  4. 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
  5. 服务器接收到后缀表达式表达式后，进行解密，解密后计算明文的MD5值，和客户端传来的MD5进行比较，一致则调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
  6. 客户端显示服务器发送过来的结果
  7. 上传测试结果截图和码云链接

我负责服务器端

import java.net.*;
import java.io.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import javax.crypto.interfaces.*;
import java.security.interfaces.*;
import java.math.*;

public class ServiceDecode {
public static void main(String args[]) throws Exception {
    ServerSocket link = null;
    Socket socket = null;
    try {
        link = new ServerSocket(2018);// 创建服务器套接字
        System.out.println("端口号:" + link.getLocalPort());
        System.out.println("服务器已经启动...");
        socket = link.accept(); // 等待客户端连接
        System.out.println("已经建立连接");
        //获得网络输入流对象的引用
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        //获得网络输出流对象的引用
        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
        // 使用服务器端RSA的私钥对DES的密钥进行解密

        String line = in.readLine();
        BigInteger cipher = new BigInteger(line);
        FileInputStream f = new FileInputStream("Skey_RSA_priv.dat");
        ObjectInputStream b = new ObjectInputStream(f);
        RSAPrivateKey prk = (RSAPrivateKey) b.readObject();
        BigInteger d = prk.getPrivateExponent();
        BigInteger n = prk.getModulus();//mod n
        BigInteger m = cipher.modPow(d, n);//m=d (mod n)
        System.out.println("d= " + d);
        System.out.println("n= " + n);
        System.out.println("m= " + m);
        byte[] keykb = m.toByteArray();
        // 使用DES对密文进行解密
        String readline = in.readLine();//读取客户端传送来的数据
        FileInputStream f2 = new FileInputStream("keykb1.dat");
        int num2 = f2.available();
        byte[] ctext = parseHexStr2Byte(readline);
        Key k = new SecretKeySpec(keykb,"DESede");
        Cipher cp = Cipher.getInstance("DESede");
        cp.init(Cipher.DECRYPT_MODE, k);
        byte[] ptext = cp.doFinal(ctext);
        String p = new String(ptext, "UTF8");//编码转换
        System.out.println("从客户端接收到信息为：" + p); //打印解密结果
        // 使用Hash函数检测明文完整性
        String aline3 = in.readLine();
        String x = p;
        MessageDigest m2 = MessageDigest.getInstance("MD5");//使用MD5算法返回实现指定摘要算法的 MessageDigest对象
        m2.update(x.getBytes());
        byte a[] = m2.digest();
        String result = "";
        for (int i = 0; i < a.length; i++) {
            result += Integer.toHexString((0x000000ff & a[i]) | 0xffffff00).substring(6);
        }
        System.out.println(result);
        if (aline3.equals(result)) {
            System.out.println("匹配成功");
        }
        MyDC evaluator = new MyDC();
        int _result = evaluator.value(p);
        out.println("Echo:" + _result);
        out.close();
        in.close();
        link.close();
    } catch (Exception e) {
        System.out.println(e);
    }
}
//二进制转换成十六进制，防止byte[]数字转换成string类型时造成的数据损失
public static String parseByte2HexStr(byte buf[]) {
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < buf.length; i++) {
        String hex = Integer.toHexString(buf[i] & 0xFF);
        if (hex.length() == 1) {
            hex = '0' + hex;
        }
        sb.append(hex.toUpperCase());//将字符串中的小写字母转换成大写字母,然后加在字符串上
    }
    return sb.toString();
}
//将十六进制转换为二进制
public static byte[] parseHexStr2Byte(String hexStr) {
    if (hexStr.length() < 1)
        return null;
    byte[] result = new byte[hexStr.length() / 2];
    for (int i = 0; i < hexStr.length() / 2; i++) {
        int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1),16);
        int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2),16);
        result[i] = (byte) (high * 16 + low);
    }
    return result;
}
}

1296460-20180601205459683-1050001851.png

遇到的问题及方法

1296460-20180601205550116-1322312727.png

解决方法：将public去掉解决

实验感想

  1. 这个实验大部分我都不会做，基本都是看学姐的代码然后自己争取看懂
  2. 在做检查点一时，学会了栈的建立，当时是每一句都百度，但是其实就发现是常规方法，也算是学习了。
posted on 2018-06-01 21:26 mushroom1111 阅读( ...) 评论( ...) 编辑 收藏

转载于:https://www.cnblogs.com/mushroomissmart/p/9123497.html

weixin_30821731
关注
Java数据结构与算法第五课——栈和队列
baijaiyu的博客
05-29 738
一：栈 1.栈的定义 栈式一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据在栈顶。 2.栈的模拟实现 从上图中可以看到，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vecto...
Java数据结构-栈
一个射手座程序猿
08-18 139
以将数组添加到栈中为例，演示栈弹出数据，访问栈顶元素、判断栈是否为空、判断栈是否满了 public class MyStack { // 定义数组的最大长度 private int maxsize; // 定义一个数组 private long[] arr; // 定义栈顶 private int top; // 构造方法 public MyStack(int size) {...
Java 数据结构之栈、队列(头歌平台，详细注释)
qwertf123的博客
10-09 2404
Java 数据结构之栈、队列
栈的实现及应用
xujia的博客
12-27 605
栈是一种“先入后出”的数据结构，只允许在一端增加和删除数据，其主要操作有push（入栈）、pop（出栈）和peek（查看）三种。在本文采用数组的方式来实现栈，结合下图进行讲解。 push（入栈） 执行该操作时向栈中插入一个数据项。在插入的过程中，top先增加1（向上移动一个单元），再将数据项插入栈中。当栈满时，top等于数组容量的大小size-1，指向栈的最顶端。 pop（出栈） 执行该操作...
java数据结构——数组实现栈结构
司新博的博客
10-09 213
package Stack; import org.junit.Test; import java.util.Stack; //数组实现一个栈:此时栈中数据元素类型为整形 public class MyStack_Array&lt;T&gt; { //存数据的数组 T[] data; //栈的最大长度 private int size; //栈顶...
南京邮电大学-课程实验-计算机通信与网络实验-实验报告和源码说明.zip
05-12
南京邮电大学的这门计算机通信与网络实验课程是一门深入理解网络协议和技术的重要实践环节。实验报告和源码说明提供了学生们在实验过程中对理论知识的直观应用和深入理解。以下将详细介绍每个实验以及相关知识点。 ...
网络安全实验报告五_网络安全实验_
09-28
网络安全实验报告五主要聚焦于一个常见的安全问题——缓冲区溢出漏洞。在计算机科学中，缓冲区溢出是由于程序尝试向固定大小的内存区域（缓冲区）写入超出其容量的数据，导致相邻内存区域的数据被覆盖。这种现象可能...
南京信息工程大学-网络大作业-上机实验与报告内含源码和说明书.zip
最新发布
05-15
该压缩包文件“南京信息工程大学-网络大作业-上机实验与报告内含源码和说明书.zip”包含了多个与网络技术相关的学习资料，适用于学生完成网络课程的实验和报告。以下是这些文件所涵盖的知识点： 1. **实验三：三层...
广工c#网络应用编程-实验报告
01-01
通过编写实验报告，学生能够系统地回顾和总结他们在实验过程中的学习成果和遇到的问题，进一步加深对C#网络编程的理解。 【标签】：“广工c#”指代广东工业大学的C#课程，“网络应用编程”意味着实验重点在于使用C#...
华科-计算机网络实验报告-Java_Socket编程-网络组建实验.docx
11-25
"华科-计算机网络实验报告-Java_Socket编程-网络组建实验.docx" 这份实验报告主要涵盖了计算机网络实验的两个部分：Socket 编程和网络组建实验。下面是对这两部分的详细解释和知识点总结： Socket 编程 Socket ...
Java 模拟栈结构
weixin_34112030的博客
04-17 104
栈和队列： 通常是作为程序猿的工具，用于辅助构思算法。生命周期较短，执行时才被创建 訪问受限。在特定时刻，仅仅有一个数据可被读取或删除 是一种抽象的结构。内部的实现机制。对用户不可见。比方用数组、链表来实现栈 栈： 同一时候，仅仅同意一个数据被訪问，后进先出 对于入栈和出栈的时间复杂度都为O(1),即不依赖栈内数据项的个数，操作比較快 例，使用数组作为栈的存储结构 ...
数组实现栈
xiaoxiaoxiaopb的博客
09-08 805
栈 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 数组实现栈 代码如下 public class ArrayStack { private int maxSize; private int top; p
Java数据结构之栈
weixin_34212762的博客
12-07 93
packagecom.xingej.algorithm.datastructure.stack; /** *数据结构之栈Stack * *以long类型为测试用例 * *@authorerjun2017年12月4日下午10:22:34 */ publicclassLongStack{ //底层数据存储 privatel...
用java代码实现一个自己的栈.
wangyang2698341的专栏
09-08 808
//转载raozhiyong11的package com.rao.util;     import java.util.EmptyStackException;   import java.util.Stack;     public class MyStack<E> {              private E[] eleDates;   //数组对象       private int topIndex;   //最上一个元素(栈顶元素)的下标       private int count;   
【Java数据结构】栈与队列详解
耀的博客
11-28 2664
Java数据结构---栈与队列详解
c#自定义栈
weixin_30920853的博客
10-04 135
栈的原理是先进后出。队列是先进先出。栈像乘坐电梯，后进的先出去。队列就是排队。 实现代码： public class myStack<T> { private int top; private T[] stkArr; private int maxSize; /// <summary...
java 栈 实现_Java实现栈
weixin_34621896的博客
02-20 81
本文中栈使用数组实现的，栈一般有2个属性：大小，栈顶2个状态：栈空，栈满3个方法：压栈，弹栈，查看栈顶元素package com.demo;public class MyStack {private T data[];// 数组实现栈private int maxSize;// 栈的大小private int top;// 栈顶/*** 构造方法，初始化* @author hushuli* @pa...
java之MyStack实现
梦
03-06 2211
1.堆栈是一种线性的操作权限受限的数据结构，先进后出。2.代码实现:package com.oop.collection.stack; public class MyStack&lt;E&gt; { /* * 栈的最大深度 * */ private int MAX_DEPTH = 10; /* * 栈的当前深度 * */ private int depth = 0;...
java基础002
热门推荐
u014163736的博客
04-29 4万+
试卷一2013年年底的时候，我看到了网上流传的一个叫做《Java面试题大全》的东西，认真的阅读了以后发现里面的很多题目是重复且没有价值的题目，还有不少的参考答案也是错误的，于是我花了半个月时间对这个所谓的《Java面试大全》进行了全面的修订并重新发布在我的CSDN博客。在修订的过程中，参照了当时JDK最新版本（Java 7）给出了题目的答案和相关代码，去掉了EJB 2.x、JSF等无用内容或过时内...
Wireshark网络协议分析实验-HTTP与TCP协议探索
"哈尔滨工业大学计算机网络实验报告，主要涉及Wireshark工具的...通过本次实验，学生不仅熟练掌握了Wireshark工具的使用，还深化了对网络协议实体间交互方式的理解，为后续的网络编程和网络安全学习奠定了坚实的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值