Question

我遇到了绑定，我必须对从电话PIM读取的数据进行排序。在这样做时，我丢失了另一个联系字段被引用到电话号码的另一个，因为我使用了2个单独的向量，如下图所示
在排序之前

 Nna - +445535533                       
Ex - +373773737                         
Ab - +234575757                         
After sorting.(Which shouldn't be)
 Ab - +445535533
 Ex - +373773737
 Nna  - +234575757

这会产生不良行为，因为排序会删除索引到索引的索引，并且所选名称（在多个列表框中）将得到错误的数字。
另外，
我使用哈希表，意图使用名称作为键和数字作为值但是这种配对意味着不允许使用重复的名称作为键。因此，我把电话号码改为按键。我不想听起来像一个哭泣的宝贝，所以我在这里停留了一段时间，所以你希望你的代码你会理解它

我的问题
1.有没有更好的方法/算法来实现这个？
2.如何以一种方式实现getSelectedItems（），以便从hashTable中获取多个选择列表的选定索引的数量

import java.util.Enumeration;
import java.util.Vector;
import java.util.Hashtable;
import javax.microedition.lcdui.List;
import javax.microedition.pim.Contact;
import javax.microedition.pim.ContactList;
import javax.microedition.pim.PIM;
import javax.microedition.pim.PIMException;

/**
 *
 * @author nnanna
 */
public class LoadContacts implements Operation {

    private boolean available;
    private Vector telNames = new Vector();
    Vector telNumbers = new Vector();
    Hashtable Listcontact = new Hashtable();
    private String[] names;

    public Vector getTelNames() {
        return telNames;
    }

    public Hashtable getListcontact() {
        return Listcontact;
    }

    public void execute() {
        try {
// go through all the lists
            String[] allContactLists = PIM.getInstance().listPIMLists(PIM.CONTACT_LIST);

            if (allContactLists.length != 0) {
                for (int i = 0; i < allContactLists.length; i++) {
                    System.out.println(allContactLists[i]);
                    System.out.println(allContactLists.length);
                    loadNames(allContactLists[i]);
                    System.out.println("Execute()");
                }

            } else {
                available = false;
            }
        } catch (PIMException e) {
            available = false;

        } catch (SecurityException e) {
            available = false;

        }
    }

    private void loadNames(String name) throws PIMException, SecurityException {
        ContactList contactList = null;

        try {
            contactList = (ContactList) PIM.getInstance().openPIMList(PIM.CONTACT_LIST, PIM.READ_ONLY, name);
            // First check that the fields we are interested in are supported(MODULARIZE)
            if (contactList.isSupportedField(Contact.FORMATTED_NAME) && contactList.isSupportedField(Contact.TEL)) {
                Enumeration items = contactList.items();
                Hashtable temp = new Hashtable();
                while (items.hasMoreElements()) {
                    Contact contact = (Contact) items.nextElement();
                    int telCount = contact.countValues(Contact.TEL);
                    int nameCount = contact.countValues(Contact.FORMATTED_NAME);
                    if (telCount > 0 && nameCount > 0) {
                        String contactName = contact.getString(Contact.FORMATTED_NAME, 0);
                        // go through all the phone availableContacts

                        for (int i = 0; i < telCount; i++) {
                            System.out.println("Read Telno");
                            int telAttributes = contact.getAttributes(Contact.TEL, i);
                            String telNumber = contact.getString(Contact.TEL, i);
                            Listcontact.put(telNumber, contactName);
                            temp.put(contactName, telNumber);
                        }
                        names = getSortedList();
//                            Listcontact = temp;
                        System.out.println(temp + "-------");
                        System.out.println(Listcontact + "*******");
                        shortenName(contactName, 20);
                    }
                    available = true;
                }
            } else {
                available = false;
            }
        } finally {
// always close it
            if (contactList != null) {
                contactList.close();
            }
        }
    }

    private void shortenName(String name, int length) {
        if (name.length() > length) {
            name = name.substring(0, 17) + "...";
        }
    }

    public Vector getSelectedItems(List lbx) {
        boolean[] arrSel = new boolean[lbx.size()];
        Vector selectedNumbers = new Vector();
        int selected = lbx.getSelectedFlags(arrSel);
        String selectedString;
        String result = "";
        for (int i = 0; i < arrSel.length; i++) {
            if (arrSel[i]) {
                selectedString = lbx.getString(lbx.getSelectedFlags(arrSel));
                result = result + " " + i;
                System.out.println(Listcontact.get(selectedString));
//                System.out.println(telNumbers.elementAt(i));
            }
        }
        return selectedNumbers;
    }

    private String[] sortResults(String data[]) {
        RecordSorter sorter = new RecordSorter();
        boolean changed = true;
        while (changed) {
            changed = false;
            for (int j = 0; j < (data.length - 1); j++) {
                String a = data[j], b = data[j + 1];
                if (a != null && b != null) {
                    int order = sorter.compare(a.getBytes(), b.getBytes());
                    if (order == RecordSorter.FOLLOWS) {
                        changed = true;
                        data[j] = b;
                        data[j + 1] = a;
                    }
                }
            }
        }
        return data;
    }

    public String[] getNames() {
        return names;
    }
        Vector elements = new Vector();
    private String[] getValueArray(Hashtable value) {

        System.out.println(Listcontact + " c");
        Enumeration e = value.elements();
        while (e.hasMoreElements()) {
            elements.addElement(e.nextElement());
        }
        String[] elementsArray = new String[elements.size()];
        elements.copyInto(elementsArray);
        elements.removeAllElements();
        System.out.println(elementsArray + " k");
        return elementsArray;
    }

    public void getDuplicates(Vector realValue) {
        Vector duplicate = new Vector();
        Enumeration e = realValue.elements();
        for (int i = 0; e.hasMoreElements(); i++) {
            if (duplicate.isEmpty() || !duplicate.elementAt(i).equals(e.nextElement())) {
                break;
            } else {
                duplicate.addElement(e.nextElement());
            }
        }
    }

    public String[] getSortedList() {
        return sortResults(getValueArray(Listcontact));
    }
}

Answer 1

让我重申一下您的要求：您需要一种方法，对从本机电话簿中读取的联系人进行排序，然后按名称对其进行按字母顺序排序。

以下是方法，

使用单个向量替换代码中的向量和哈希表，例如contactListVector，包含类型为ContactItem的元素，不要担心此类将在下面解释。从根本上说，联系人的名称和号码在ContactItem中链接在一起，因此您不必担心存在减少冗余使用的映射数据结构。

class ContactItem {
    private String name;
    private String tnumber;  //this can also be a data structure 
                             //for storing multiple numbers

    ContactItem( String name, String tnumber) {
        this.name = name;
        this.tnumber = tnumber;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getTnumber() {
        return tnumber;
    }

    public void setTnumber(String tnumber) {
        this.tnumber = tnumber;
    }        
}

您可以通过比较vector元素的成员变量contactListVector来重用ContactItem.name上的排序算法。您还可以在成员变量数字和/或名称上部署不同的排序。此外，还有许多可用的JavaME库，如果需要使用它们，可以实现更好的排序算法。

我建议你在方法contactListVector末尾的loadNames(...)元素上执行一次排序，可能在某个布尔变量触发的finally块中。在items枚举的每次迭代中，当前的排序调用既昂贵又耗时。

您也可以序列化/反序列化ContactItem，从而保留您的联系人列表。

如果您需要详细解释，请告诉我。

Answer 2

如何在recordStore中插入联系人姓名和号码，以便稍后通过创建实现RecordComparator的类进行排序。

Answer 3

您的代码中的此语句没有意义：

selectedString = lbx.getString(lbx.getSelectedFlags(arrSel))

上面的每个lcdui List API documentation将返回位于索引处的字符串等于所选元素的数量为什么需要它？

如果您需要输出所选文本以进行调试，请改用lbx.getString(i)。

以方式实现getSelectedItems（），以便抓取多个选择列表的选定索引的数量，如下所示：

    public Vector getSelectedItems(List lbx) {
        boolean[] arrSel = new boolean[lbx.size()];
        Vector selectedNumbers = new Vector();
        int selected = lbx.getSelectedFlags(arrSel);
        System.out.println("selected: [" + selected + "] elements in list");
        String selectedString;
        String result = "";
        for (int i = 0; i < arrSel.length; i++) {
            if (arrSel[i]) {
                // here, i is the selected index
                selectedNumbers.addElement(new Integer(i)); // add i to result
                String selectedString = lbx.getString(i);
                System.out.println("selected [" + selectedString
                        + "] text at index: [" + i + "]");
            }
        }
        return selectedNumbers;
    }

至于排序需求，只需删除HashTable并使用Vector正确设计的对象，而不是another answer中的建议 - 使用您自己的排序算法或来自某些第三方J2ME库的算法

Answer 4

我建议您使用名称和数字向量Contact类。而不是排序名称数组排序联系人数组。

实现从电话簿中读取联系人在J2ME中使用Hashtable

4 个答案: