Remplacer beaucoup de méthode similaire appelle à simple appel à la méthode arité variables

Question

J'ai une charge entière appels de méthode comme ceci:

thing.doOneThing(a); 
thing.doOneThing(b); 
thing.doOneThing(c); 
thing.doOneThing(d); 
// ... etc 

Mais la classe Thing a une méthode doManyThings équivalente, donc cela pourrait être réécrite :

thing.doManyThings(a, b, c, d /* etc */); 

Quelle est la bonne façon de faire ce refactoring dans intellij?

Je l'ai utilisé pour faire des remplacements de structure:

• Remplacer $t$.doOneThing($a$); $t$.doOneThing($b$); avec $t$.doManyThings($a$, $b$);
• Remplacer $t$.doManyThings($a$); $t$.doOneThing($b$); ($a$ ayant multiplicité infinie) avec $t$.doManyThings($a$, $b$);
• Remplacer $t$.doManyThings($a$); $t$.doManyThings($b$); ($a$ et $b$ ayant multiplicités infinies) avec $t$.doManyThings($a$, $b$);

Je dois continuer à faire la dernière étape encore et encore, car il fusionne des paires d'instructions correspondantes, donc cela réduit de moitié le nombre d'appels à doManyThings à chaque fois, et il doit être fait quelques fois pour les fusionner tous .

Cela semble plus difficile que cela devrait être - s'il vous plaît pouvez-vous me montrer le meilleur moyen de réaliser cela? :)

Answer 1

Personnellement j'écrirais une regex pour remplacer toutes les chaînes "thing.doOneThing (" avec une virgule (,) et une autre pour remplacer toutes les chaînes "); \ n" à rien (ou l'inverse , vous pouvez également le faire sur une zone sélectionnée au cas où vous auriez plus de code dans le fichier que vous ne voulez pas modifier). Vous aurez une virgule de début/de fin supplémentaire en fonction de l'approche que vous adopterez, mais après cela, vous aurez une belle liste séparée par des virgules de tous vos arguments. Vous pouvez ensuite remplacer tous ces appels par un seul appel à votre méthode doManyThings où vous collez la liste d'arguments séparés par des virgules.