Java Convert Object [] Array en vecteur

Quel est le meilleur moyen de convertir un tableau d'Objets à un Vecteur?

JDE < 1.5

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

.les éléments de est un Objet[]

Grâce,
rAyt

Je me dois de préciser ma question

Ma plate-forme cible est un blackberry.

Collections ne sont pas pris en charge. Tableau.asList() n'est pas, non plus :/

Complet De La Classe

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

source d'informationauteur Henrik P. Hessel

35
```
return new Vector(Arrays.asList(elements));
```
Maintenant, il peut sembler comme si vous copiez des données deux fois, mais vous ne l'êtes pas. Vous obtenez un petit objet temporaire (un List de asList), mais cela donne une vue de l'ensemble. Au lieu de le copier, de lire et d'écrire les opérations de passer par le tableau d'origine.

Il est possible de s'étend Vector et fourrer sa protected champs. Ce serait donner un moyen relativement simple d'avoir la Vector devenir une vue sur le tableau, comme Arrays.asList. Sinon, juste de la copie de données dans les champs. Pour Java ME, c'est à peu près aussi bon qu'il obtient sans avoir à écrire de l'évidence de la boucle. Code non testé:
```
return new Vector(0) {{
    this.elementData = (Object[])elements.clone();
    this.elementCount = this.elementData.length;
}};
```
Bien sûr, vous êtes probablement mieux avec un List qu'un Vector. 1.4 a terminé sa Fin de Vie. Même 1.5 a réalisé la plupart de ses EOSL période.

En J2ME, vous êtes coincé à parcourir le tableau et ajouter les éléments un par un.

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

Simplifié de comparaison qui n'est fondamentalement la même chose.

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

L'utilisation de génériques et ?: il serait juste

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

Mais pour répondre à votre question... (oh, je vois Tom a ce que je mettrais déjà)

à mon humble avis, votre seule option viable est:

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

1
1. Copier les éléments d'un tableau à l' Vectorou
2. Utilisation Arrays.asList(...) retour d'un Listce qui n'est pas exactement un Vectormais vous devriez être codage de la List interface de toute façon.

Une assez concis façon de le faire est quelque chose comme:

Object[] xx = { 1, "cat", new Point(100,200) };
Vector vv = new Vector(Arrays.asList(xx));
System.out.println("vv=="+vv.toString());

Mais y'all le savais déjà, je suppose.

Vous devez vous connecter pour publier un commentaire.