Java将对象[]数组转换为向量

将对象数组转换为向量的最佳方式是什么

JDE<1.5

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

this.elements是一个对象[]

谢谢， 雷特

我应该澄清我的问题

我的目标平台是黑莓

不支持集合。Array.asList（）也不是：/

全班

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

包装定制元素；
导入net.rim.device.api.ui.component.*；
导入net.rim.device.api.collection.util.*；
导入net.rim.device.api.util.*；
导入java.util.*；
公共类ContactsList扩展了TableList实现关键字提供程序
{
//建造师
公共联系人列表（矢量联系人）
{
super（新联系人列表比较器orbyfirstname（））；
loadFrom（contacts.elements（））；
}
//将元素添加到ContactsOrtedReadableList
void addElement（对象元素）
{
doAdd（元素）；
}   
公共向量getListElements（）
{
返回新向量（集合）
向量测试=this.getElements（）；
}
//获取关键字
公共字符串[]getKeywords（对象元素）
{
返回StringUtilities.StringToWord（（（Contact）元素）.get_contactFirstName（）；
//返回StringUtilities.StringToWord（element.toString（））；
}  
//比较器按名称对联系人对象排序
最后一个静态类ContactsListComparatorByFirstName实现了Comparator
{                           
公共整数比较（对象o1、对象o2）
{
//粘性条目实现
如果（（（ContactsListObject）o2）.getSticky（））
{
返回1；
}否则
if（（（ContactsListObject）o1.getSticky（））
{
返回-1；
}否则
{
如果（（（ContactsListObject）o1.get_contactFirstName（）.compareTo（（（ContactsListObject）o2.get_contactFirstName（））0）
{
返回1；
}
其他的
{
返回0；
}
}
}        
}    
}

将数组元素复制到

向量

，或

使用

Arrays.asList（…）

返回一个

列表

，它不完全是一个

向量

，但无论如何都应该对

列表

接口进行编码

现在，看起来您可能要复制两次数据，但事实并非如此。您确实得到了一个小的临时对象（来自

asList

）的

List

），但这提供了数组的视图。读取和写入操作不是复制它，而是执行到原始数组

可以扩展

Vector

并插入其

受保护的
字段。这将提供一种相对简单的方法，使
Vector
成为数组的一个视图，就像
数组。asList
那样。或者，只需将数据复制到字段中。对于Java ME来说，这与不编写ob的情况差不多未测试的循环。未测试的代码：

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

当然，使用
列表
可能比使用
向量
要好。1.4已经完成了它的使用寿命期。即使是1.5也已经完成了它的大部分EOSL周期。
在J2ME中，你必须迭代数组，然后逐个添加元素

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

Vector v=new Vector（）；
for（int i=0；i
imho您唯一可行的选择是：

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

公共向量getListElements（）
向量向量=新向量（this.elements.length）；
for（int i=0；i
一个简化的比较器，基本上做相同的事情

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

使用泛型和？：这将是

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

静态最终类ContactsListComparatorByFirstName实现Comparator{
公共整数比较（ContactsListObject clo1、ContactsListObject clo2）{
返回clo2.getSticky（）？1://Sticky条目实现
clo1.getSticky（）？-1：
clo1.get_contactFirstName（）.compareTo（clo2.get_contactFirstName（））；
}
}

但要回答你的问题…（哦，我看汤姆已经有了我想说的）
一个相当简洁的方法是：

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

但我想你们都已经知道了。
所以，没有办法绕过for循环？我建议选择2，但值得注意的是，它不复制数组，只包装数组。我不建议选择1，即除非确实需要，否则不要使用向量。@rAyt：即使有内置函数这样做，它仍然会使用for循环没有魔法：）是的，看起来是这样。在对象数组中复制1000多个对象会很糟糕。如果你担心的话，你可以将initialCapacity of elements.length添加到向量构造函数中。我是否应该理解为什么“动态研究”提供类似SorterDableList的东西，它有一个LoadFrom方法，但没有LoadTO方法？！：）我的java版本也不支持泛型！但是谢谢你的提示+1Wow，第二个解决方案看起来非常优雅！我认为“创造性”需要引用
Object[] xx = { 1, "cat", new Point(100,200) };
Vector vv = new Vector(Arrays.asList(xx));
System.out.println("vv=="+vv.toString());