Java Converti oggetto [] matrice in vettore

Question

Qual è il modo migliore per convertire una matrice di oggetti in un vettore?

JDE 1.5 <

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

this.elements è un oggetto []

Grazie, rAyt

vorrei chiarire la mia domanda

La mia piattaforma di destinazione è un mora.

Le raccolte non sono supportate. Array.asList() non è, o:/

Classe 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)); 

Ora, può sembrare come se si copiano i dati due volte, ma non lo sono. Si ottiene un piccolo oggetto temporaneo (uno da asList), ma questo fornisce una vista dell'array. Invece di copiarlo, le operazioni di lettura e scrittura passano alla matrice originale.

È possibile estendere Vector e inserire i suoi campi protected. Ciò fornirebbe un modo relativamente semplice di avere la Vector una vista dell'array, come fa Arrays.asList. In alternativa, copia semplicemente i dati nei campi. Per Java ME, questo è quanto di meglio si ottiene senza scrivere il ciclo ovvio. codice non testato:

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

Naturalmente, si sono probabilmente meglio con un List di un Vector. 1.4 ha completato il periodo di fine vita del servizio. Anche 1.5 ha completato la maggior parte del suo periodo di EOSL.

Answer 2

1. copiare gli elementi dell'array al Vector o

2. Usa Arrays.asList(...) per restituire un List, che non è esattamente un Vector, ma dovresti codificare comunque l'interfaccia List.

Answer 3

In J2ME, stai bloccando l'iterazione sull'array e aggiungi gli elementi uno a uno.

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

Answer 4

imho l'unica opzione valida è:

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 comparatore semplificata che fa sostanzialmente la stessa cosa.

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()); 
    } 
}  

Utilizzando farmaci generici e: sarebbe solo

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()); 
    } 
} 

Ma per rispondere alla tua domanda ...(oh vedo che Tom ha quello che metterei già)