Java Convert Object[] Array to Vector

Question

What's the best way to convert an Object array to a Vector?

JDE < 1.5

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

this.elements is an Object[]

Thanks, rAyt

I should clarify my question

My target platform is a blackberry.

Collections aren't supported. Array.asList() isn't, either :/

Full Class

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

1) Copy the array elements to the Vector, or

2) Use Arrays.asList(...); to return a List, which isn't exactly a Vector, but you should be coding the List interface anyway.

Answer 2

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

Now, it may look as if you are copying the data twice, but you aren't. You do get one small temporary object (a List from asList), but this provides a view of the array. Instead of copying it, read and write operations go through to the original array.

It is possible to extends Vector and poke its protected fields. This would give a relatively simple way of having the Vector become a view of the array, as Arrays.asList does. Alternatively, just copying data into the fields. For Java ME, this is about as good as it gets without writing the obvious loop. Untested code:

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

Of course, you are probably better off with a List than a Vector. 1.4 has completed its End of Service Life period. Even 1.5 has completed most of its EOSL period.

Answer 3

In J2ME, you're stuck iterating over the array and add the elements one by one.

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

Answer 4

imho your only viable option is:

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

A simplified comparator which does basically the same thing.

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

Using generics and ?: it would be just

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

But to answer your question... (oh I see Tom has what I would put already)

Answer 6

A for loop. I've seen your comments about trying to avoid this. How do you think some api method is implemented? I mean, even if it involves a native call, it is essentially the same.