Error reading txt file line by line

The problem is that in the file you think nodes are numbered from 1 to 6 while using indexes numbered 0 to 5. Even there are some places where you use +1 or -1 because of that, but it does not use everywhere it should. Using checks on the parameters of Graph would be obvious.

However, there are a few other things that could be improved in your code. In particular that global variables are bad, you do not have to use System.exit and you have javadoc malformed. And it's also much easier to read all the lines of the file using Files.readAllLines(Path) method.

Here is the revised code:

import java.io.File;
import java.io.FileNotFoundException;
import java.nio.file.Files;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Graph subway = new Graph(6);

        System.out.println("Desenvolvido por Guilherme alves vieria dos santos");
        System.out.println("--------------------------------------------------");
        System.out.println("Digite o nome do arquivo: ");

        Scanner in = new Scanner(System.in);
        String arquivo = in.next();

        try {
            for (String linha : Files.readAllLines(new File(arquivo).toPath())) {
                String[] dadosLinha = linha.split(";");
                if (dadosLinha.length != 3) throw new IllegalArgumentException();
                int a = Integer.parseInt(dadosLinha[0]);
                int b = Integer.parseInt(dadosLinha[1]);
                int c = Integer.parseInt(dadosLinha[2]);
                subway.makeEdge(a - 1, b - 1, c - 1);
            }
        } catch (FileNotFoundException e) {
            System.out.println("Arquivo não encontrado, verifique se o caminho do arquivo está correto.");
            return;
        } catch (IllegalArgumentException e) {
            System.out.println("O arquivo contém dados malformados.");
            return;
        }

        while (true) {
            //int source = readStation("source", in);
            //int destination = readStation("destination", in);

            System.out.println("Caminho mais rápido: ");
            for (Integer station : subway.path(0/*source*/, 5/*destination*/)) {
                System.out.println((station + 1) + " -> ");
            }
            System.out.println("EXIT");
        }
    }

    private static int readStation(String type, Scanner in) {
        while (true) {
            System.out.println(type + ": ");
            String line = in.nextLine().trim();
            try {
                int station = Integer.parseInt(line);
                if (station >= 1 && station <= 6) return station - 1;
            } catch (NumberFormatException e) {
                // Ignora.
            }
            System.out.println("Invalid station! Try again.");
        }
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Graph {
    private static final int UNDEFINED = -1;
    private int vertices[][];

    public Graph(int numVertices) {
        if (numVertices < 0) throw new IllegalArgumentException();
        vertices = new int[numVertices][numVertices];
    }

    private void checkVertex(int vertex) {
        if (vertex < 0 || vertex >= vertices.length) throw new IllegalArgumentException();
    }

    public void makeEdge(int vertex1, int vertex2, int time) {
        checkVertex(vertex1);
        checkVertex(vertex2);
        if (time < 0) throw new IllegalArgumentException();
        vertices[vertex1][vertex2] = time;
        vertices[vertex2][vertex1] = time;
    }

    public void removeEdge(int vertex1, int vertex2) {
        checkVertex(vertex1);
        checkVertex(vertex2);
        vertices[vertex1][vertex2] = 0;
        vertices[vertex2][vertex1] = 0;
    }

    public int getCost(int vertex1, int vertex2) {
        checkVertex(vertex1);
        checkVertex(vertex2);
        return vertices[vertex1][vertex2];
    }

    /**
     * @param vertex Origin vertex
     * @return a list with the index of all vertexes connected to the given vertex.
     */
    public List<Integer> getNeighbors(int vertex) {
        checkVertex(vertex);
        List<Integer> neighbors = new ArrayList<>();
        for (int i = 0; i < vertices[vertex].length; i++) {
            if (vertices[vertex][i] > 0) {
                neighbors.add(i);
            }
        }

        return neighbors;
    }

    /**
     * Implementation of the Dijkstra's algorithm.
     * @param from Source node
     * @param to Destionation node
     * @return The path.
     */
    public List<Integer> path(int from, int to) {
        checkVertex(from);
        checkVertex(to);
        //Initialization
        //--------------
        int cost[] = new int[vertices.length];
        int prev[] = new int[vertices.length];
        Set<Integer> unvisited = new HashSet<>();

        //All other nodes will have its cost set to MAXIMUM and undefined previous
        for (int v = 0; v < vertices.length; v++) {
            cost[v] = Integer.MAX_VALUE;
            prev[v] = UNDEFINED;
            unvisited.add(v);
        }

        //The initial node has cost 0 and no previous vertex
        cost[from] = 0;

        //Graph search
        //------------
        while (!unvisited.isEmpty()) {
            int near = closest(cost, unvisited);
            unvisited.remove(near);

            for (Integer neighbor : getNeighbors(near)) {
                int totalCost = cost[near] + getCost(near, neighbor);
                if (totalCost < cost[neighbor]) {
                    cost[neighbor] = totalCost;
                    prev[neighbor] = near;
                }
            }
            //Found?
            if (near == to) {
                return makePathList(prev, near);
            }
        }

        //No path found
        return Collections.emptyList();
    }

    private int closest(int[] dist, Set<Integer> unvisited) {
        double minDist = Integer.MAX_VALUE;
        int minIndex = 0;
        for (Integer i : unvisited) {
            if (dist[i] < minDist) {
                minDist = dist[i];
                minIndex = i;
            }
        }
        return minIndex;
    }

    private List<Integer> makePathList(int[] prev, int u) {
        List<Integer> path = new ArrayList<>();
        path.add(u);
        while (prev[u] != UNDEFINED) {
            path.add(prev[u]);
            u = prev[u];
        }
        Collections.reverse(path);
        return path;
    }
}