JFrame动态显示距离矢量算法过程

最新推荐文章于 2025-10-23 11:07:12 发布
原创 最新推荐文章于 2025-10-23 11:07:12 发布 · 238 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了一种基于Java Swing的图形用户界面实现距离矢量路由算法的过程。通过按钮动作监听，更新并显示每次迭代后的距离矩阵和下一跳节点，实现了动态展示距离矢量路由算法的运行过程。

基本的按钮动作监听

多个同样的文本域可以用数组做。

package disvec;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.util.*;

public class Main extends JFrame implements ActionListener, FocusListener {
    int[][] dist;
    int[][] jmp;
    final int NN=9;
    int [][] map;
    JPanel picPanel;
    JTextArea listA;
    JTextArea listB;
    JTextArea listC;
    JTextArea listD;
    JTextArea listE;
    JTextArea listF;
    JTextArea listG;
    JTextArea listH;
    JPanel A;
    JPanel B;
    JPanel C;
    JPanel D;
    JPanel E;
    JPanel F;
    JPanel G;
    JPanel H;
    JLabel pic ;
    JButton next;
    final  int n=8;
    final  int oo=1000000010;
    int[][] olddist,oldjmp;
    public void initArray(){
        olddist=new int[NN][NN];
        oldjmp=new int[NN][NN];
        map = new int[][]{
            {oo,oo,oo,oo,oo,oo,oo,oo,oo},
            {oo,0,2,oo,oo,oo,oo,6,oo},
            {oo,2,0,7,oo,2,oo,oo,oo},
            {oo,oo,7,0,3,oo,3,oo,oo},
            {oo,oo,oo,4,0,oo,oo,oo,2},
            {oo,oo,2,oo,oo,0,2,1,oo},
            {oo,oo,oo,3,oo,2,0,oo,2},
            {oo,6,oo,oo,oo,1,oo,0,4},
            {oo,oo,oo,oo,2,oo,2,4,0}
        };
        dist= new int[NN][NN];
        jmp=new int[NN][NN];
        for(int i=1;i<=n;i++)for(int j=1;j<=n;j++){
            dist[i][j]=map[i][j];
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(dist[i][j]<oo)jmp[i][j]=j;
                else jmp[i][j]=-1;
            }
        }
    }
    public void initPicPanel(){
        picPanel =new JPanel();
        picPanel.setPreferredSize(new Dimension(1100, 200));
        picPanel.setBackground(Color.white);
        picPanel.setBorder(BorderFactory.createTitledBorder("Map"));
        picPanel.add(pic);
    }
    public void initTexField(){
        listA=new JTextArea();
        listB=new JTextArea();
        listC=new JTextArea();
        listD=new JTextArea();
        listE=new JTextArea();
        listF=new JTextArea();
        listG=new JTextArea();
        listH=new JTextArea();
        A=new JPanel();
        B=new JPanel();
        C=new JPanel();
        D=new JPanel();
        E=new JPanel();
        F=new JPanel();
        G=new JPanel();
        H=new JPanel();
        A.setPreferredSize(new Dimension(135, 300));
        A.setBackground(Color.white);
        A.setBorder(BorderFactory.createTitledBorder("listA"));
        A.add(listA);
        B.setPreferredSize(new Dimension(135, 300));
        B.setBackground(Color.white);
        B.setBorder(BorderFactory.createTitledBorder("listB"));
        B.add(listB);
        C.setPreferredSize(new Dimension(135, 300));
        C.setBackground(Color.white);
        C.setBorder(BorderFactory.createTitledBorder("listC"));
        C.add(listC);
        D.setPreferredSize(new Dimension(135, 300));
        D.setBackground(Color.white);
        D.setBorder(BorderFactory.createTitledBorder("listD"));
        D.add(listD);
        E.setPreferredSize(new Dimension(135, 300));
        E.setBackground(Color.white);
        E.setBorder(BorderFactory.createTitledBorder("listE"));
        E.add(listE);
        F.setPreferredSize(new Dimension(135, 300));
        F.setBackground(Color.white);
        F.setBorder(BorderFactory.createTitledBorder("listF"));
        F.add(listF);
        G.setPreferredSize(new Dimension(135, 300));
        G.setBackground(Color.white);
        G.setBorder(BorderFactory.createTitledBorder("listG"));
        G.add(listG);
        H.setPreferredSize(new Dimension(135, 300));
        H.setBackground(Color.white);
        H.setBorder(BorderFactory.createTitledBorder("listH"));
        H.add(listH);
    }
    public void initButton(){
        next=new JButton("next time");
        next.addActionListener(this);
    }
    public void makeFrame(){
        this.setTitle("Distance Vector Routing");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLayout(new FlowLayout());
        this.add(picPanel);
        this.add(A);
        this.add(B);
        this.add(C);
        this.add(D);
        this.add(E);
        this.add(F);
        this.add(G);
        this.add(H);
        this.add(next);
        this.setVisible(true);
        this.setSize(1200,600);
    }
    void BellmanFord(){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                olddist[i][j]=dist[i][j];
                oldjmp[i][j]=jmp[i][j];
            }
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(j==i)continue;
                if(map[i][j]<oo){
                    for(int k=1;k<=8;k++){
                        if(olddist[j][k]<oo){
                            if(olddist[i][k]>=oo){//i表没有项目k
                                dist[i][k]=olddist[j][k]+map[i][j];
                                jmp[i][k]=j;
                            }
                            else{
                                if(oldjmp[i][k]!=j){
                                    if(olddist[j][k]+map[i][j]<olddist[i][k]){
                                        dist[i][k]=olddist[j][k]+map[i][j];
                                        jmp[i][k]=j;
                                    }
                                }
                                else{
                                    dist[i][k]=olddist[i][j]+olddist[j][k];
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    public void display(){
        listA.setText("");
        for(int i=1;i<=n;i++){
            char cc= (char) ('A'+i-1);
            char cc2= (char) ('A'+jmp[1][i]-1);
            if(i==1||dist[1][i]>=oo)listA.append(cc+" "+"N"+" "+"/"+"\n");
            else listA.append(cc+" "+dist[1][i]+" "+cc2+"\n");
        }
        listB.setText("");
        for(int i=1;i<=n;i++){
            char cc= (char) ('A'+i-1);
            char cc2= (char) ('A'+jmp[2][i]-1);
            if(i==2||dist[2][i]>=oo)listB.append(cc+" "+"N"+" "+"/"+"\n");
            else listB.append(cc+" "+dist[2][i]+" "+cc2+"\n");
        }
        listC.setText("");
        for(int i=1;i<=n;i++){
            char cc= (char) ('A'+i-1);
            char cc2= (char) ('A'+jmp[3][i]-1);
            if(i==3||dist[3][i]>=oo)listC.append(cc+" "+"N"+" "+"/"+"\n");
            else listC.append(cc+" "+dist[3][i]+" "+cc2+"\n");
        }
        listD.setText("");
        for(int i=1;i<=n;i++){
            char cc= (char) ('A'+i-1);
            char cc2= (char) ('A'+jmp[4][i]-1);
            if(i==4||dist[4][i]>=oo)listD.append(cc+" "+"N"+" "+"/"+"\n");
            else listD.append(cc+" "+dist[4][i]+" "+cc2+"\n");
        }
        listE.setText("");
        for(int i=1;i<=n;i++){
            char cc= (char) ('A'+i-1);
            char cc2= (char) ('A'+jmp[5][i]-1);
            if(i==5||dist[5][i]>=oo)listE.append(cc+" "+"N"+" "+"/"+"\n");
            else listE.append(cc+" "+dist[5][i]+" "+cc2+"\n");
        }
        listF.setText("");
        for(int i=1;i<=n;i++){
            char cc= (char) ('A'+i-1);
            char cc2= (char) ('A'+jmp[6][i]-1);
            if(i==6||dist[6][i]>=oo)listF.append(cc+" "+"N"+" "+"/"+"\n");
            else listF.append(cc+" "+dist[6][i]+" "+cc2+"\n");
        }
        listG.setText("");
        for(int i=1;i<=n;i++){
            char cc= (char) ('A'+i-1);
            char cc2= (char) ('A'+jmp[7][i]-1);
            if(i==7||dist[7][i]>=oo)listG.append(cc+" "+"N"+" "+"/"+"\n");
            else listG.append(cc+" "+dist[7][i]+" "+cc2+"\n");
        }
        listH.setText("");
        for(int i=1;i<=n;i++){
            char cc= (char) ('A'+i-1);
            char cc2= (char) ('A'+jmp[8][i]-1);
            if(i==8||dist[8][i]>=oo)listH.append(cc+" "+"N"+" "+"/"+"\n");
            else listH.append(cc+" "+dist[8][i]+" "+cc2+"\n");
        }
    }
    public Main(){
        pic = new JLabel(new ImageIcon("D:\\disVec\\src\\disvec\\图片1.png"));
        initArray();
        initPicPanel();
        initTexField();
        initButton();
        makeFrame();
        display();
    }
    public void actionPerformed(ActionEvent e) {
        if(e.getSource()==next){
            BellmanFord();
            display();
        }
    }
    public void focusGained(FocusEvent e) {
        ;
    }
    public void focusLost(FocusEvent e) {
        ;
    }
    public static void main(String[] args) {
        new Main();
    }

}

效果

在这里插入图片描述

DV、LS路由算法Java编程实现
weixin_57671089的博客
06-17 1556
DV、LS路由算法java编程实现
在Java绘图坐标原点在_java 绘图
weixin_31655833的博客
02-27 1209
java 绘图圆形、线条、矩形、填充插入图片文字//绘图import java.awt.*;import javax.swing.*;public class Index extends JFrame{public static void main(String[] args) throws Exception{//实例化当前类Index index = new Index();}//自动执行pu...
java实现基于距离向量算法 路由协议
sinat_32092165的博客
11-23 7150
算法就不多说了，该程序实现的功能：首先你要将网络结构转化成邻接矩阵，每个路由器对应一行，若路由器m与网络n直接相连，则m行n列为1，否则为0 该程序的路由器和网络都从0开始编号 首先创建Table类，代表路由器的路由表 public class Table { public int hostId;//哪个路由器的路由表 public int netId;//目的网络的id
距离矢量路由算法的java代码_八大排序算法比较（附Java代码）
weixin_39987847的博客
12-02 376
冒泡排序/** * 冒泡排序 比较好理解 * 两两相比 较大的放后面 * 时间复杂度O(n^2) */ /** * 改进前的冒泡排序算法进行100,000数据排序运行时间为：3829ms * 优化后的冒泡排序算法进行100,000数据排序运行时间为：3551ms */ public static void bubbleSort(int[] array){ //原始的冒泡排序，比较的...
路由选择矢量距离java,距离矢量路由算法
weixin_31174767的博客
03-13 716
现代计算机网络通常使用动态路由算法，因为这类算法能够适应网络的拓扑和流量变化，其中最流行的两种动态路由算法是“距离矢量路由算法”和“链路状态路由算法”。距离矢量路由算法(Distance Vector Routing，DV)是ARPANET网络上最早使用的路由算法，也称Bellman-Ford路由算法和Ford-Fulkerson算法，主要在RIP(Route Information Protoc...
【Java图形学数学基础】：图形算法背后的数学原理
图形学是计算机科学的一个分支，它研究如何使用计算机生成、处理、存储和显示图形信息。图形学广泛应用于游戏开发、模拟仿真、虚拟现实以及医疗成像等领域。在Java中实现图形学功能，不仅可以提升用户界面的交互性，...
1、计算机图形学入门：使用 Java 2D 和 3D
最新发布
fanta的博客
10-23 16
本文介绍了计算机图形学的基础知识及其在Java 2D和Java 3D中的应用。内容涵盖从二维图形绘制、几何变换、动画实现，到三维建模、光照着色、可见性处理及特殊视觉效果的完整技术体系。通过丰富的代码示例和图表，帮助初学者理解光栅与矢量图形的区别、使用AffineTransform进行变换、实现抗锯齿与渐变填充，并深入探讨Java 3D中的场景图结构、动画插值、投影方式、表面建模以及虚拟现实相关技术如碰撞检测、LOD和立体观看等。适合具备Java基础的开发者学习图形编程入门。
JAVA电子地图开发教程与功能实现
- **测距工具**：测距功能允许用户在地图上选择两点，计算并显示这两点之间的实际距离。这可能需要用到地图的比例尺换算。 - **图层查询**：通过将地图划分为多个图层，用户可以查询特定类型的信息，如道路、河流...
Java核心技术· 卷二（11版）笔记（第 9-12章）
weixin_43647460的博客
11-16 797
Java平台模块系统是Java 9中引入的一个新特性，它可以更好地管理Java应用程序的依赖关系，提高应用程序的可扩展性和安全性。模块系统可以将Java应用程序的代码组织为独立的模块，每个模块都有自己的接口和实现。模块可以声明自己的依赖关系，并且只会导出需要公开的API，从而减少了依赖项的耦合性和可能出现的命名冲突。同时，模块系统还提供了更好的可见性和访问控制，允许开发人员更好地控制代码的复杂性和安全性。在Java 9的模块系统中，一个模块是一个可以进行依赖管理和版本控制的独立单元。每个模块都有自己的名称、
距离矢量算法（Distance Vector Algorithm）的动态路由
06-12
距离矢量算法（Distance Vector Algorithm）的动态路由
距离矢量路由算法
热门推荐
Mr.Phoebe的专栏
05-07 5万+
现代计算机网络通常使用动态路由算法，因为这类算法能够适应网络的拓扑和流量变化，其中最流行的两种动态路由算法是“距离矢量路由算法”和“链路状态路由算法”。     距离矢量路由算法（Distance Vector Routing，DV）是ARPANET网络上最早使用的路由算法，也称Bellman-Ford路由算法和Ford-Fulkerson算法，主要在RIP（Route Inform
RIP及距离向量算法
weixin_30533797的博客
10-09 2134
>>>预备知识 网络层提供两种服务： 虚电路服务 数据报服务 虚电路服务与数据报服务的对比 对比的方面 虚电路服务 数据报服务 思路 可靠通信由网络保证 可靠通信由终系统保证 连接的建立 必须有 不需要 终点地址 仅在连接建立阶段使用，每个分组使用短的虚电路号 每个分组都有终点的完整地址 分组...
计算机网络1-距离矢量路由算法模拟
bobo1356的博客
06-16 9735
距离矢量路由算法实验 一、实验要求 网络拓扑图 实验过程描述 1、将上面的网络拓扑图保存待用 例如，可用二维数组保存，数组下标或索引可隐含表示网络节点。数组元素保存网络拓扑图边上的权值 2、为每个网络节点初始化并保存一张路由表 例如，可以用单链表表示一个网络节点的路由表，单链表的每个结点存储一个表项信息；表项信息是一个三元组（目的节点，下一跳，开销），可用结构体表示...
软件构造心得（12）：关于JFrame、动态显示、与交互界面制作的入门级心得
weixin_43197820的博客
05-03 757
前言 GUI虽然不是我们软件构造课程的核心思想所在，但是却往往是一个软件设计者外在而直接的品味。当然抛开这些不谈，初次接触GUI如我，因为毫无基础，面对网上鱼龙混杂的说法真的尝试而且崩溃了好久，多亏陶神佬相助为我仙人指路，让我得以系统性的接触并且学习了相关的知识。这里逐步整理一下我的心得。因为内容较多，可能需要多更新几回… JFrame是什么 通过阅读书籍，发现JFrame和swing的历史是一个...
路由算法之距离矢量算法和链路状态算法
hanzhen7541的博客
01-11 4万+
我们之前说了，路由器需要对于每一对端端节点都要寻找出一个最佳的路径，比如说最小链路成本的路径。路由算法就是通过自己到相邻节点之间的信息来计算出自己到目的地址的最佳出境线路是哪一条，进而进行转发的一类算法。具有代表性的就是距离矢量算法和链路状态算法。         距离矢量算法的特点是：         1.分布的  每个节点接收来自与其直接邻接节点的路由信息，并执行路由计算，将计算结果回传给
JFrame窗口界面的动态显示
sinat_40553837的博客
12-04 5975
通过一个.remove（）删除其直接的控件。然后重绘重绘。 最后需要更新的JFrame窗口，进行刷新。 方法1.重新显示窗口 frame.setVisible(false); frame.setVisible(true); 方法2.重新验证窗体 frame.invalidate(); frame.validate(); 方法3.重置窗口大小 frame.pack(); fram...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值