Arquivo Discussoes de Programacao e Tecnologia Olá,
Estou com uma dificuldade em trabalhar com arrays,
tenho que criar um array associativo, onde o indice do array é uma String, Ex:
meuArray['um'],meuArray['dois']
Só que as chaves(indices) podem se repetir, oque me impete de de usar HashMap(), alguma sujestão ?
Eae blz?
bom na verdade vc pode usar o HashMap mas de uma outra forma
pelo que eu tentendi vc vai ter chaves que podem se repetir
mas o hashmap soh são 2 módutos
+-------+-------+
| chave | valor |
+-------+-------+
oq proponho é criar um novo objeto onde a sua base de armazenagem seja um HashMap mas no seguinte formato
+-------+--------------------+
| chave | coleção de objetos |
+-------+--------------------+
onde vc nesse formato de armazenagem vc pode usar uma mesma chave num hashmap onde a mesma não retorna um unico objeto | valor mas cada chave armazene
tendo em vista que a o método de entrada de dados do hashmap é
public Object put(Object key, Object value)
e dai é soh criar uma classe que te facilite a manipulação desse modelo
de dado e dai vc poderá utilizar para uma mesma chave recuperar mais de um valor 
[]´s
Anjo,
Obrigado pela idéia, se puder ver como ficou, http://paste.b1n.org/tl
seria isso né ?
compilei agora o codigo (http://paste.b1n.org/tl ) com a opção
javac -Xlint e o seguinte aviso foi mostrado:
warning: [unchecked] unchecked call to addElement(E) as a member of the raw type
Eu tenho que declara o tipo de dados do Vector, é isso ?
eae blz?
bom o tipo do vector é Object
e minha proposta foi a seguinte como a classe a seguir
import java.util.*;
/**
* @author Erko Bridee
*
* Tido de dados que utiliza um identificador como indice de uma coleção de objetos
*/
public class ArrayText {
private Hashtable hashTable;
/** Creates a new instance of ArrayText */
public ArrayText() {
this.hashTable = new Hashtable();
}
/*
* Definição de métodos de acesso a objetos da classe
*/
public void setArrayText( Hashtable ht ) { this.hashTable = ht; }
public Hashtable getArryText() { return this.hashTable; }
/*
* Métodos de serviços da classe
*/
// método para adicionar algum valor
public void add( Object key, Object value ) {
/*
* Verificando se já existe a chave
* -> Caso exista recupera a coleção de objetos e adiciona um novo
* valor a essa coleção de objetos
* -> Caso contrário adiciona a nova chave e cria uma nova coleção de
* objetos, inserindo a esta o primeiro valor repassado
*/
if( this.hashTable.containsKey(key) ) {
Vector v = (Vector) this.hashTable.get(key);
v.add( value );
} else {
Vector ObjectCollection = new Vector();
ObjectCollection.add( value );
this.hashTable.put( key, ObjectCollection );
}
}
// remove todos os objetos relacionados a chave repassada
public void remove( Object key ) {
this.hashTable.remove(key);
}
// método para remover um objeto específico da coleção de objetos
public void remove( Object key, Object value ) {
Vector v = ( Vector )this.hashTable.get( key );
v.removeElement( value );
}
// método que retorna a coleção de objetos quando solicitado
public Vector get( Object key ) {
return ( Vector ) this.hashTable.get( key );
}
// retorna um elemento específico da coleção de objetos
public Object get( Object key, int element ) {
return ((Vector)this.hashTable.get( key )).elementAt( element );
}
// método que retorna um array de objetos
public Object[] getArray( Object key ) {
return ((Vector)this.hashTable.get( key )).toArray();
}
/*
* método para alterar um valor da coleção de uma determinada chave
* altera todos os antigos valores oldValue por newValue
*/
public void replace( Object key, Object oldValue, Object newValue ) {
// recupera a coleção
Vector v = ( Vector )this.hashTable.get( key );
/*
* Armazena os indices da coleção que serão alterados
*/
Vector positionsToReplace = new Vector();
for(int count = 0; count < v.size(); count++ ) {
if( v.get(count).equals( oldValue ) ) {
positionsToReplace.add( new Integer( count ) );
}
}
/*
* recupera os indices dos valores que deverão ser alterados
* e realiza a substituição dos valores antigos pelo novo
*/
for( int i = 0; i < positionsToReplace.size(); i++ ) {
int index = Integer.parseInt(positionsToReplace.get(i).toString());
v.set( index, newValue );
}
}
public String toString() {
String out = "";
Enumeration enumeration = this.hashTable.keys();
out += "\n";
out += "+--------------------------------------------------------------+\n";
out += "| Relatório de teste da classe |\n";
out += "+--------------------------------------------------------------+\n";
while( enumeration.hasMoreElements() ) {
Object key = enumeration.nextElement();
Vector vector = ( Vector )this.hashTable.get( key );
out += "\nKey: " + key.toString();
for( int i = 0; i < vector.size(); i++ ) {
out += "\n value: " + vector.get(i).toString();
}
}
out += "\n\n";
out += "+--------------------------------------------------------------+\n";
out += "| Fim do Relatório de teste da classe |\n";
out += "+--------------------------------------------------------------+\n";
return out;
}
/*
* Método principal de teste da classe
*/
public static void main(String[] args) {
ArrayText arrayText = new ArrayText();
arrayText.add( "um", "primeiro" );
arrayText.add( "um", "segundo" );
arrayText.add( "dois", "primeiro do segundo" );
arrayText.add( "dois", "segundo do segundo" );
arrayText.add( "dois", "terceiro do segundo" );
System.out.print(arrayText.toString());
arrayText.replace( "um", "segundo", "segundo ALTERADO" );
System.out.print(arrayText.toString());
arrayText.remove( "dois", "terceiro do segundo" );
System.out.print(arrayText.toString());
arrayText.remove( "um" );
System.out.print(arrayText.toString());
}
}
espero ter ajudado, qq ideia ai ou duvida é soh falar
[]´s
hrober, essa mensagem é dada pelo compilador do Java 5.0, e quer dizer que embora seu código rode bonitinho, é preferível usar o Vector “genérico” do Tiger. Leia o tutorial da Sun sobre genéricos para saber direitinho do que se trata, mas no seu caso, é porque em vez de criar um lista de Objects e ter que fazer a conversão para pegar o objeto, você pode criar uma lista que aceita e lhe retorna só os tipos corretos de instância. Então, em vez de escrever:
Hashtable ht = new Hashtable();
Vector v = new Vector();
v.add("value1");
v.add("value2");
v.add(new Object()); // permitido, Vector armazena objetos
ht.add("key", v);
Vector v2 = (Vector) ht.get("key");
String s = (String) v2.get(2); // pau em tempo de execução
Você escreve isto:
// Só aceita Strings de chave, e Vectors de Strings de valor
Hashtable<String, Vector<String>> ht = new Hashtable<String, Vector<String>>();
Vector<String> v = new Vector<String>(); // Só aceita Strings
v.add("value1");
v.add("value2");
v.add(new Object()); // pau na compilação, o Vector v só aceita Strings
ht.add("key", v);
Vector<String> v2 = ht.get("key"); // Note que não precisa de casting
String s = v2.get(1); // Novamente, nada de casting
É bem legalzinho, embora tenha algumas propriedades não intuitivas. Leia o tutorial para entender melhor.
Até mais,