Y a-t-il une raison de nettoyer les importations inutilisées en Java, autre que de réduire l'encombrement?

Y a-t-il une bonne raison d'éviter les instructions d'importation inutilisées en Java? Si je comprends bien, ils sont là pour le compilateur, donc beaucoup d'importations inutilisées n'auront aucun impact sur le code compilé. Est-ce juste pour réduire l'encombrement et éviter les conflits de noms sur toute la ligne?

(Je demande parce qu'Eclipse donne un avertissement sur les importations inutilisées, ce qui est un peu ennuyeux lorsque je développe du code car je ne veux pas supprimer les importations tant que je ne suis pas sûr d'avoir fini de concevoir la classe.)

Je ne pense pas que des problèmes de performances ou quelque chose comme ça soient probables si vous ne supprimez pas les importations.

Mais il peut y avoir des conflits de noms, dans de rares cas comme l'importation de l'interface de liste.

Dans Eclipse, vous pouvez toujours utiliser un raccourci (dépend du système d'exploitation - Win: Ctrl + SHIFT + Oet Mac:) COMMAND + SHIFT + Opour organiser les importations. Eclipse nettoie ensuite la section d'importation supprime toutes les importations périmées, etc. Si vous avez besoin d'une chose importée à nouveau, eclipse les ajoutera automatiquement pendant que vous complétez l'instruction avec Ctrl + SPACE. Il n'est donc pas nécessaire de conserver le code inutilisé dans votre classe.

Comme toujours, le code inutilisé vous distraira, vous et les autres, tout en lisant le code et en laissant quelque chose dans votre code actif parce que j'en ai peut-être besoin plus tard est surtout considéré comme une mauvaise pratique.

La première serait que si vous supprimez la classe référencée par l'importation du chemin de classe, vous n'obtiendrez pas une erreur de compilation idiote qui n'a servi à rien. Et vous n'obtiendrez pas de faux positifs lorsque vous effectuez une recherche «où utilisé».

Un autre (mais ce serait de nature très spécifique) serait si l'importation inutilisée avait des conflits de noms avec une autre importation, vous obligeant à utiliser des noms pleinement qualifiés inutilement.

Addendum: Aujourd'hui, le serveur de build a commencé à échouer la compilation (pas même le test en cours) avec une erreur de mémoire insuffisante. Cela a fonctionné pour toujours et les enregistrements n'ont pas apporté de modifications au processus de construction ni d'ajouts importants qui pourraient expliquer cela. Après avoir tenté d'augmenter les paramètres de mémoire (cela exécute une JVM 64 bits sur un CentOS 64 bits!) À quelque chose bien au-delà de l'endroit où les clients pourraient compiler, j'ai examiné les enregistrements un par un.

Il y avait une importation incorrecte qu'un développeur avait utilisée et abandonnée (ils ont utilisé la classe, l'ont importée automatiquement, puis ont réalisé que c'était une erreur). Cette importation inutilisée a été extraite d'un niveau distinct de l'application qui, bien que l'EDI ne soit pas configuré pour les séparer, le processus de construction l'est. Cette importation unique a entraîné tellement de classes que le compilateur a tenté de compiler sans avoir les bibliothèques dépendantes appropriées dans le chemin de classe, que cela a causé tellement de problèmes que cela a provoqué une erreur de mémoire insuffisante. Il a fallu une heure pour résoudre ce problème causé par une importation non utilisée.

D'un point de vue puriste, toute dépendance est une "contrainte" sur le produit et peut donc entraîner des problèmes de maintenance par la suite.

Par exemple, supposons que votre programme utilise la classe com.XYZObjectPool, et que plus tard vous décidez de ne pas l'utiliser mais de ne jamais supprimer l'importation. Si quelqu'un d'autre veut maintenant instancier org.WVYObjectPool et se référer simplement à ObjectPool, il ne reçoit aucun avertissement à ce sujet jusqu'à ce qu'il y ait un problème de conversion ou d'appel.

Ce n’est d’ailleurs pas un scénario irréaliste. Chaque fois que Eclipse vous demande quelle version spécifique de X vous souhaitez importer, et que vous en avez choisi une parmi de nombreux packages, il y a un scénario dans lequel si vous avez eu l'importation là-bas, vous avez peut-être fait le mauvais choix sans le savoir.

Dans tous les cas, vous pouvez demander à Eclipse de les nettoyer pour vous

Avertissement? Demandez à Eclipse de les nettoyer automatiquement pour vous. C'est ce que fait IntelliJ. S'il est assez intelligent pour vous avertir, il devrait être assez intelligent pour les nettoyer. Je recommanderais de rechercher un paramètre Eclipse pour lui dire d'arrêter d'être un tel bourrin et de faire quelque chose.

Cela a à voir avec la clarté du programme utile pour la maintenance.

Si vous deviez gérer un programme, vous découvrirez combien il est utile d'avoir une seule importation de classe par ligne.

Pensez au scénario suivant:

import company.billing.*;
import company.humanrerources.*;

// other imports 


class SomeClass {
      // hundreds or thousands of lines here... 
    public void veryImportantMethod() {
      Customer customer;
      Employee comployee;
      Department dept. 
      // do something with them
     }
 }

Lorsque vous corrigez des bogues ou maintenez un morceau de code (ou que vous le lisez seulement), il est très utile pour le lecteur de savoir à quel paquet appartiennent les classes utilisées. L'utilisation de l'importation de caractères génériques comme indiqué ci-dessus n'aide pas à cette fin.

Même avec un IDE, vous ne voulez pas survoler ou passer à la déclaration et au retour, c'est plus facile si vous comprenez en termes de fonctionnalités de quels autres packages et classes le code actuel dépend.

Si c'est pour un projet personnel ou quelque chose de petit, cela n'a vraiment pas d'importance, mais pour quelque chose de plus grand qui doit être utilisé par d'autres développeurs (et maintenu au fil des ans), c'est un MUST HAVE.

Il n'y a absolument aucune différence de performance avec aucun.

Pour info, cela m'a surpris, car je ne pensais pas que l'organisation des importations supprimait réellement les importations inutilisées, je pensais que cela les triait simplement.

La suppression automatique des importations lors d'une opération de sauvegarde m'a causé un certain problème lorsque, par exemple, pendant le développement ou le test, vous avez un problème et commentez du code, lorsque vous l'enregistrez, les importations utilisées par la section de code commentée sont supprimées. Parfois, ce n'est pas un problème car vous pouvez annuler ( Ctrl+ Z) les modifications, mais d'autres fois, ce n'est pas aussi simple que vous avez peut-être apporté d'autres modifications. J'ai également eu un problème où, lorsque j'ai décommenté le code (j'ai déjà commenté puis enregistré, supprimant ainsi les importations pour ce code), il a automatiquement essayé de deviner les importations nécessaires et de sélectionner les mauvaises (par exemple, je pense que je avait une StringUtilsclasse utilisée et il en a choisi une autre avec le même nom dans la mauvaise bibliothèque).

