Java:JGraphT使用循环添加边

是否可以通过使用循环向图形添加边？我正在分析一个字符串以确定适当的边和标签。出于某种原因，它只会在用于遍历字符串的while循环的第一轮中添加边。对于所有其他人，将显示以下消息

警告：已删除边，因为基础JGraphT图形拒绝创建它。当违反基础图的约束时，可能会发生这种情况，例如，试图向禁止它们的图添加平行边或自循环。要避免此消息，请确保使用合适的底层JGraphT图

import java.awt.*;
import java.awt.geom.*;

import javax.swing.*;

import org.jgraph.*;
import org.jgraph.graph.*;

import org.jgrapht.*;
import org.jgrapht.ext.*;
import org.jgrapht.graph.*;

// resolve ambiguity
import org.jgrapht.graph.DefaultEdge;

public class JGraphAdapterDemo
    extends JApplet
{

    private static final long serialVersionUID = 3256444702936019250L;
    private static final Color DEFAULT_BG_COLOR = Color.decode("#FAFBFF");
    private static final Dimension DEFAULT_SIZE = new Dimension(530, 320);

    static ListenableGraph<String, String> g =
        new ListenableDirectedMultigraph<String, String>(String.class);

    static int [] finalStates = new int[10];
    static int startState = 0;
    static char tran = ' ';
    static int endState = 0;

    private JGraphModelAdapter<String,String> jgAdapter;

    public static void main(String [] args)
    {
        JGraphAdapterDemo applet = new JGraphAdapterDemo();
        applet.init();

        JFrame frame = new JFrame();
        frame.getContentPane().add(applet);
        frame.setTitle("JGraphT Adapter to JGraph Demo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setVisible(true);
    }

    public void init()
    {
        // create a JGraphT graph
        ListenableGraph<String, String> g =
            new ListenableDirectedMultigraph<String, String>(String.class);

        // create a visualization using JGraph, via an adapter
        jgAdapter = new JGraphModelAdapter<String, String>(g);

        JGraph jgraph = new JGraph(jgAdapter);

        adjustDisplaySettings(jgraph);
        getContentPane().add(jgraph);
        resize(DEFAULT_SIZE);

        int numStates = 4;
        int numSymbols;
        int currentState;
        int i = 0;

            String input = "4 2 0 2 -1 0 a 1 1 b 3 2 c 2 3 c 3 -1";     //place input String here
            int readInt = 0;
            int j = 0;
            String str = "";
            int place = 0;
            String fState;

            //read in numStates, numSymbols, initialState
            i=0;

            //parse string 
            i = input.indexOf(" ",0);

            str = input.substring(0,i); //number of states
            numStates = Integer.parseInt(str);  //convert to int

            for(int k = 0; k< numStates; k++){
                g.addVertex("q"+k);
            }

            i++;
            j = i;

            i=input.indexOf(" ",j);

            str = input.substring(j,i); //number of symbols
            numSymbols = Integer.parseInt(str);

            i++;
            j = i;

            i=input.indexOf(" ",j);

            str = input.substring(j,i); //initial state
            currentState = Integer.parseInt(str);   

            i++;
            j = i;      

            //read in finalStates
            while(readInt!=-1){
                i=input.indexOf(" ",j);
                fState = input.substring(j,i);  //a final state
                readInt = Integer.parseInt(fState);
                if(readInt!=-1){
                    finalStates[place] = readInt;
                    i++;
                    j = i;
                    place++;
                }//end if
            }//end while
            i++;
            j = i;

            String sState;
            String eState;

            while(startState!=-1&& j<(input.length()-2)){           //until end of file
                i=input.indexOf(" ",j);
                sState = input.substring(j,i);  //start state
                startState = Integer.parseInt(sState);  //convert to int
                if(startState!=-1){             
                    i++;
                    j = i;

                    String cStr = "";
                    tran = input.charAt(i);         //transition
                    cStr = cStr + tran;
                    i = i+2;
                    j=i;        

                    i=input.indexOf(" ",j); 
                    eState = input.substring(j,i);      //end state
                    endState = Integer.parseInt(eState);

                    i++;
                    j=i;
                    String one = "q"+startState;
                    String two = "q"+endState;
                    System.out.println(one+ two +" "+cStr);
                    g.addEdge(one, two, cStr);

                    //drawEdge(one, two, cStr);

                }//end if

            }//end while

    }

    public static void drawEdge(String v, String v1, String label){
        System.out.println(v +" "+v1+ " "+label);
        g.addEdge(v,v1,label);
    }

    private void adjustDisplaySettings(JGraph jg)
    {
        jg.setPreferredSize(DEFAULT_SIZE);

        Color c = DEFAULT_BG_COLOR;
        String colorStr = null;

        try {
            colorStr = getParameter("bgcolor");
        } catch (Exception e) {
        }

        if (colorStr != null) {
            c = Color.decode(colorStr);
        }

        jg.setBackground(c);
    }

    @SuppressWarnings("unchecked") // FIXME hb 28-nov-05: See FIXME below
    private void positionVertexAt(Object vertex, int x, int y)
    {
        DefaultGraphCell cell = jgAdapter.getVertexCell(vertex);
        AttributeMap attr = cell.getAttributes();
        Rectangle2D bounds = GraphConstants.getBounds(attr);

        Rectangle2D newBounds =
            new Rectangle2D.Double(
                x,
                y,
                bounds.getWidth(),
                bounds.getHeight());

        GraphConstants.setBounds(attr, newBounds);

        // TODO: Clean up generics once JGraph goes generic
        AttributeMap cellAttr = new AttributeMap();
        cellAttr.put(cell, attr);
        jgAdapter.edit(cellAttr, null, null, null);
    }

    //~ Inner Classes ----------------------------------------------------------

    /**
     * a listenable directed multigraph that allows loops and parallel edges.
    // */
    private static class ListenableDirectedMultigraph<V, E>
    extends DefaultListenableGraph<V, E>
    implements DirectedGraph<V, E>
    {
    private static final long serialVersionUID = 1L;

    ListenableDirectedMultigraph(Class<E> edgeClass)
        {
        super(new DirectedMultigraph<V, E>(edgeClass));
        }
    }


}

import java.awt.*；
导入java.awt.geom.*；
导入javax.swing.*；
导入org.jgraph.*；
导入org.jgraph.graph.*；
导入org.jgrapht.*；
导入org.jgrapht.ext.*；
导入org.jgrapht.graph.*；
//解决歧义
导入org.jgrapht.graph.DefaultEdge；
公共类JGraphAdapterDemo
扩展JApplet
{
私有静态最终长serialVersionUID=3256444702936019250L；
私有静态最终颜色默认值_BG_Color=Color.decode（“#FAFBFF”）；
私有静态最终维度默认值_SIZE=新维度（530320）；
静态ListenableGraph g=
新的ListenableDirectedMultigraph（String.class）；
静态整数[]最终状态=新整数[10]；
静态int startState=0；
静态字符传输=“”；
静态int endState=0；
专用JGraphModelAdapter；
公共静态void main（字符串[]args）
{
JGraphAdapterDemo applet=新的JGraphAdapterDemo（）；
applet.init（）；
JFrame=新JFrame（）；
frame.getContentPane（）.add（小程序）；
frame.setTitle（“JGraph适配器到JGraph演示”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.pack（）；
frame.setVisible（true）；
}
公共void init（）
{
//创建JGraphT图
ListenableGraph g=
新的ListenableDirectedMultigraph（String.class）；
//通过适配器使用JGraph创建可视化
jgAdapter=新的JGraphModelAdapter（g）；
JGraph JGraph=新的JGraph（JGraph适配器）；
调整显示设置（jgraph）；
getContentPane（）.add（jgraph）；
调整大小（默认大小）；
int numStates=4；
整数符号；
int-currentState；
int i=0；
String input=“4 2 0 2-1 0 a 1 b 3 2 c 2 3 c 3-1”//将输入字符串放在此处
int readInt=0；
int j=0；
字符串str=“”；
int place=0；
字符串状态；
//读入numStates、numSymbols、initialState
i=0；
//解析字符串
i=input.indexOf（“，0”）；
str=input.substring（0，i）；//状态数
numStates=Integer.parseInt（str）；//转换为int
对于（int k=0；kwhile（startState！=-1&&j如果要使用允许循环的图形，则必须创建一个抽象类“AbstractBaseGraph”。因此，必须创建另一个扩展超类的类。下面是一个示例

public class MiGrafo
extends AbstractBaseGraph<String, DefaultEdge>
implements DirectedGraph<String, DefaultEdge> {

public MiGrafo() {// EdgeFactory<String, DefaultEdge> arg0, boolean arg1,boolean arg2
    super(new ClassBasedEdgeFactory<String, DefaultEdge>(
            DefaultEdge.class),
        true,
        true);
    // TODO Auto-generated constructor stub
}

公共类
扩展AbstractBaseGraph
实现DirectedGraph{
public MiGrafo（）{//EdgeFactory arg0、布尔arg1、布尔arg2
超级（新的ClassbasedGeFactory）(
DefaultEdge.class），
是的，
正确的）；
//TODO自动生成的构造函数存根
}

}

此外，您还必须实现扩展的有向或无向图

当您创建允许使用循环的新图形时，您只需编写以下语句：

MiGrafo h=new MiGrafo（）；

最后，您只需像使用简单图形一样使用该图形

再见。
您是否可能因为
numStates
的值无效而试图添加平行边？或者它是一个无向图，您试图添加另一条边（Vertex1->Vertex2和Vertex2->Vertex1），从而产生平行边？