Objeto Convertir Java [] Matriz a Vector

Question

¿Cuál es la mejor forma de convertir una matriz de Objetos a un Vector?

JDE < 1,5

public Vector getListElements() 
{ 
    Vector myVector = this.elements; 
    return myVector; 
} 

this.elements es un objeto []

Gracias, RAYT

Debo aclarar mi pregunta

Mi plataforma de destino es una Mora.

Las colecciones no son compatibles. Array.asList() no es, ya sea:/

Clase completa

package CustomElements; 

import net.rim.device.api.ui.component .*; 
import net.rim.device.api.collection.util.*; 
import net.rim.device.api.util.*; 
import java.util.*; 

public class ContactsList extends SortedReadableList implements KeywordProvider 
{ 
    // Constructor 
    public ContactsList(Vector contacts) 
    { 
     super(new ContactsListComparatorByFirstName());  
     loadFrom(contacts.elements());  
    } 
    // Add Element to ContactsSortedReadableList 
    void addElement(Object element) 
    { 
     doAdd(element); 
    } 

    public Vector getListElements() 
    { 
     return new Vector(Collection 


     Vector test = this.getElements(); 
    } 
    // getKeywords 
    public String[] getKeywords(Object element) 
    { 
     return StringUtilities.stringToWords(((Contact)element).get_contactFirstName()); 
     // return StringUtilities.stringToWords(element.toString()); 
    } 
    // Comparator sorting Contact objects by name 
    final static class ContactsListComparatorByFirstName implements Comparator 
    {       
     public int compare(Object o1, Object o2) 
     { 
      // Sticky Entries Implementation 
      if(((ContactsListObject)o2).getSticky()) 
      { 
       return 1; 
      } else 
       if (((ContactsListObject)o1).getSticky()) 
       { 
        return -1; 
       } else 
       { 
        if(((ContactsListObject)o1).get_contactFirstName().compareTo(((ContactsListObject)o2).get_contactFirstName()) <0) 
        { 
         return -1; 
        } 
        if(((ContactsListObject)o1).get_contactFirstName().compareTo(((ContactsListObject)o2).get_contactFirstName()) >0) 
        { 
         return 1; 
        } 
        else 
        { 
         return 0; 
        } 
       } 
     }   
    }  
} 

Answer 1

return new Vector(Arrays.asList(elements)); 

Ahora, puede parecer como si va a copiar los datos dos veces, pero no lo son. Obtiene un objeto temporal pequeño (List desde asList), pero proporciona una vista de la matriz. En lugar de copiarlo, las operaciones de lectura y escritura pasan a la matriz original.

Se puede extender Vector y meter sus campos protected. Esto daría una forma relativamente simple de hacer que el Vector se convierta en una vista de la matriz, como lo hace Arrays.asList. Alternativamente, simplemente copiando datos en los campos. Para Java ME, esto es casi tan bueno como se consigue sin escribir el ciclo obvio. código no probado:

return new Vector(0) {{ 
    this.elementData = (Object[])elements.clone(); 
    this.elementCount = this.elementData.length; 
}}; 

Por supuesto, usted es probablemente mejor con un List que un Vector. 1.4 ha completado su período de fin de servicio. Incluso 1.5 ha completado la mayor parte de su período de EOSL.

Answer 2

1. Copiar los elementos de la matriz a la Vector, o

2. Uso Arrays.asList(...) para devolver un List, que no es exactamente un Vector, pero debe codificar la interfaz List de todos modos.

Answer 3

En J2ME, estás atrapado iterando sobre la matriz y agregando los elementos uno por uno.

Vector v = new Vector(); 
for (int i = 0; i < this.elements.length; i++) { 
    v.add(this.elements[i]); 
} 

Answer 4

en mi humilde opinión la única opción viable es:

public Vector getListElements() 
    Vector vector = new Vector(this.elements.length); 

    for (int i = 0; i < this.elements.length; i++) { 
     vector.add(this.elements[i]); 
    } 

    return vector; 
} 

Answer 5

Un comparador simplificado que hace básicamente lo mismo.

final static class ContactsListComparatorByFirstName implements Comparator { 
    public int compare(Object o1, Object o2) { 
      // Sticky Entries Implementation 
     ContactsListObject clo2 = (ContactsListObject) o2; 
     ContactsListObject clo1 = (ContactsListObject) o1; 
     if (clo2.getSticky()) return 1; 
     if (clo1.getSticky()) return -1; 
     return clo1.get_contactFirstName().compareTo(clo2.get_contactFirstName()); 
    } 
}  

El uso de los genéricos y:? Sería simplemente

static final class ContactsListComparatorByFirstName implements Comparator<ContactsListObject> { 
    public int compare(ContactsListObject clo1, ContactsListObject clo2) { 
     return clo2.getSticky() ? 1 : // Sticky Entries Implementation 
      clo1.getSticky() ? -1 : 
      clo1.get_contactFirstName().compareTo(clo2.get_contactFirstName()); 
    } 
} 

Pero para responder a su pregunta ...(oh veo que Tom tiene lo que pondría ya)