Fuite possible de mémoire due à l'absence de StringBuffer?

Question

Le code suivant peut-il provoquer une fuite de mémoire? L'utilisation d'un StringBuffer améliorerait-elle réellement l'utilisation de la mémoire? Un petit contexte: Un collègue a poussé ses théories sur les fuites de mémoire, et c'est un code qu'il a identifié comme étant un code de problème (sans faire de profilage), ce qui, selon lui, peut causer une fuite de mémoire. Je suis en désaccord avec cela, alors j'ai pensé que je le mettrais à d'autres développeurs pour obtenir une opinion de tiers.

List partCollection = new ArrayList() 

String partKeyID = null; 
String sPartNbr = null; 
String partDescription = null; 

while(rsPartRes.next()) 
{ 
     partKeyID = rsPartRes.getString("PART_KEY_ID"); 
     sPartNbr = rsPartRes.getString("PART_NBR"); 
     partDescription = rsPartRes.getString("PART_DESC"); 

     SomeValueObject someValueObject = new SomeValueObject(); 
     someValueObject.setPartKeyID(partKeyID); 
     someValueObject.setSPartNbr(sPartNbr); 
     someValueObject.setPartDescription(partDescription); 

     partCollection.add(someValueObject); 
} 

Supposons que rsPartRes est un ResultSet dans ce code qui peut contenir plus de 100 enregistrements. Fondamentalement, son souci est que parce que nous bouclons à travers ce jeu de résultats et n'utilise pas un StringBuffer (qui, dans ce cas, je ne suis même pas sûr comment vous en utiliseriez un), cela pourrait causer des fuites de mémoire. Y a-t-il un cas que quelqu'un voit ici où cela pourrait causer des fuites de mémoire ou des problèmes de performance ...?

Answer 1

Pour autant que je sache, il n'est pas nécessaire d'utiliser un StringBuffer ici. La seule raison d'utiliser un StringBuffer pour augmenter les performances serait de concaténer String s à plusieurs reprises.

String result = ""; 
while (condition) { 
    result += somethingElse; 
} 

ou (StringBuilder est un meilleur remplacement pour StringBuffer ces jours)

StringBuilder result = new StringBuilder(); 
while (condition) { 
    result.append(somethingElse); 
} 

La seconde partie de code est plus performant.

Answer 2

Non, cela ne provoquera pas de fuite de mémoire. Cependant, il serait plus propre de déclarer les variables à l'intérieur de la boucle:

List partCollection = new ArrayList(); 

while(rsPartRes.next()) 
{ 
    String partKeyID = rsPartRes.getString("PART_KEY_ID"); 
    String sPartNbr = rsPartRes.getString("PART_NBR"); 
    String partDescription = rsPartRes.getString("PART_DESC"); 

    SomeValueObject someValueObject = new SomeValueObject(); 
    someValueObject.setPartKeyID(partKeyID); 
    someValueObject.setSPartNbr(sPartNbr); 
    someValueObject.setPartDescription(partDescription); 

    partCollection.add(someValueObject); 
} 

Il est même pas évident pourquoi vous avez besoin de ces variables du tout:

while(rsPartRes.next()) 
{ 
    SomeValueObject someValueObject = new SomeValueObject(); 
    someValueObject.setPartKeyID(rsPartRes.getString("PART_KEY_ID")); 
    someValueObject.setSPartNbr(rsPartRes.getString("PART_NBR")); 
    someValueObject.setPartDescription(rsPartRes.getString("PART_DESC")); 

    partCollection.add(someValueObject); 
} 

(Il serait également plus agréable d'utiliser les médicaments génériques, mais c'est une question différente ...)

Comment votre collègue prévoyait-il d'utiliser StringBuffer? Il n'y a pas de manipulation de chaînes ...

Answer 3

À quoi pense-t-il qu'il fuit?

Vous ne savez pas comment StringBuilder aide ici car vous ne semblez pas créer (concaténer) de chaînes. À moins que quelque chose ne se passe à l'intérieur de SomeValueObject()