Vector Initialized but Null

2

I'm freaking out with a simple piece of code. My application is for giving information to use on a course.

I add several cities, and then I try to add to the vector, but at the end the vector is always null.

Here is the code:

 Ponto_Turistico Santo_Tirso = new Ponto_Turistico("Santo Tirso");
 Ponto_Turistico Felgueiras = new Ponto_Turistico("Felgueiras");


adPontoTuristico((T) Santo_Tirso);
adPontoTuristico((T) Felgueiras);

Method addTouristic Point:

Line Error:

  

if (this.cont_cid == this.TypeTuristicos_root.length) {

public void adPontoTuristico(T pontoT) {

    Ponto_Turistico c = (Ponto_Turistico) pontoT;


        if (this.cont_cid == this.pontosTuristicos_roteiro.length) {
            expandCapacity_PT();
        }
        this.pontosTuristicos_roteiro[this.cont_cid] = c;
        this.cont_cid++;


}

EDIT CLASSES ROUTES

public class Roteiros<T> {

    private final int DEFAULT_SIZE = 20;
    private Ponto_Turistico[] pontosTuristicos_roteiro;
    private int cont_cid;

    /**
     *
     */
    public void Roteiros() {

        this.pontosTuristicos_roteiro = new Ponto_Turistico[DEFAULT_SIZE];
        this.cont_cid = 0;

    }

    /**
     * Adiciona um ponto turistico
     *
     * @throws IOException
     */
    public void AdicionarPonto_Turistico() throws IOException {

        System.out.println("**Adicionar um Ponto_Turistico**");
        System.out.println("Nome do novo Ponto Turistico:");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String opc = br.readLine();

        if (procurarPontoTuris((T) opc) != null) { // se o ponto turistico que o jogador adicionar  for diferente  de null, ou seja se ainda nao existir

            Ponto_Turistico nova_city = new Ponto_Turistico(opc);
            adPontoTuristico((T) nova_city);
        } else {
            System.out.println("Já existe um ponto turistico com o nome escolhido!");
        }
    }

    /**
     * Adiciona um Ponto Turistico
     *
     * @param pontoT a adicionar
     * @return 
     */
    public void adPontoTuristico(T pontoT) {

        Ponto_Turistico c = (Ponto_Turistico) pontoT;


            if (this.cont_cid == this.pontosTuristicos_roteiro.length) {
                expandCapacity_PT();
            }
            this.pontosTuristicos_roteiro[this.cont_cid] = c;
            this.cont_cid++;




    }

    public void removerPontoTuristico() throws IOException {

        System.out.println("\n **Remover Ponto Turistico**");
        System.out.println("\n Introduza o ponto turistico a ser removido:");

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String opc2 = br.readLine();

        Ponto_Turistico pro = procurarPontoTuris((T) opc2);
        if (pro != null) {
            for (int i = 0; i < this.cont_cid; i++) {
                if (this.pontosTuristicos_roteiro[i].getNome().equals(opc2)) {

                    this.pontosTuristicos_roteiro[i] = null;
                    this.cont_cid--;
                } else {
                    this.pontosTuristicos_roteiro[i] = this.pontosTuristicos_roteiro[i + 1];
                    this.cont_cid--;
                }
            }
        } else {
            System.out.println("Ponto Turistico: " + opc2 + " nao encontrada!");
        }

    }

    /**
     * Iniciar um jogo
     *
     * @throws IOException
     * @throws EmptyCollectionException
     */
    public void iniciar() throws IOException, EmptyCollectionException {
        String a;

        do {
            System.out.println("Agência de Viagens");
            System.out.println("1- Percursos Existentes");
            System.out.println("2- Administracao");
            System.out.println("3- Sair");

            System.out.print("A sua escolha: ");
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String opc = br.readLine();
            a = opc;
            System.out.println(" ");

            switch (opc) {
                case "1":
                    menuJogar();
                    break;
                case "2":
                    admin();
                    break;
            }

        } while (!a.equals("3"));

    }

    /**
     * Menu administrador
     *
     * @throws IOException
     */
    public void admin() throws IOException {
        String o;
        do {
            System.out.println("\n\nMenu Administrador");
            System.out.println("1- Adicionar Ponto Turistico");
            System.out.println("2- Remover Ponto_Turistico");
            System.out.println("3- Alterar Trajetos entre Pontos");
            System.out.println("4- Adicionar Trajetos Entre Pontos");
            System.out.println("5- Listar Pontos Turisticos");
            System.out.println("6- Listar Trajetos");
            System.out.println("7- Sair");
            System.out.print("A sua escolha: ");

            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String opc = br.readLine();
            o = opc;

            switch (opc) {
                case "1":
                    AdicionarPonto_Turistico(); // adiciona um novo ponto turistico
                    break;
                case "2":
                    removerPontoTuristico(); // remove um ponto turistico já existente
                    break;
                case "3":
                    System.out.println("\nAlterar Trajetos entre Pontos ");
                    System.out.print("Nome do Ponto Turistico a ser alterado:");
                    String nome = br.readLine();
                    Ponto_Turistico proc = procurarPontoTuris((T) nome);
                    if (proc != null) {
                        int pos = 0;
                        for (int i = 0; i < this.cont_cid; i++) {
                            if (this.pontosTuristicos_roteiro[i].getNome().equals(nome)) {
                                pos = i;
                            }
                        }

                        System.out.println("\nINTRODUZA OS VALORES ANTIGOS!");
                        System.out.print("Distancia Total: ");
                        double old_dist = 0;
                        String ond_d = br.readLine();
                        old_dist = Double.parseDouble(ond_d);
                        System.out.print("\nDuracao Total: ");
                        double old_durac = 0;
                        String ond_dura = br.readLine();
                        old_durac = Double.parseDouble(ond_dura);
                        System.out.print("\nCusto Total: ");
                        double old_custo = 0;
                        String ond_cust = br.readLine();
                        old_custo = Double.parseDouble(ond_cust);
                        System.out.print("\nPonto Turistico Final: ");
                        String ond_city = br.readLine();

                        Trajeto[] old_traj = this.pontosTuristicos_roteiro[pos].getAdjacencias();

                        for (int j = 0; j < (this.pontosTuristicos_roteiro[pos].getNum_cidades() * 2); j++) {
                            if ((old_traj[j].getCidade_final().getNome().equals(ond_city)) && (old_traj[j].getDistancia() == old_dist) && (old_traj[j].getDuracao() == old_durac) && (old_traj[j].getCusto() == old_custo)) {
                                System.out.println("\nINTRODUZA NOVOS VALORES!");
                                System.out.print("Distancia: ");
                                double new_dist = 0;
                                String new_d = br.readLine();
                                new_dist = Double.parseDouble(new_d);
                                System.out.print("\nDuracao: ");
                                double new_durac = 0;
                                String new_dura = br.readLine();
                                new_durac = Double.parseDouble(new_dura);
                                System.out.print("\nCusto: ");
                                double new_custo = 0;
                                String new_cust = br.readLine();
                                new_custo = Double.parseDouble(new_cust);
                                System.out.print("\nCidade Destino: ");
                                String new_city = br.readLine();
                                if (procurarPontoTuris((T) new_city) != null) {
                                    Trajeto traje = new Trajeto(procurarPontoTuris((T) new_city), new_dist, new_durac, new_custo);
                                    this.pontosTuristicos_roteiro[pos].alterarTrajeto(pos, traje);
                                } else {
                                    System.out.println("Não foi encontrado nenhum ponto turistico com o nome " + new_city + "\n");
                                }
                            }
                        }
                    } else {
                        System.out.println("Ponto Turistico  não encontrado!\n");
                    }

                    break;
                case "4":
                    System.out.println("\n**Adicionar Trajetos ao Ponto Turistico**");
                    System.out.print("Indique a cidade à qual quer adicionar: ");
                    String city = br.readLine();
                    Ponto_Turistico proc2 = procurarPontoTuris((T) city);

                    if (proc2 != null) {
                        int pos1 = 0;
                        for (int i = 0; i < this.cont_cid; i++) {
                            if (this.pontosTuristicos_roteiro[i].getNome().equals(city)) {
                                pos1 = i;
                            }
                        }
                        System.out.println("\nINTRODUZA NOVOS VALORES!");
                        System.out.print("Distancia Total: ");
                        double new_dist = 0;
                        String new_d = br.readLine();
                        new_dist = Double.parseDouble(new_d);
                        System.out.print("\nDuracao Total: ");
                        double new_durac = 0;
                        String new_dura = br.readLine();
                        new_durac = Double.parseDouble(new_dura);
                        System.out.print("\nCusto Total: ");
                        double new_custo = 0;
                        String new_cust = br.readLine();
                        new_custo = Double.parseDouble(new_cust);
                        System.out.print("\nPonto Turistico de Destino: ");
                        String ncity = br.readLine();
                        Ponto_Turistico g = procurarPontoTuris((T) ncity);
                        if (g != null) {
                            this.pontosTuristicos_roteiro[pos1].adicionar_trajeto(g, new_dist, new_durac, new_custo);
                        } else {
                            System.out.println("Ponto Turistico de  destino nao encontrado!");
                        }

                    } else {
                        System.out.println("Ponto Turistico " + city + " não encontrado!");
                    }
                    break;

                case "6":
                    System.out.println("Pontos Turisticos Existentes");
                    for (int k = 0; k < this.cont_cid; k++) {
                        System.out.println(k + 1 + "- " + this.pontosTuristicos_roteiro[k].getNome());
                    }
                    break;
                case "7":
                    System.out.println("** Trajetos Existentes a partir da cidade **");
                    System.out.println("Introduza o Ponto Turistico a ver: ");
                    String l_ci = br.readLine();
                    Ponto_Turistico v = procurarPontoTuris((T) l_ci);
                    Trajeto[] t = v.getAdjacencias();

                    System.out.println("\n\n\nTrajetos:");
                    for (int ta = 0; ta < v.getNum_cidades(); ta++) {
                        System.out.println((ta + 1) + "- " + t[ta].getCidade_final() + " dista: " + t[ta].getDistancia() + " Custo: " + t[ta].getCusto() + " Duracao: " + t[ta].getDuracao());
                    }
                    break;
            }
        } while (!o.equals("8"));

    }

    /**
     * Menu Secundario
     *
     * @throws IOException
     * @throws EmptyCollectionException
     */
    public void menuJogar() throws IOException, EmptyCollectionException {
        String a;
        do {
            System.out.println("Menu de Viagens");
            System.out.println("1- Nova Viagem");
            System.out.println("2- Sair");

            System.out.print("A sua escolha: ");
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String opc = br.readLine();
            a = opc;
            System.out.println(" ");

            switch (opc) {
                case "1":
                    menuNovaViagem();
                    break;

            }
        } while (!a.equals("3"));
    }

    /**
     * Procurar pontos turisticos
     *
     * @param nome nome do ponto turistico
     * @return ponto turistico
     */
    public Ponto_Turistico procurarPontoTuris(T nome) {

        String nome_pontoTuris = (String) nome;

        for (int i = 0; i < this.cont_cid; i++) {
            if (this.pontosTuristicos_roteiro[i].getNome().equals(nome_pontoTuris)) {
                return this.pontosTuristicos_roteiro[i];
            }
        }

        return null;
    }

    /**
     * Menu novaViagem
     *
     *
     * @throws IOException
     * @throws EmptyCollectionException
     */
    public void menuNovaViagem() throws IOException, EmptyCollectionException {
        Percursos_SelfService percursoSelf = new Percursos_SelfService();
        String a;
        do {
            System.out.println("\n\n");
            System.out.println("O que deseja fazer:");
            System.out.println("1- Self Service Percurso");
            System.out.println("2- Ver Pontos Turisticos mais Atraentes");
            System.out.println("3- Procurar Percurso de uma Cidade");
            System.out.println("4- Sair");

            System.out.print("A sua escolha: ");
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String opc = br.readLine();
            a = opc;
            System.out.println(" ");

            switch (opc) {
                case "1":
                    percursoSelf.verPercursosMaisEconomicos();

                    /*  String opc2 = br.readLine();
                    System.out.println(" ");
                    Cidade target = procurarCidade((T) opc2);
                    if (target != null && !j.containsCidade(target)) {
                        j.conquistarCidade(target);
                    } else if (j.containsCidade(target)) {
                        System.out.println("Cidade já conquistada!");
                    } else {
                        System.out.println("Cidade nao encontrada!"); */
                    break;

                case "2":
                    System.out.println("Os nossos pontos de turismo");
                    for (int i = 0; i < this.cont_cid; i++) {
                        System.out.println(this.pontosTuristicos_roteiro[i].getNome());

                    }
                    break;
                case "3":
                    /*
                    System.out.print("Alterar para a cidade: ");
                    String b = br.readLine();
                    Cidade cti = procurarCidade((T) b);
                    if (j.containsCidade(cti)) {
                        j.setCidade_atual(cti);
                    } else {
                        System.out.println("Ainda nao conquistou " + cti.getNome());
                    }
                     */
                    break;

            }
        } while (!a.equals("4"));
    }

    /**
     * Carrega informação Esta função é uma alternativa pouco eficiente, na
     * tentativa de superar a falha nos ficheiros
     */
    public void carregarinfo() {

        Ponto_Turistico Santo_Tirso = new Ponto_Turistico("Santo Tirso");
        Ponto_Turistico Felgueiras = new Ponto_Turistico("Felgueiras");
        Ponto_Turistico Amarante = new Ponto_Turistico("Amarante");
        Ponto_Turistico Celorico_de_Basto = new Ponto_Turistico("Celorico de Basto");
        Ponto_Turistico Fafe = new Ponto_Turistico("Fafe");
        Ponto_Turistico Guimaraes = new Ponto_Turistico("Guimarães");
        Ponto_Turistico Mondim_Basto = new Ponto_Turistico("Mondim de Basto");
        Ponto_Turistico Famalicao = new Ponto_Turistico("VN Famalicão");

        Santo_Tirso.adicionar_trajeto(Felgueiras, 29.0, 41.0, 2.50);
        Santo_Tirso.adicionar_trajeto(Mondim_Basto, 63, 48, 2.2);
        Santo_Tirso.adicionar_trajeto(Famalicao, 11, 20, 3.5);
        Amarante.adicionar_trajeto(Famalicao, 12, 25, 4.5);




        adPontoTuristico((T) Santo_Tirso);
        adPontoTuristico((T) Felgueiras);



    }

    /**
     * Expande a capacidade de pontos turisticos
     *
     * @return
     */
    private Ponto_Turistico[] expandCapacity_PT() {

        Ponto_Turistico[] novo = new Ponto_Turistico[this.pontosTuristicos_roteiro.length + this.DEFAULT_SIZE];
        System.arraycopy(novo, this.cont_cid, this.pontosTuristicos_roteiro, 0, this.cont_cid);
        return novo;
    }

}

EDIT - CLASS_TURISTIC POINT

public class Ponto_Turistico<T> implements Comparable<Ponto_Turistico> {

    private final int DEFAULT_CAPACITY = 7;
    private final String nome;
    private Trajeto[] ligacoes;

    private double minDistance = Double.POSITIVE_INFINITY;
    private double minCusto = Double.POSITIVE_INFINITY;
    private double minDuracao = Double.POSITIVE_INFINITY;
    private int num_cidades;
    private Ponto_Turistico previous;

    /**
     * Construtor de Cidade
     *
     * @param nome Nome da Cidade
     *
     */
    public Ponto_Turistico(String nome) {
        this.nome = nome;
        this.ligacoes = new Trajeto[DEFAULT_CAPACITY];
        this.num_cidades = 0;
    }



    /**
     * Método para comparar Pontos Turisticos
     *
     * @param other outra cidade
     * @return -1 se menor 0 igual 1 superior
     */
    public int compareTo(Ponto_Turistico other) {
        return Double.compare(minDistance, other.minDistance);
    }

    /**
     * Obter nome
     *
     * @return nome
     */
    public String getNome() {
        return nome;
    }

    /**
     * Obter adjacencias
     *
     * @return array de adjacencias
     */
    public Trajeto[] getAdjacencias() {
        return ligacoes;
    }

    /**
     * obter minima distancia
     *
     * @return
     */
    public double getMinDistance() {
        return minDistance;
    }

    /**
     * Obter anterior
     *
     * @return
     */
    public Ponto_Turistico getPrevious() {
        return previous;
    }

    public void setAdjacencies(Trajeto[] adjacencies) {
        this.ligacoes = adjacencies;
    }

    public void setMinDistance(double minDistance) {
        this.minDistance = minDistance;
    }

    public void setPrevious(Ponto_Turistico previous) {
        this.previous = previous;
    }

    public int getDEFAULT_CAPACITY() {
        return DEFAULT_CAPACITY;
    }

    public int getNum_cidades() {
        return num_cidades;
    }

    public void setNum_cidades(int num_cidades) {
        this.num_cidades = num_cidades;
    }

    public boolean isEmpty() {
        return this.num_cidades == 0;
    }

    /**
     * Expandir capacidadade de adjacencias
     *
     * @return
     */
    private Trajeto[] expandCapacity() {
        Trajeto[] novo = new Trajeto[this.ligacoes.length + DEFAULT_CAPACITY];
        System.arraycopy(novo, this.num_cidades, this.ligacoes, 0, this.num_cidades);
        return novo;
    }

    /**
     * Adiciona uma adjacencia
     *
     * @param cidadefinal cidade destino
     * @param distancia diastancia entre cidades
     * @param duracao duracao
     * @param custo custo por km
     */
    public void adicionar_trajeto(Ponto_Turistico cidadefinal, double distancia, double duracao, double custo) {
        if (isEmpty()) {
            this.ligacoes[0] = new Trajeto(cidadefinal, distancia, duracao, custo);
            this.num_cidades++;
        } else if (this.num_cidades == this.ligacoes.length) {
            this.ligacoes = expandCapacity();
            this.ligacoes[this.num_cidades] = new Trajeto(cidadefinal, distancia, duracao, custo);
            this.num_cidades++;
        } else {
            this.ligacoes[this.num_cidades] = new Trajeto(cidadefinal, distancia, duracao, custo);
            this.num_cidades++;
        }
    }

    public double getMinCusto() {
        return minCusto;
    }

    public void setMinCusto(double minCusto) {
        this.minCusto = minCusto;
    }

    public double getMinDuracao() {
        return minDuracao;
    }

    public void setMinDuracao(double minDuracao) {
        this.minDuracao = minDuracao;
    }

    /**
     * Funçao exponencial
     *
     * @param h o valor
     * @param d exponencial
     * @return resultado
     */
    private int exp(double h, double d) {
        int res = 1;
        for (double i = 0; i <= d; i++) {
            res *= h;
        }
        return res;
    }

    /**
     * Alterar adjacencia
     *
     * @param pos posição
     * @param trajeto trajeto
     */
    public void alterarTrajeto(T pos, T trajeto) {
        this.ligacoes[(Integer) pos] = (Trajeto) trajeto;
    }

}

EDIT ** MAIN

public static void main(String[] args) throws EmptyCollectionException, IOException {
        // mark all the vertices 

        Roteiros play = new Roteiros();
        play.carregarinfo();
        play.iniciar();

    }

** EDIT with NEW TEST **

public class testeh{
private final int DEFAULT_SIZE = 20;
private int[] pontosTuristicos_roteiro;
private int cont_cid;


public void Roteiros() {

    this.pontosTuristicos_roteiro = new int[DEFAULT_SIZE];
    this.cont_cid = 0;

}

 public void adPontoTuristico(String pontoT) {

        if (this.cont_cid == this.pontosTuristicos_roteiro.length) {

        }
        this.pontosTuristicos_roteiro[this.cont_cid] = 0;
        this.cont_cid++;




}

** MAIN CLASS **

 testeh dc = new testeh();
 dc.adPontoTuristico("ola");

Continue to give error, NullPointerExeption ...

    
asked by anonymous 12.01.2017 / 00:58

1 answer

5

Sorry for the sincerity, but your code is very full of problems and quite gambiarrado.

The cause of your NullPointerException is this:

public void Roteiros() {
    // ...
}

Do not put void in the builders signature! This is not a constructor, it's just a method with the same name as the class pretending to be a constructor!

In addition, your code has a myriad of other problems. For example, this:

    private Ponto_Turistico[] expandCapacity_PT() {

        Ponto_Turistico[] novo = new Ponto_Turistico[this.pontosTuristicos_roteiro.length + this.DEFAULT_SIZE];
        System.arraycopy(novo, this.cont_cid, this.pontosTuristicos_roteiro, 0, this.cont_cid);
        return novo;
    }

It creates a new array but does not put it anywhere. All places where this method is called do nothing with return. If instead of using arrays, you use lists, you do not have to be doing so much gambiarra to know if the array is full or not, or where to insert elements in it.

It also has this:

        if (procurarPontoTuris((T) opc) != null) { // se o ponto turistico que o jogador adicionar  for diferente  de null, ou seja se ainda nao existir

            Ponto_Turistico nova_city = new Ponto_Turistico(opc);
            adPontoTuristico((T) nova_city);
        } else {
            System.out.println("Já existe um ponto turistico com o nome escolhido!");
        }

That is, if you found the tour point, then add a new one. If you did not find it, say it already exists. You should have used == instead of != .

Also, you use generic types for absolutely nothing useful. Take the generic types of this code they are good for.

I also tell you to use only Scanner and please follow the language naming rules. There are still a lot more things I could suggest, but I'll stick around for a while.

    
12.01.2017 / 01:51