Qualche motivo per ripulire le importazioni inutilizzate in Java, oltre a ridurre il disordine?

C'è qualche buona ragione per evitare istruzioni di importazione inutilizzate in Java? A quanto ho capito, sono lì per il compilatore, quindi molte importazioni inutilizzate non avranno alcun impatto sul codice compilato. È solo per ridurre il disordine ed evitare conflitti di denominazione lungo la linea?

(Lo chiedo perché Eclipse fornisce un avviso sulle importazioni inutilizzate, il che è un po 'fastidioso quando sto sviluppando codice perché non voglio rimuovere le importazioni finché non sono abbastanza sicuro di aver finito di progettare la classe.)

Non penso che siano probabili problemi di prestazioni o qualcosa del genere se non rimuovi le importazioni.

Ma potrebbero esserci conflitti di denominazione, in rari casi come l'importazione dell'interfaccia dell'elenco.

In Eclipse puoi sempre usare un collegamento (dipende dal sistema operativo - Win: Ctrl + SHIFT + Oe Mac :) COMMAND + SHIFT + Oper organizzare le importazioni. Eclipse quindi pulisce la sezione di importazione rimuove tutte le importazioni non aggiornate ecc. Se hai bisogno di nuovo di una cosa importata, eclipse le aggiungerà automaticamente mentre stai completando l'istruzione con Ctrl + SPACE. Quindi non è necessario mantenere il codice inutilizzato nella tua classe.

Come sempre il codice inutilizzato distrarrà te e le altre persone durante la lettura del codice e lascerà qualcosa nel tuo codice attivo perché forse ne ho bisogno in seguito è per lo più visto come una cattiva pratica.

Uno sarebbe che se rimuovi la classe a cui fa riferimento l'importazione dal classpath, non otterrai uno stupido errore del compilatore che non ha avuto alcuno scopo. E non otterrai falsi positivi quando esegui una ricerca "dove usato".

Un altro (ma questo sarebbe di natura molto specifica) sarebbe se l'importazione inutilizzata avesse conflitti di denominazione con un'altra importazione, causando l'uso inutile di nomi completamente qualificati.

Addendum: oggi il server di compilazione ha iniziato la compilazione non riuscita (nemmeno il test in esecuzione) con un errore di memoria insufficiente. Ha funzionato bene per sempre e i check-in non hanno apportato modifiche al processo di compilazione o aggiunte significative che potrebbero spiegare questo. Dopo aver tentato di aumentare le impostazioni di memoria (si tratta di una JVM a 64 bit su un CentOS a 64 bit!) A qualcosa che va ben oltre il punto in cui i client potevano compilare, ho esaminato i controlli uno per uno.

C'era un'importazione impropria che uno sviluppatore aveva utilizzato e abbandonato (hanno usato la classe, l'hanno importata automaticamente e poi si sono resi conto che era un errore). Quell'importazione inutilizzata ha inserito un intero livello separato dell'applicazione che, sebbene l'IDE non sia configurato per separarli, il processo di compilazione lo è. Quella singola importazione ha trascinato in così tante classi che il compilatore ha tentato di compilare senza avere le librerie dipendenti pertinenti nel classpath, che questo ha causato così tanti problemi da causare l'errore di memoria insufficiente. Ci è voluta un'ora per risolvere questo problema causato da un'importazione inutilizzata.

Da un punto di vista purista, qualsiasi dipendenza è un "vincolo" sul prodotto e può quindi causare problemi di manutenzione in un secondo momento.

Ad esempio, supponiamo che il tuo programma utilizzi la classe com.XYZObjectPool e che in seguito decidi di non usarla ma non rimuovere mai l'importazione. Se qualcun altro ora desidera creare un'istanza di org.WVYObjectPool e fare semplicemente riferimento a ObjectPool, non riceve alcun avviso a riguardo fino a quando da qualche parte lungo la linea non c'è un problema di casting o problema di invocazione.

Questo, a proposito, non è uno scenario irrealistico. Ogni volta che Eclipse ti ha chiesto quale versione specifica di X desideri importare e ne hai scelto uno tra tanti pacchetti, è uno scenario in cui se hai avuto l'importazione potresti aver fatto la scelta sbagliata senza saperlo.

In ogni caso, puoi chiedere a Eclipse di ripulirli per te

Avvertimento? Chiedi a Eclipse di ripulirli automaticamente per te. Questo è ciò che fa IntelliJ. Se è abbastanza intelligente da avvisarti, dovrebbe essere abbastanza intelligente da ripulirli. Consiglierei di cercare un'impostazione Eclipse per dirgli di smettere di essere un tale ronzino e di fare qualcosa.

Questo ha a che fare con la chiarezza del programma utile per la manutenzione.

Se dovessi mantenere un programma scoprirai quanto sia utile avere una sola importazione di classi per riga.

Pensa al seguente scenario:

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
     }
 }

