J'ai une classe de branche qui a une arrayliste d'objets clients. Dans la classe de branche, je souhaite addtransaction code> pour un nom de client donné, mais je souhaite d'abord vérifier si le client existe, puis ajoutez la transaction. private boolean customerExists(String customerName) {
for (int i = 0; i < customers.size(); i++) {
if(customers.get(i).getCustomerName().equalsIgnoreCase(customerName)) {
return true;
}
}
return false;
}
private int customerPosition(String customerName) {
for (int i = 0; i < customers.size(); i++) {
if(customers.get(i).getCustomerName().equalsIgnoreCase(customerName)) {
return i;
}
}
return -1;
}
public void addTransaction(String customerName, Double transactionValue) {
if(customerExists(customerName) == false) {
System.out.println("Customer with name " + customerName + " not found");
} else {
customers.get(customerPosition(customerName)).addTransaction(transactionValue);
}
}
6 Réponses :
Vous ne pouvez pas, en général, faire de mieux que de simplement boucler dans la liste pour trouver une valeur.
en termes de duplication de code, remplacez le corps de et, dans Si vous utilisez Java 8+, vous pouvez utiliser des flux: P> Customérexistes Code> avec: P > addtransaction () code>, stockez le résultat de ClientPosition () code> dans une variable et utilisez quevariable > = 0 code> au lieu d'appeler personnalisés () code>. P> Optional<Customer> cust = customers.stream().filter(c -> c.getCustomerName().equals(customerName)).findFirst();
Même si vous pouviez utiliser une variante mutante de «indexof», cela n'améliorerait pas l'efficacité. Pour trouver des données dans une matrice non formée, vous devez traverser le tableau la recherche. Cela est inhérent au choix d'un tableau pour stocker les données.
Mais pourquoi utilisez-vous des customérexistes du tout? La dépôt de la clientèle exécute exactement la même logique. Vous n'avez besoin que d'appeler cela une fois.
Au lieu d'utiliser plusieurs pour boucler, utilisez un seul pour boucle et obtenez l'objet client et utilisez-le,
public void addTransaction(String customerName, Double transactionValue) {
Customer customer = getCustomerUsingName(customerName)
if(customer == null) {
return;
}
customer.addTransaction(transactionValue);
}
Bonne façon pendant que je favoriserais en option à null .
De plus, il n'y a aucune raison d'utiliser une boucle indexée là-bas. Une boucle améliorée est NATATAIRE.
Utilisez Cinonposition CODE> Méthode de vérification Existe Client CODE> public void addTransaction(String customerName, Double transactionValue) {
final int index = customerPosition(customerName);
if(index == -1) {
System.out.println("Customer with name " + customerName + " not found");
} else {
customers.get(index).addTransaction(transactionValue);
}
}
Vous pouvez utiliser un hashmap à la place,
Généralement, la châtryliste est plus rapide que la haquetable dans certains cas, mais lorsque vous devez rechercher un élément, la haquetable (à l'aide de la clé pour rechercher) est plus rapide que la flambée, vous. peut l'utiliser:
D'accord avec la première réponse de Andy Turner. Après FindFirst () code> Vous pouvez appliquer ifpresent code> consommateur qui ajoutera la transaction. Iterator it = customers.iterator();
while (it.hasNext()) {
Customer customer = it.next();
if (customerPredicate.test(customer)) { // your if condition
customer.addTransaction(transactionValue); // your consumer.
break; // If you need to change only first customer.
}
}
Utilisez des angles () pour vérifier l'index de
On pourrait également utiliser une carte et ajouter des noms majuscules / minuscules à celui-ci (pour la comparaison insensible à la casse), puis obtenir un client par nom (également majuscule / minuscule). Cela aborde votre préoccupation pour l'inefficacité.