D'accord, cela peut être une question boiteuse, mais tout le monde utilise ces choses différemment. Quels sont les meilleurs gains de temps pour cet IDE?

À M

N'oubliez pas Ctrl+ Shift+ L, qui affiche une liste de toutes les combinaisons de raccourcis clavier (juste au cas où vous oublieriez l'une de celles listées ici).

Ctrl-2 quelque chose

Il semble que personne n'ait mentionné Ctrl-2 L (assigner à une nouvelle variable locale) et Ctrl-2 F (assigner à un nouveau champ), ceux-ci ont changé la façon dont j'écris le code.

Auparavant, je tapais, disons (| est l'emplacement du curseur):

Display display = new |

puis j'ai poussé Ctrl-Space pour terminer l'appel du constructeur. Maintenant je tape:

new Display()|

et appuyez sur Ctrl-2 L, ce qui entraîne:

Display display = new Display()|

Cela accélère vraiment les choses. (Ctrl-2 F fait la même chose, mais affecte un nouveau champ plutôt qu'une nouvelle variable.)

Un autre bon raccourci est Ctrl-2 R: renommer dans le fichier. C'est beaucoup plus rapide que de renommer le refactoring (Alt-Shift-R) lorsque vous renommez des choses comme des variables locales.

En fait, je suis allé à la page de préférences de personnalisation des touches et j'ai attribué toutes sortes de correctifs rapides supplémentaires à Ctrl-2-something. Par exemple, j'appuie maintenant sur Ctrl-2 J pour diviser / joindre la déclaration de variable, Ctrl-2 C pour extraire une classe interne dans le niveau supérieur, Ctrl-2 T pour ajouter une déclaration de lancement à la fonction, etc. correctifs, allez choisir vos favoris et attribuez-les aux raccourcis Ctrl-2.

Modèles

Un autre de mes favoris dans mon modèle "npe", défini comme:

if (${arg:localVar} == null)
    throw new ${exception:link(NullPointerException,IllegalArgumentException)}("${arg:localVar} is null");

Cela me permet d'ajouter rapidement des vérifications d'argument nul au début de chaque fonction (en particulier celles qui enregistrent simplement l'argument dans un champ ou l'ajoutent dans une collection, en particulier les constructeurs), ce qui est idéal pour détecter les bogues tôt.

Voir des modèles plus utiles sur www.tarantsov.com/eclipse/templates/ . Je ne les énumérerai pas tous ici car il y en a beaucoup et parce que j'en ajoute souvent de nouveaux.

Achèvement

Quelques astuces de complétion de code:

• support de cas de chameau mentionné dans une autre réponse: tapez cTM, obtenez currentTimeMillis
• constructeur par défaut: dans la déclaration de classe sans constructeur par défaut, appuyez sur Ctrl-Espace, le premier choix sera d'en créer un
• surcharge: dans la déclaration de classe, commencez à taper le nom d'une méthode que vous pouvez surcharger, Ctrl-Space, choisissez-en une
• création de getter / setter: tapez «get», Ctrl-Space, choisissez un getter à créer; même chose avec "est" et "défini"

Attribuer à un nouveau champ

C'est ainsi que j'ajoute des champs.

1. Si vous n'avez pas encore de constructeur, ajoutez-en un. (Ctrl-Espace n'importe où dans une déclaration de classe, choisissez la première proposition.)

2. Ajoutez un argument (| est la position du curseur):

   public class MyClass {
       public MyClass(int something|) {
       }
   }

3. Appuyez sur Ctrl-1, choisissez «assigner à un nouveau champ». Vous obtenez:

   public class MyClass {
       private final Object something;
       public MyClass(Object something) {
           this.something = something;
       }
   }

4. Ajoutez une vérification de pointeur nul le cas échéant (voir le modèle «npe» ci-dessus):

   public class MyClass {
       private final Object something;
       public MyClass(Object something) {
           npe|
           this.something = something;
       }
   }

   Appuyez sur Ctrl-Espace, obtenez:

   public class MyClass {
       private final Object something;
       public MyClass(Object something) {
           if (something == null)
               throw new NullPointerException("something is null");
           this.something = something;
       }
   }

Un excellent gain de temps!

ctrl-shift-r et son compagnon, ctrl-shift-t, pour ouvrir une ressource ou un type, respectivement. Resources inclut tous les fichiers de vos projets ouverts (y compris les fichiers non java), et les types inclut les types java soit dans vos projets, soit dans une bibliothèque incluse dans les projets.

Crtl+ 1est mon préféré. Les correctifs rapides pour les gribouillis rouges.

Il se trouve également dans le menu Edition -> Correction rapide.

Ctrl+ Shift+ Opour organiser les importations, ce qui les formatera bien, supprimera les importations inutiles et ajoutera les importations manquantes.

Ctrl-J lance une recherche incrémentielle.

Appuyez sur Ctrl-J, puis commencez à taper. Utilisez haut / bas pour trouver les instances précédentes / suivantes de ce que vous avez tapé.

Ctrl-Shift-J recherche en arrière.

Tapez 'syso' puis appuyez sur Ctrl+Space pour le développer en System.out.println ().

Très pratique.

CTRL+ 3affiche une liste de saisie anticipée de toute commande de menu.

• CTRL-SHIFT-g: trouve les utilisations de la méthode ou du champ sous le curseur, absolument nécessaire pour comprendre le code
• CTRL-F6: naviguez entre la liste des fenêtres de l'éditeur ouvertes, si vous le tapez une seule fois et que vous laissez aller, vous revenez à la fenêtre de l'éditeur précédente, le faire successivement est un bon moyen de sauter d'avant en arrière
• CTRL-t: sur une classe ou une méthode vous montrera la hiérarchie des types, très utile pour trouver des implémentations d'une méthode d'interface par exemple

Cliquer sur le type de retour dans la déclaration d'une méthode met en évidence tous les points de sortie de la méthode.

par exemple:

1: public void foo()
2: {
3:   somecode();
4:    if ( blah ) return;
5:
6:    bar();
7: }

cliquer sur annuler mettra en évidence le retour à la ligne 4 et la fermeture } à la ligne 7.

