Matriz dinamicamente alocada

Programação Java
#1

Gostaria de criar uma matriz dinamicamente alocada, não consegui achar nada na documentação de java então edcidi criar uma eu mesmo usando Vector, aliás uma matriz de inteiros, então fiz o seguinte:

private Vector<Vector> matriz = new Vector<Vector>();

compilou sem problemas, creio que com isso criei um vetor cujas posições são vetores interios, me corrijam se estiver errado.

Mas agora não sei como usar as funções para acessar os elementos, pois estas são unidimensionais…

Teria outra maneira de fazer essa matriz ou é assim mesmo? E se for, como acesso seus elementos???

Obrigado

#2

Dá para fazer isso, mas dependendo do seu problema, você deve usar uma representação alternativa.

Se por exemplo a sua matriz é retangular e grande, ou você vai fazer multiplicações ou transformações de coordenadas, usar um Vector< Vector < Integer> > é meio pesado, para melhor dizer inadequado. Um Vector < Vector < Integer > > seria adequado se sua matriz fosse retangular ou “jagged” (exemplo: triangular), e pequena, e não se fizessem muitos cálculos com ela.

Acho que há alguns pacotes para computação numérica com Java que representam matrizes bidimensionais de uma forma mais amigável e eficiente. Dê uma procurada por aí.

Se você quer fazer uma planilha (onde há três dimensões: linhas, colunas e “worksheets”, e é uma matriz esparsa), você pode usar ainda uma outra representação.

#3

Você criou um Vector de Integers, ou seja uma coleção de Objetos do tipo integer, isto não é a mesma coisa que criar um array de int.

Integer = Wrapper. Nesse tipo vc pode fazer as mesmas operações que vc faz com qualquer objeto e o valor (o número em si) não acessado diretamente.
int = tipo primitivo é o próprio valor numérico da variável.

Para acessar o valor em um vector vc faz:

Integer valor = seuVector.get(indice);
int valorPrimitivo = valor.intValue();

O Vector é uma classe que vc deve pensar muito bem antes de utilizar, pois seus métodos são sincronizados e isto deixa-o um pouco mais lento do que as outras coleções. Na maioria das vezes eu uso ArrayList, mas cada caso é um caso.

Você poderia falar um pouco mais do que vc deseja para nós podermos ajudar.

#4

Bem o que eu pretendo fazer é um programa academico, pequeno, tem haver com grafos, o professor fez uma interface que vamos clicando e desenhando o grafo com suas arestas e vértices, então devemos gerar a matriz de adjascencias e fazer o caminhamento em profundidade e amplitude nela, já consegui fazer tudo, mas a minha matriz é estática, queria uma que pudesse ir crescendo a medida em que fosse desenhando o grafo…
Pois agora tudo o que faço é pegar a aresta criada e por na matriz, mas do jeito que está fica limitado ao tamanho da matriz que eu declarei, no caso 10, só que quero remover essa limitação, quero que a matriz vá sendo alocada na medida em que o grafo for sendo gerado…

grato.

#5

Olá

  1. Não use Vector que é sincronizado, use ArrayList ou mesmo um Array

  2. Tente raciocinar e descobrir a fórmula para acessar os termos. Vou raciocinar junto contigo:

Seja uma matriz 4x3

1,1   1,2   1,3
2,1   2,2   2,3
3,1   3,2   3,3
4,1   4,2   4,3

Vamos supor que vamos armazenar por coluna. Então o Array vai ficar assim:

0      1      2      3     4      5      6      7     8      9      10     11     (índices)
1,1    2,1    3,1    4,1   1,2    2,2    3,2    4,2   1,3    2,3    3,3    4,3    (Array)

Então precisamos achar uma fórmula com l e c (l = linha, c =coluna) que quando colocarmos valores para l e c nos dê o índice do Array que vou chamar de i:

Vamos experimentar i = (c - 1) * n + l - 1
onde n = número de linhas
e vamos testar diversos valores:
elemento 3,2 --> i = (2-1) * 4 + 3-1 = 6 OK
elemento 1,1 --> i = (1-1) * 4 + 1-1 = 0 OK
elemento 3,3 --> i = (3-1) * 4 + 3-1 = 10

Faça um raciocínio análogo se quiser armazenar por linha. Confira bem a fórmula porque pensei muito rapidamente nela.

[]s
Luca

#6

Bom, no seu caso até dá para usar o tal do Vector < Vector < Integer > > . Mas você ainda vai ter alguns probleminhas, não sei se é a melhor solução. Acho que é meio complicado.

import java.util.*;