Je préfère organiser manuellement les importations plutôt que de l'avoir comme action de sauvegarde.

Pour eclipse, j'utilise ceci: window -> preferences -> java -> editor -> save action -> cochez la case pour organiser les importations (il y a aussi beaucoup d'autres choses utiles, comme le formatage, la finalisation des champs, etc. .). Ainsi, lorsque j'enregistre mon fichier, eclipse supprime les importations sans accès pour moi. À mon avis, si vous n'avez pas besoin de quelque chose, supprimez-le (ou laissez-le être supprimé par éclipse).

Vous pouvez commenter les instructions d'importation inutilisées et les avertissements ne vous dérangeront pas, mais vous pouvez voir ce que vous aviez.

Il n'y a aucun impact sur les performances, mais pour la lisibilité, vous pouvez le rendre propre. La suppression des importations inutilisées est assez simple dans Eclipse et IntelliJ IDEA.

Éclipse

Windows / Linux -    Ctrl+ Shift+O

Mac -                        Cmd+ Shift+O

IntelliJ IDEA ou Android Studio

Windows / Linux -    Ctrl+ Alt+O

Mac -                        Cmd+ Alt+O

J'ai lu quelque part, il y a quelques années, que chaque classe importée serait chargée au moment de l'exécution avec la classe d'importation. Ainsi, la suppression des paquets inutilisés, en particulier des paquets entiers, réduirait la charge mémoire. Bien que je suppose que les versions modernes de java traitent de cela, ce n'est probablement plus une raison.

Et au fait, avec eclipse, vous pouvez utiliser Ctrl+ Shift+ Opour organiser les importations, mais vous pouvez également configurer un "nettoyeur" qui traite de telles choses (et bien d'autres) chaque fois que vous enregistrez un fichier java.

Pour moi, une importation de classe inutilisée dans une classe de contrôleur a créé un problème de compilation dans la compilation Jenkins après avoir supprimé la classe importée pendant le nettoyage du code et commis la suppression dans git sans tester une compilation en local.