Quando si corregge un bug o si mantiene una parte di codice (o solo la si legge) è molto utile per il lettore sapere a quale pacchetto appartengono le classi utilizzate. L'utilizzo dell'importazione di caratteri jolly come mostrato sopra non aiuta a tale scopo.

Anche con un IDE, non vuoi passare il mouse o saltare alla dichiarazione e tornare, è più facile se capisci in termini di funzionalità da quali altri pacchetti e classi dipende il codice corrente.

Se questo è per un progetto personale o qualcosa di piccolo, non importa, ma per qualcosa di più grande che deve essere utilizzato da altri sviluppatori (e mantenuto negli anni) questo è un MUST HAVE.

Non c'è assolutamente alcuna differenza di prestazioni con nessuno.

Cordiali saluti, questo mi ha colto di sorpresa, poiché non pensavo che l'organizzazione delle importazioni rimuovesse effettivamente le importazioni inutilizzate, pensavo che le avesse semplicemente ordinate.

La rimozione automatica delle importazioni durante un'operazione di salvataggio mi ha causato qualche problema quando, ad esempio, durante lo sviluppo o il test si ha un problema e si commenta del codice, quando lo si salva, le importazioni utilizzate dalla sezione di codice commentata vengono rimosse. A volte questo non è un problema in quanto puoi annullare ( Ctrl+ Z) le modifiche, ma altre volte non è così semplice in quanto potresti aver apportato altre modifiche. Ho anche avuto un problema in cui quando ho decommentato il codice (ho precedentemente commentato e salvato, rimuovendo così le importazioni per quel codice), ha cercato automaticamente di indovinare le importazioni che erano necessarie e ha raccolto quelle sbagliate (ad es. aveva unStringUtils classe in uso e ne ha scelta un'altra con lo stesso nome dalla libreria sbagliata).

Preferisco organizzare manualmente le importazioni piuttosto che averlo come azione di salvataggio.

Per eclipse uso questo: finestra -> preferenze -> java -> editor -> salva azione -> seleziona la casella di controllo per organizzare le importazioni (ci sono anche molte altre cose utili, come la formattazione, rendere i campi finali e così via. .). Quindi, quando salvo il mio file, eclipse rimuove le importazioni di unessacry per me. Secondo me, se non hai bisogno di qualcosa, rimuovilo (o lascia che venga rimosso da eclipse).

Puoi commentare le istruzioni di importazione inutilizzate e gli avvisi non ti daranno fastidio, ma puoi vedere cosa avevi.

Non c'è alcun impatto sulle prestazioni, anche se per leggibilità puoi renderlo pulito. La rimozione delle importazioni inutilizzate è abbastanza semplice sia in Eclipse che in IntelliJ IDEA.

Eclisse

Windows / Linux -    Ctrl+Shift +O

Mac -                        Cmd+ Shift+O

IntelliJ IDEA o Android Studio

Windows / Linux -    Ctrl+Alt +O

Mac -                        Cmd+ Alt+O

Ho letto da qualche parte, alcuni anni fa, che ogni classe importata sarebbe stata caricata in fase di esecuzione con la classe importatrice. Quindi la rimozione di pacchetti inutilizzati, specialmente interi, ridurrebbe il sovraccarico di memoria. Anche se suppongo che le versioni moderne di java si occupino di questo, quindi probabilmente non è più un motivo.

E a proposito, con eclipse puoi usare Ctrl+ Shift+ Oper organizzare le importazioni, ma puoi anche configurare un "pulitore" che si occupi di queste cose (e molte altre) ogni volta che salvi un file java.

Per me, un'importazione di classi inutilizzata in una classe controller ha creato un problema di compilazione nella build di Jenkins dopo che ho eliminato la classe importata durante la pulizia del codice e ho eseguito l'eliminazione in git senza testare una build in locale.