Para exibir um gráfico visualmente, cada vértice deve receber uma localização. A seção anterior introduziu como modelar um gráfico usando a interface Graph, a classe AbstractGraph e a classe UnweightedGraph. Esta seção discute como exibir gráficos graficamente. Para exibir um gráfico, você precisa saber onde cada vértice é exibido e o nome de cada vértice. Para garantir que um gráfico possa ser exibido, definimos uma interface chamada Displayable que possui os métodos para obter as coordenadas x- e y- e seus nomes, e torne os vértices instâncias de Displayable, no código abaixo.

Um gráfico com vértices Displayable agora pode ser exibido em um painel chamado GraphView, conforme mostrado no código abaixo.

Para exibir um gráfico em um painel, simplesmente crie uma instância de GraphView passando o gráfico como um argumento no construtor (linha 9). A classe para o vértice do gráfico deve implementar a interface Displayable para exibir os vértices (linhas 13–22). Para cada índice de vértice i, invocar graph.getNeighbors(i) retorna sua lista de adjacências (linha 26). Nesta lista, você pode encontrar todos os vértices adjacentes a i e desenhar uma linha para conectar i com seu vértice adjacente (linhas 27–34).

O código abaixo dá um exemplo de exibição do gráfico na Figura acima, conforme mostrado na Figura abaixo.

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.stage.Stage;

public class DisplayUSMap extends Application {
    @Override // Override the start method in the Application class
    public void start(Stage primaryStage) {
        City[] vertices = {new City("Seattle", 75, 50),
                new City("San Francisco", 50, 210),
                new City("Los Angeles", 75, 275), new City("Denver", 275, 175),
                new City("Kansas City", 400, 245),
                new City("Chicago", 450, 100), new City("Boston", 700, 80),
                new City("New York", 675, 120), new City("Atlanta", 575, 295),
                new City("Miami", 600, 400), new City("Dallas", 408, 325),
                new City("Houston", 450, 360)};

        // Edge array for graph
        int[][] edges = {
                {0, 1}, {0, 3}, {0, 5}, {1, 0}, {1, 2}, {1, 3},
                {2, 1}, {2, 3}, {2, 4}, {2, 10},
                {3, 0}, {3, 1}, {3, 2}, {3, 4}, {3, 5},
                {4, 2}, {4, 3}, {4, 5}, {4, 7}, {4, 8}, {4, 10},
                {5, 0}, {5, 3}, {5, 4}, {5, 6}, {5, 7},
                {6, 5}, {6, 7}, {7, 4}, {7, 5}, {7, 6}, {7, 8},
                {8, 4}, {8, 7}, {8, 9}, {8, 10}, {8, 11},
                {9, 8}, {9, 11}, {10, 2}, {10, 4}, {10, 8}, {10, 11},
                {11, 8}, {11, 9}, {11, 10}
        };

        Graph graph = new UnweightedGraph(vertices, edges);

        // Create a scene and place it in the stage
        Scene scene = new Scene(new GraphView(graph), 750, 450);
        primaryStage.setTitle("DisplayUSMap"); // Set the stage title
        primaryStage.setScene(scene); // Place the scene in the stage
        primaryStage.show(); // Display the stage
    }

    public static void main(String[] args) {
        Application.launch(args);
    }

    static class City implements Displayable {
        private int x, y;
        private String name;

        City(String name, int x, int y) {
            this.name = name;
            this.x = x;
            this.y = y;
        }

        @Override
        public int getX() {
            return x;
        }

        @Override
        public int getY() {
            return y;
        }

        @Override
        public String getName() {
            return name;
        }
    }
}

A classe Cidade é definida para modelar os vértices com suas coordenadas e nomes (linhas 39–63). O programa cria um gráfico com os vértices do tipo Cidade (linha 30). Como City implementa Displayable, um objeto GraphView criado para o gráfico exibe o gráfico no painel (linha 33).