class VectorVectorInteger {
    public static void main(String[] args) {
        //-- Declarando um vetor [5][4] (entendido no sentido Java da coisa, ou seja,
        //-- 5 linhas de 4 colunas) e o preenchendo com (linha + 7 * coluna)
        
        Vector< Vector <Integer > > vvi = new Vector< Vector <Integer> >();
        for (int linha = 0; linha < 5; ++linha) {
            Vector<Integer> vi = new Vector<Integer>();
            for (int coluna = 0; coluna < 4; ++coluna) {
                vi.add(linha + 7 * coluna);
            }
            vvi.add(vi);
        }
        //-- Imprimindo o vetor - é impresso como
        // [[0, 7, 14, 21], [1, 8, 15, 22], [2, 9, 16, 23], [3, 10, 17, 24], [4, 11, 18, 25]]
        System.out.println (vvi);
        //-- Imprimindo o valor [3][2] - note que as coordenadas começam por zero, isto dá a quarta
        //-- linha, terceira coluna, ou seja, 17
        System.out.println (vvi.get(3).get(2));
        //-- Alterando o valor [3][2] para 18, e imprimindo de novo
        vvi.get(3).set(2, 18); // note que é get/set, não set/set como você pensaria
        System.out.println (vvi);
        //-- Agora você quer aumentar a matriz para [6][7], pondo o valor -(linha * 2 + coluna * 3) 
        //-- nas posições novas - os números negativos é só para você ver com mais facilidade.
        //-- Você vai ter de fazer algo meio nojento:
        //-- A) Adicionar mais colunas à matriz anterior:
        for (int linha = 0; linha < 5; ++linha) {
            Vector<Integer> vi = vvi.get(linha);
            for (int coluna = 4; coluna < 7; ++coluna) {
                vi.add(-(linha * 2 + coluna * 3));
            }
            vvi.add(vi);
        }
        //-- B) Adicionar mais linhas à matriz anterior.
        for (int linha = 5; linha < 6; ++linha) {
            Vector<Integer> vi = new Vector<Integer>();
            for (int coluna = 0; coluna < 7; ++coluna) {
                vi.add(-(linha * 2 + coluna * 3));
            }
            vvi.add(vi);
        }
        //-- Agora imprimindo...
        System.out.println (vvi);
    }
}

Você pode ainda usar uma outra coisa que é muito nojenta. Se você tiver uma matriz muito, muito esparsa, onde apenas uns poucos elementos são zero, você pode usar uma “matriz associativa”. A idéia é a seguinte: guarde uma lista das posições que não são zero e as associe com os valores. Isso pode ser feito usando um Map < XY, Integer > onde XY é uma classe contendo dois valores int. Se não for encontrado no Map, então o valor é zero. Se precisar inserir um elemento na matriz, use o método “put” de Map. Isso é mais rápido que você pensa, use HashMap ou TreeMap.

EDIT - não tinha visto que você (e eu) estávamos usando Vector. Vector usa umas primitivas de sincronização que a fazem relativamente lenta, principalmente em máquinas multiprocessadas. Use ArrayList.

#7

Um exemplo bobo de matriz associativa. Não é a melhor implementação possível, mas dá pro gasto. Note que você nunca precisa redimensionar a matriz, mas em compensação não sei qual seria a “dimensão” dela. Aqui também falta um método que permita mostrar essa matriz como uma matriz retangular.

import java.util.*;

class XY implements Comparable<XY> {
    
    public int x;
    
    public int y;
    
    public XY (int pX, int pY) {
        x = pX; y = pY;
    }
    
    public String toString() {
        return "(" + x + ", " + y + ")";
    }
    
    /** Definindo arbitrariamente um comparador, para fazer isto funcionar */
    public int compareTo(XY obj) {
        if (x < obj.x) {
            return -1;
        } else if (x == obj.x) {
            if (y < obj.y) return -1;
            else if (y == obj.y) return 0;
        }
        return +1;
    }
}

class MatrizAssociativa {
    private Map<XY,Integer> map;
    
    public MatrizAssociativa() {
        map = new TreeMap<XY,Integer>();
    }
    
    Integer get(int pX, int pY) {
        XY xy = new XY(pX, pY);
        if (!map.containsKey (xy))
            return 0;
        else
            return map.get(xy);
    }
    
    void put(int pX, int pY, Integer val) {
        XY xy = new XY(pX, pY);
        map.put (xy, val);
    }
    
    public String toString() {
        return map.toString();
    }

    public static void main(String[] args) {
        MatrizAssociativa m = new MatrizAssociativa();
        m.put (2, 4, 100); // m[2,4] = 100
        m.put (3, 4, 200); // m[3,4] = 200
        System.out.println (m.get (2, 4)); // m[2,4] -> 100
        System.out.println (m.get (2, 5)); // m[2,5] -> 0
        System.out.println (m); // imprime {(2, 4)=100, (3, 4)=200}
    }
}
#8

Obrigado a todos, graças as dicas que recebi, consegui fazer a matriz! usei ArrayList e ficou muito bom!

#9