Implementar la lectura del contacto de la guía telefónica usando hashtable en J2ME
https://stackoverflow.com/questions/8399187
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Me encontré con un enlace por el cual tuve que ordenar los datos leídos de los teléfonos PIM. Al hacer esto, perdí el otro al que se hizo referencia a cada campo de contacto al número de teléfono porque utilicé 2 vectores separados como se ilustra a continuación
Antes de ordenar
Nna - +445535533
Ex - +373773737
Ab - +234575757
After sorting.(Which shouldn't be)
Ab - +445535533
Ex - +373773737
Nna - +234575757
Esto proporciona un comportamiento no deseado ya que el tipo que elimina el índice al puntero de índice de los vectores y un nombre seleccionado (en un cuadro de lista múltiple) obtendrá un número incorrecto.
Alternativamente,
Utilicé un hashtable, con la intención de usar los nombres como claves y números como valores.
Pero este emparejamiento significa que no se permitirán nombres duplicados como claves. Por lo tanto, lo hice, es decir, el número de teléfono como teclas. No quiero sonar como un bebé llorón, así que me detengo aquí por un tiempo, por lo que el código con una esperanza lo entiende
MI PREGUNTA
1. ¿Hay una mejor manera/algoritmo para implementar esto?
2. ¿Cómo implemento el getSelectedItems () de tal manera que obtenga los números de los índices seleccionados de una lista de opción múltiple de un 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));
}
}
Solución
Permítanme reiterar su requisito: desea un método que ordene los contactos leídos desde la portada nativa, luego los ordene alfabéticamente a su nombre.
El siguiente es el enfoque,
Reemplace los vectores y las tablas de hash en su código con un solo vector, digamos contactListVector, que contienen elementos de tipo ContactItem, no te preocupes, esta clase se explica a continuación. Fundamentalmente el contacto nombre y números) están vinculados juntos en un ContactItem, por lo tanto, no tiene que preocuparse por sus asignaciones que reducen el uso de estructuras de datos redundantes.
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;
}
}
Puedes reutilizar el algoritmo de clasificación en contactListVector Comparando la variable miembro ContactItem.name del elemento vectorial. También puede implementar diferentes tipos en variables de miembros números y/o nombramiento. También hay muchas bibliotecas para Javame disponibles que tienen un mejor algoritmo de clasificación implementado si es necesario usarlas.
Te recomendaría que realices la clasificación una vez en el contactListVector elementos al final de su método loadNames(...) Tal vez en el bloque Finalmente activado por alguna variable booleana. La llamada de clasificación actual en cada iteración en items La enumeración es costosa y lleva mucho tiempo.
También puede serializar / deserializar el ContactItem Persistir así su lista de contactos.
Avíseme si necesita una explicación detallada.
Otros consejos
¿Qué hay de insertar el nombre y los números de contacto dentro de una tienda de registros, por lo que luego puede hacer un tipo creando una clase que implementa RecordComparator.
Esta declaración en su código no tiene sentido:
selectedString = lbx.getString(lbx.getSelectedFlags(arrSel))
Por LCDUI LIST Documentación de API arriba devolverá la cadena ubicada en el índice igual a el número de elementos seleccionados ¿Por qué necesitarías esto?
Si necesita emitir el texto seleccionado para fines de depuración, use lbx.getString(i) en cambio.
A Implemente GetSelectedItems () de tal manera que obtenga los números de los índices seleccionados de una lista de opción múltiple Haz lo siguiente:
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;
}
En cuanto a las necesidades de clasificación, simplemente deje caer el HashTable y use Vector de objetos debidamente diseñados en su lugar como se sugiere en otra respuesta - Con su propio algoritmo de clasificación o uno de una biblioteca J2ME de tercera parte.
Te sugiero que tengas Contact clase con nombre y vector de números. Y en lugar de clasificar la matriz de nombres, clasifique la matriz de contactos.
