Como criar variaveis dinamicamente?

procure usar vetor!

eu não queria uzar vetor pq achu esteticamente feio, + c não tiver jeito vou ter q uzar vetor mesmo

‘esteticamente feio’ :?
rsrs

cara tenha certeza que tanto como em flash como qualquer linguagem usar vetores vc tere esteticamente :roll:
bem mais PERFORMACE… do que qualquer criação de variaveis dinamicamente… infelizmente em java vc não pode fazer estas gambiarras do flash…

Hehehe… É verdade… :-o

ironicamente…eu acho feio é usar um loop para criar mais de uma variavel…alem de ser um codigo maior, sendo assim vc gasta um tempo maior lendo e interpretando-o…

exemplo besta e pequeno para ser considerado nesses itens, mais tanto em manuteinibilidade quanto em velocidade do codigo fica pior no loop…

se usado para coisas maiores faria certa diferença…

não é dificil…

mais compare esse codigo com a criação de um vetor comum…

int variavel[]=new int[x];

mais facil e leve né…

pra q complica???

Não sei o que o povo tem que gosta tanto desse Vector.

Vector é uma classe antiga, criada nas primeiras versões do Java.

Seu uso, juntamente com o da classe HashTable, não é recomendado desde a criação da Collections Framework, no Java 1.2. No lugar, deve-se usar o ArrayList (e no caso do HashTable, usa-se HashMap no lugar).

As razões para isso são várias:

1. O Vector tem sincronização tem todos os métodos, o que representa um despercídio de recursos e um possível código mais lento (embora eu não usaria a lentidão como um argumento na maior parte dos casos, pq ela não é representativa);

2. O Vector tem a interface inxada, pois suporta tanto métodos antigos quanto os novos, implementados de List. Por exemplo, o ideal é usar add da interface List, e não o addElement, existente só em Vector - ambos os métodos fazem a mesma coisa.
   Usar métodos não padrão de list tornam o código mais difícil de manter;

3. Não é recomendado pela Sun;

Explicando o item #2 em mais detalhes, não se recomenda usar nenhum coleção diretamente, e sim através de uma interface. Isso permite a adaptação da coleção com wrappers de sincronização e imutabilidade, além da troca de um algoritmo de coleção por outra, caso necessário. Um exemplo do uso pela interface seria:

List<Integer> list = new ArrayList<Integer>(); for (int i = 0; i < 10; i++) { list.add(new Integer(i)); }

Note que a variável é do tipo List, não ArrayList. Isso me permite fazer coisas interessantes como:

List<Integer> listReadOnly = Collections.unmodifiableList(v);
List<Integer> listSynchronized = Collections.synchronizedList(v);

listSynchronized.add(10); //Adiciona 10 em list de maneira sincronizada
listReadOnly.remove(0);  //Erro! UnsupportedOperationException!

Ou mesmo, eu poderia trocar a declaração no futuro por:

List<Integer> list = new LinkedList<Integer>(); //Outra lista, mesmo código para usar for (int i = 0; i < 10; i++) { list.add(new Integer(i)); }

Sem que isso afetasse o meu código inteiro. Tem mais um exemplo disso nesse tópico: http://www.guj.com.br/posts/list/55387.java#290673

maior_abandonado:

não é dificil...

mais compare esse codigo com a criação de um vetor comum...

int variavel[]=new int[x];

mais facil e leve né...

pra q complica???

Na hora de criar, até que sim... mas e que tal na hora de usar?
Vamos comparar a remoção de um List com um Array comum.

Suponha que tenhamos um List chamado list e um array chamado array, ambos de String, e contendo nomes. E queremos remover o nome Vinícius.

list.remove("Vinícius");

//Primeiro achamos o elemento lá dentro:
int pos;
for (pos = 0; pos < array.length; pos++) 
   if (array[pos].equals("Vinícius"))
      break;

//Se não achamos, não temos o que remover.
if (pos == array.length) 
   return;

//Caso contrário, removemos o elemento
   for (int i = pos; i < array.length-1; i++)
      array[pos] = array[pos+1];

//Finalmente, reduzimos o tamanho físico de nosso array. Esse passo poderia ser evitado 
//se vc guardar o tamanho do array numa outra variável, mas daí vc teria que controlar 
//também essa variável e não poderia esquecer de fazer array[pos] = null.

int[] array2 = new int[array.length-1];
System.arrayCopy(array, 0, array2, 0, array2.length);
array = array2;

E aí, qual vcs preferem?

Daria mais ou menos o mesmo trabalho para adicionar novos elementos. E provavelmente nosso algoritmo ficaria ainda menos flexível e eficiente do que o implementado na classe ArrayList.

entao utiliza ArrayList.

Seria um Vetor que fez plástica?

Onde esta a “dificuldade” de se fazer isso:

Vector<Object> v = new Vector<Object>();
for (int i = 0; i < 10; i++) {
    v.add(i, new Integer(i));
}

Até!