Meilleure façon de parcourir et de trouver un champ d'objet à partir d'une liste

Question

J'ai une liste d'objets personnalisés et je veux trouver un objet par un ID donné (un champ dans un objet personnalisé). Je codais pour cela, donc j'ai trouvé deux solutions lors de la comparaison des champs.

private Product getProduct(String productId,List<Product> productList){ 
     for (int i = 0; i < productList.size(); i++) { 
      if (productId.equals(productList.get(i).getId())) { 
       return productList.get(i); 
      } 


     } 
     return null; 
    } 

2.

private Product getProduct(String productId,List<Product> productList){ 
     for (int i = 0; i < productList.size(); i++) { 
      if (productList.get(i).getId().equals(productId)) { 
       return productList.get(i); 
      } 
     } 
     return null; 
    } 

La différence est en if état, je veux savoir que l'on est mieux que l'autre et pourquoi, quand utiliser 1ère méthode et quand utiliser la seconde?

Answer 1

La première appelle equals sur le paramètre productId, tandis que le second invoque equals sur l'élément de la liste actuelle de productList. Le résultat est le même, car equals est symétrique :

pour toutes doit renvoyer true valeurs de référence non nuls x et y, x.equals(y) si et seulement si les rendements y.equals(x) vrai.

Vous pouvez également utiliser un flux pour cela, de sorte que vous n'avez pas à se soucier des détails de mise en œuvre (par ailleurs, Objects#equals(Object, Object) est nul-safe):

String p = productList.stream().filter(e -> Objects.equals(e, productId)) 
           .findFirst() 
           .orElse(null); 

un coup d'oeil une question this pour plus d'informations.

Answer 2

Depuis equals() est required par Java pour être symétrique, il n'y a pas de différence entre les deux extraits.

Les deux extraits sont sous-optimaux, en ce sens qu'ils parcourent par index numérique et récupèrent deux fois productList.get(i) avant de les renvoyer. Itérer par index est particulièrement dangereux, car le passage d'un LinkedList<Product> ralentira considérablement votre recherche.

Une meilleure approche est d'utiliser un pour-chaque forme de la boucle:

for (Product p : productList) { 
    if (p.getId().equals(productId)) { 
     return p; 
    } 
} 
return null; 

Answer 3

Lorsque vous êtes sûr que l'id produit de ce ne sont jamais nuls ça n'a pas vraiment d'importance.

Mais en général, il est toujours bon de programmer de manière défensive, donc par exemple préfèrent utiliser

"SomeString".equals(aString) 

au lieu de

aString.equals("SomeString") 

puisque vous savez « SomeString » est jamais null.

Ou utilisez

Objects.equals(object1, object2) 

quand peut-être les deux objets null.

Answer 4

La préoccupation dans vos deux implémentations est la possibilité d'appeler .equals sur une valeur nulle.

Si vous pouvez garantir qu'aucun d'eux n'est nul alors ils sont équivalents.

Si vous utilisez Java 8, le flux peut être un meilleur choix.

private Product getProduct(String productId,List<Product> productList){ 
    return products.stream() 
     .filter(p-> productId.equals(p.getId()) 
     .findFirst() 
     .orElse(null);