Mise à jour : cela fonctionne même pour les blocs try {} catch. Si vous placez le curseur sur l'exception dans le bloc catch et eclipse mettra en évidence les méthodes probables qui peuvent lever cette exception.

La complétion de code prend en charge CamelCase, par exemple, la saisie CWARaffichera un résultat pourClassWithAReallyLongName . Commencez à utiliser cette fonctionnalité et vous ne saisirez plus jamais un autre nom de classe long.

(parties copiées d'une autre réponse parce que je pense que les réponses avec un seul indice / conseil sont les meilleures pour le sondage)

Alt-Flèche haut déplace la sélection actuelle d'une ligne vers le haut, Alt-Flèche bas la déplace vers le bas. J'utilise aussi tout le temps Alt-Shift-Up / Down Arrow. Ctrl-K et Ctrl-Shift-K sont assez pratiques, trouvant l'occurrence suivante / précédente de la sélection actuelle (ou de la dernière recherche, si rien n'est sélectionné).

Il y a une option pour placer l'accolade ouvrante et un point-virgule automatiquement dans la position "correcte". Vous devrez l'activer - Choisissez Fenêtre / Préférences et tapez "accolade" dans la boîte de recherche - devrait être facilement trouvable (pas d'éclipse sur cet ordinateur). L'effet:

• Taper un point-virgule n'importe où sur la ligne le placera à cette fin de ligne (comme dans word / openoffice: Backspace si vous souhaitez l'avoir à la place d'origine)
• Taper une accolade ouvrante lorsque vous êtes juste à l'intérieur d'une autre paire d'accolades la placera à la fin de cette ligne - comme dans cet exemple

("|" est le curseur):

if(i==0|)

taper "{" maintenant entraînera

if(i==0) {|

Hippie expand / Word Complete, afaik inspiré par Emacs: complétera automatiquement n'importe quel mot dans n'importe quel éditeur basé sur d'autres mots de ce fichier. Saisie semi-automatique dans les littéraux String dans le code Java, dans des fichiers xml, partout.

Alt + /

Alt-Shift-R signifie renommer , pas refactoriser. Le refactoring est un terme plus général (tel que défini par le livre ).

Néanmoins, c'est l'un de mes refactorings préférés. D'autres incluent:

• Alt-Shift-M : méthode d'extraction (lorsqu'un bloc de code ou une expression est sélectionné)

• Alt-Shift-L : Extraire la variable locale (lorsqu'une expression est sélectionnée)

Extraire la variable locale est particulièrement utile lorsque je ne me souviens pas (ou que je prends la peine de taper) le type de résultat d'une méthode. En supposant que vous avez une méthode JdbcTemplate createJdbcTemplate()dans votre classe, écrivez du code comme celui-ci:

void someQuery() {
    createJdbcTemplate()
}

Sélectionnez l'expression createJdbcTemplate(), cliquez sur Alt-Maj-L, saisissez le nom de la variable et appuyez sur Entrée.

void someQuery() {
    JdbcTemplate myTemplate = createJdbcTemplate();
}

CTRL+ D- pour supprimer la ligne actuelle

Absolument, Ctrl+ Qpour accéder au dernier emplacement d'édition. C'est très utile juste après avoir été interrompu par téléphone, patron ou autres.

Ctrl+ Shift+ M: change une méthode statique ou une référence d'attribut statique d'une classe en une importation statique.

Avant

import X;

...
X.callSomething();

Après

import static X.callSomething;

...
callSomething();

Alt+ Shift+ La Upflèche fait une sélection croissante. Alt+ Shift+ Downfait le contraire.

Alt+ Upou Alt+ Downpour déplacer les lignes

Personne n'a encore mentionné le meilleur. Cliquez sur un nom de classe ou de méthode et appuyez sur Ctrl+T .

Vous obtenez une hiérarchie de types rapide. Pour un nom de classe, vous voyez toute la hiérarchie des classes. Pour un nom de méthode, vous obtenez la hiérarchie montrant les superclasses et les sous-classes, avec les implémentations de cette méthode distinctes des mentions abstraites ou des classes qui ne mentionnent pas la méthode.

C'est énorme lorsque vous êtes à une déclaration de méthode abstraite et que vous voulez rapidement voir où elle est implémentée.

F3 a été mon préféré, ouvre la définition de l'élément sélectionné.

Ctrl+ Shift+ Ra une fonctionnalité intéressante, vous pouvez utiliser uniquement les lettres majuscules de chameau d'une classe lors de la recherche (comme taper CWAR affichera un résultat pour ClassWithAReallyLongName).

Alt+ Shift+ W> L'Explorateur de packages facilite la vie lors de la navigation de grands projets.

Une astuce sans raccourci clavier consiste à utiliser des ensembles de validation dans votre vue Équipe-> Synchroniser pour organiser vos modifications avant de valider.

Définissez un ensemble de modifications comme valeur par défaut, et toutes les modifications que vous apportez aux fichiers seront placées dans cet ensemble, ce qui vous permettra de voir facilement ce que vous avez changé lorsque vous travaillez sur un défaut / une fonctionnalité spécifique, et d'autres modifications que vous avez apportées lors des tests, etc.

CTRL + ESPACE, pour tout, n'importe où.

Générez des getters et des setters.

Créer des constructeurs à l'aide de champs

Méthode d'extraction ...

Refactoriser-> Renommer

CTRL + O pour le contour rapide. CTRL + O + CTRL + O pour le contour hérité.

F4 pour afficher une hiérarchie de types

Ouvrez la hiérarchie des appels pour afficher d'où une méthode est appelée.

CTRL + SHIFT + T pour ouvrir un type Java

CTRL + SHIFT + R pour ouvrir n'importe quelle ressource.

ALT + gauche ou droite pour avancer ou reculer dans les emplacements d'édition de vos documents (navigation facile)

Remplacez / implémentez des méthodes si vous savez que vous allez faire beaucoup de méthodes (sinon, CTRL + ESPACE est préférable pour une sélection à la fois.

Refactor-> Extraire l'interface

Refactor-> Pull up

Refactor-> Push down

CTRL + SHIFT + O pour organiser les importations (lorsque vous tapez le nom de la classe générale comme Map, appuyez sur CTRL + ESPACE puis sélectionnez la classe appropriée pour l'importer directement pour vous).

CTRL + SHIFT + F pour le formatage (bien que le formateur intégré d'Eclipse puisse être un peu braindead pour de longues lignes de code)

EDIT: Oh ouais, un peu de débogage:

F5: Entrez (montrez-moi les détails!)

F6: Passez au-dessus (je vous crois, passez à la partie suivante ...)

F7: Sortez (je pensais que cette méthode m'intéressait, mais il s'avère que non, sortez-moi d'ici!)

F8: Reprendre (aller jusqu'à ce que le prochain point d'arrêt soit atteint)

CTRL + SHIFT + I: inspecter une expression. CTRL + SHIFT + I + CTRL + SHIFT + I: crée une expression de surveillance sur l'expression inspectée.

Points d'arrêt conditionnels: Faites un clic droit sur un point d'arrêt et vous pouvez définir une condition qui se produit qui déclenche sa rupture de l'exécution du programme (l'assistance contextuelle, avec Ctrl + Espace, est disponible ici!)

F11 - Dernier lancement du débogage (application)

CTRL + F11 - Dernière exécution lancée (application)

Point d'arrêt sur exception

Eclipse vous permet de définir des points d'arrêt en fonction de l'endroit où une exception se produit.
Vous accédez à l'option via le "j!" texte alternatif http://help.eclipse.org/stable/topic/org.eclipse.jdt.doc.user/images/org.eclipse.jdt.debug.ui/elcl16/exc_catch.png icône dans la fenêtre de débogage.

texte alternatif http://blogs.bytecode.com.au/glen/2007/04/06/images/2007/AddExceptionWindow.png

La rubrique d'aide officielle " Ajouter un point d'arrêt d'exception Java " en contient plus.

• L'option d'exception non interceptée consiste à suspendre l'exécution lorsqu'une exception du même type que le point d'arrêt est levée dans un emplacement non intercepté.
• L'option d'exception interceptée consiste à suspendre l'exécution lorsqu'une exception du même type que le point d'arrêt est levée dans un emplacement intercepté.
• n'oubliez pas l' exception Breakpoint Suspend on Subclass de cette exception :
  pour suspendre l'exécution lorsque des sous-classes de type exception sont rencontrées.
  Par exemple, si un point d'arrêt d'exception pour RuntimeExceptionest configuré pour se suspendre sur des sous-classes, il sera également déclenché par unNullPointerException .

texte alternatif http://help.eclipse.org/stable/topic/org.eclipse.jdt.doc.user/reference/breakpoints/images/ref-breakpoint_suspendsubclass.PNG

Ctrl+ Alt+ Hsur une méthode pour obtenir la hiérarchie des appels. Moyen rapide de voir d'où il est appelé.

Ctrl+ Alt+ UPou Ctrl+ Alt+ DOWNpour copier des lignes

Alt+ Shift+ Rpour refactoriser et renommer.

Voici ma collection des raccourcis clavier les plus utiles pour Eclipse 3:

Eclipse 3 Favorite Keyboard Shortcuts. 
by -=MaGGuS=-

Navigate:

•   Ctrl + Shift + L – Shows useful keyboard shortcuts in popup window 
•   Ctrl + H – Search.
•   Ctrl + K – Goes to next search match in a single file. Shift + Ctrl + K – goes to previous match.
•   F3 - Goes to ‘declaration’ of something. Same as Ctrl + Click.
•   Ctrl + Shift + G - Use this on a method name or variable. It will search for references in the code (all the code) to that item.
•   Ctrl + O – Shows outline view of the current class or interface.
•   Ctrl + T – Shows class hierarchy of the current class or interface. F4 – shows the same in separate tab.
•   Ctrl + Shift + T - Open Type. Search for any type globally in the workspace.
•   Ctrl + Shift + R – Open Resource. Search for any file inside workspace.
•   Ctrl + J – Incremental search. Similar to the search in firefox. It shows you results as you type. Shift + Ctrl +J - Reverse incremental search.
•   Ctrl + Q – Goes to the last edit location.
•   Ctrl + Left|Right – Go Back/Forward in history.
•   Ctrl + L – Go to line number.
•   Ctrl + E – This will give you a list of all the source code windows that are currently open. You can arrow up or down on the items to go to a tab.
•   Ctrl +PgUp|PgDown – Cycles through editor tabs.
•   Ctrl + Shift + Up|Down - Bounces you up and down through the methods in the source code.
•   Ctrl + F7 – Switches between panes (views).
•   Ctrl + ,|. – Go to the previous/next error. Great in combination with Ctrl + 1.
•   Ctrl + 1 on an error – Brings up suggestions for fixing the error. The suggestions can be clicked.
•   Ctrl + F4 – Close one source window.

Edit:

•   Ctrl + Space – Auto-completion.
•   Ctrl + / – Toggle comment selected lines.
•   Ctrl + Shift + /|\ – Block comment/uncomment selected lines.
•   Ctrl + Shift + F – Quickly ‘formats’ your java code based on your preferences set up under Window –> Preferences.
•   Ctrl + I – Correct indentations.
•   Alt + Up|Down – move the highlighted code up/down one line. If nothing is selected, selects the current line.
•   Ctrl + D – Delete row.
•   Alt + Shift + Up|Down|Left|Right – select increasing semantic units.
•   Ctrl + Shift + O – Organize Imports.
•   Alt + Shift + S – Brings up “Source” menu.
o   Shift + Alt + S, R – Generate getter/setter.
o   Shift + Alt + S, O – Generate constructor using fields.
o   Shift + Alt + S, C – Generate constructor from superclass.
•   Alt + Shift + T – Brings up “Refactor” menu.
•   Alt + Shift + J – Insert javadoc comment.
•   F2 – Display javadoc popup for current item. Shift + F2 – Display javadoc in external browser.

Run/Debug:

•   F11 / Ctrl + F11 – Execute/debug.
•   Ctrl + Shift +B – Toggle breakpoint.
•   When paused: F5 – Step into, F6 – Step over, F7 – Step out, F8 – Resume.
•   Ctrl + F2 – Terminate.

EOF

Pas si caché mais IMO le meilleur truc.

En supposant les paramètres par défaut (et vous n'avez pas ajouté de nouveaux extraits)

Mettez en surbrillance (ou sélectionnez) un texte (chaîne ou variable) ... Appuyez sur Ctrl + Espace. Appuyez sur Fin + Entrée. l'extrait de code "sysout" est déclenché et encapsule la sélection comme son paramètre.

par exemple.

 "hello world!"

becomes
System.out.println("hello world!");

Je l'aime tellement que j'ai implémenté un extrait de code similaire pour Toast et Log.i () d'Android ÉNORME gain de temps pendant le débogage manuel ...