Les assistants rapides effectuent des transformations de code locales. Ils sont appelés par sélection ou par curseur unique dans l'éditeur Java et
utilisent le même raccourci que pour les correctifs rapides (Ctrl+1), mais sont généralement masqués en cas d'erreur. Pour les afficher, même en cas d'erreurs présentes sur la même ligne, appuyez de nouveau sur Ctrl+1.
Une sélection d'assistants rapides peut être affectée à un raccourci direct. Par défaut, ces raccourcis sont les suivants :
Affectez d'autres raccourcis ou modifiez les raccourcis par défaut sur la page des préférences
Général > Touches (dans la catégorie 'Source').
La page des préférences de l'éditeur Java comprend une ampoule d'assistant rapide que vous pouvez activer en accédant à cette page :
Java > Editeur.
| Nom | Exemple de code | Emplacement d'appel | ||
|---|---|---|---|---|
| Inverser une instruction if |
if (x) a(); else b();
|
> |
if (!x) b(); else a();
|
Sur des instructions 'if' avec un bloc 'else' |
| Inverser une expression booléenne |
a && !b
|
> |
!a || b
|
Sur une expression booléenne |
| Inverser la variable locale |
boolean a = false;
|
> |
boolean notA = true;
|
Sur une variable booléenne |
| Inverser l'égalité |
a.equals(b)
|
> |
b.equals(a)
|
sur un appel de 'equals' |
| Inverser l'expression conditionnelle |
x ? b : c
|
> |
!x ? c : b
|
Sur une expression conditionnelle |
| Décaler la négation vers l'amont |
b && c
|
> |
!(!b || !c)
|
Sur une expression booléenne |
| Décaler la négation en aval |
!(b && c)
|
> |
!b || !c
|
Sur une expression booléenne inversée |
| Supprimer les parenthèses supplémentaires |
if ((a == b) && (c != d) {}
|
> |
if (a == b
&& c != d) {}
|
Sur des expressions sélectionnées |
| Placer l'expression entre parenthèses |
return a > 10 ? 1 : 2;
|
> |
return (a > 10) ? 1 : 2;
|
Sur une expression sélectionnée |
| Placer les expressions entre parenthèses |
if (a == b
&& c != d) {}
|
> |
if ((a == b) && (c != d)) {}
|
Sur des expressions sélectionnées |
| Joindre des instructions if imbriquées |
if (a) { if (b) {} }
|
> |
if (a && b) {}
|
Sur une instruction if imbriquée |
| Permuter les instructions if imbriquées |
if (a) { if (b) {} }
|
> |
if (b) { if (a) {} }
|
Sur une instruction if imbriquée |
| Fractionner une instruction if avec une expression and'ed |
if (a && b) {}
|
> |
if (a) { if (b) {} }
|
Sur une expression and'ed dans un 'if' |
| Joindre les instructions 'if' sélectionnées avec || |
if (a) x(); if (b) x();
|
> |
if (a || b) x();
|
Sur des instructions 'if' sélectionnées |
| Joindre la séquence 'if' dans if-else-if |
if (a) x(); if (b) y();
|
> |
if (a) x(); else if (b) y();
|
Sur des instructions 'if' sélectionnées |
| Fractionner une instruction if avec une expression or'd |
if (a || b) x();
|
> |
if (a) x(); if (b) x();
|
Sur une expression or'd dans un 'if' |
| Affectation If-else à une expression conditionnelle |
if (a) x= 1; else x= 2;
|
> |
x= a ? 1 : 2;
|
Sur une instruction 'if' |
| renvoi If-else à une expression conditionnelle |
if (a) return 1;
|
> |
return a ? 1 : 2;
|
Sur une instruction 'if' |
| Affectation d'une expression conditionnelle à If-else |
x= a ? 1 : 2;
|
> |
if (a) x= 1; else x= 2;
|
Sur une expression conditionnelle |
| Renvoi d'une expression conditionnelle à If-else |
return
a ? 1 : 2;
|
> |
if (a) return 1; else return 2;
|
Sur une expression conditionnelle |
| Passer à If-else |
switch (kind) {
|
> |
if (kind == 1) {
|
Sur une instruction switch |
| Ajouter les instructions case manquantes sur enums |
switch (e){
|
> |
switch (e){
|
Sur une instruction switch |
| Permuter les opérandes |
a + b
|
> |
b + a
|
Sur une opération infix |
| Transtyper et affecter |
if (obj
instanceof Vector) {
|
> |
if (obj
instanceof Vector) {} |
Sur une instance d'expression dans une instruction if ou while |
| Utiliser des blocs catch séparés |
try {
|
> |
try {
|
Sur un bloc multi-catch (version 1.7 ou supérieure) |
| Déplacer les exceptions vers les blocs catch séparés |
try {
|
> |
try {
|
Sur les exceptions dans une clause multi-catch (version 1.7 ou supérieure) |
| Combiner des blocs catch |
try {
|
> |
try {
|
Sur un bloc catch (version 1.7 ou supérieure) |
| Ajouter un bloc finally |
try {
|
> |
try {
|
sur une instruction try/catch |
| Ajouter un bloc else |
if (a) b();
|
> |
if (a) b(); else { }
|
sur une instruction if |
| Remplacer une instruction par un bloc |
if (a) b();
|
> |
if (a) { b(); }
|
sur une instruction if |
| Ouvrir des blocs |
{ a() }
|
> |
a()
|
sur des blocs, instructions if/while/for |
| Extraire une chaîne |
"abcdefgh"
|
> |
"abc" + "de" + "fgh"
|
Sélection littérale d'une partie d'une chaîne |
| Convertir une concaténation de chaînes en StringBuilder (J2SE 5.0) ou StringBuffer |
"Hello " + nom
|
> |
StringBuilder builder= new StringBuilder();
|
Sélection d'un littéral de chaîne |
| Convertir une concaténation de chaînes en MessageFormat |
"Hello " + nom
|
> |
MessageFormat.format("Hello {0}", nom);
|
Sélection d'un littéral de chaîne |
| Fractionner une variable |
int i= 0;
|
> |
int i; i= 0;
|
sur une variable avec initialisation |
| Joindre une variable |
int i; i= 0;
|
> |
int i= 0
|
sur une variable sans initialisation |
| Affecter une variable |
foo()
|
> |
X x= foo();
|
sur une instruction d'expression |
| Extraire vers local |
foo(getColor());
|
> |
Color color= getColor();
|
Sur une expression |
| Affecter le paramètre à la zone |
public A(int
color) {}
|
> |
Color fColor;
|
sur un paramètre |
| Initialiseur de tableau en création de tableau |
int[] i= { 1, 2, 3 }
|
> |
int[] i= new int[] { 1, 2, 3 }
|
sur un initialiseur de tableau |
| Convertir en 'enhanced for loop' (J2SE 5.0) |
for (Iterator
i= c.iterator();i.hasNext();) {
|
> |
for (x : c) {
|
Sur une boucle for |
| Convertir en boucle 'for' indexée (J2SE 5.0) |
for (x : c) {
|
> |
for (int i = 0; i < c.size(); i++) {
|
Sur une boucle for améliorée |
| Convertir en boucle 'for' basée sur un itérateur (J2SE 5.0) |
for (x : c) {
|
> |
for (Iterator
i= c.iterator();i.hasNext();) {
|
Sur une boucle for améliorée |
| Créer une méthode en super classe |
|
|
|
sur une déclaration de méthode |
| Renommer dans un fichier |
|
|
|
sur des identificateurs |
| Renommer dans l'espace de travail |
|
|
|
sur des identificateurs |
| Extraire et placer dans une variable locale |
a= b*8;
|
> |
int x= b*8;
|
Sur les expressions |
| Extraire vers la constante |
a= 8;
|
> |
final static int CONST= 8;
|
Sur les expressions |
| Extraire la méthode |
int x= p * 5;
|
> |
int x= getFoo(p);
|
Sur des expressions et des instructions |
| Aligner une variable locale |
int a= 8, b= a;
|
> |
int b= 8;
|
Sur les variables locales |
| Convertir la variable locale en zone |
void foo() { int a= 8; }
|
> |
int a= 8; void foo() {}
|
Sur les variables locales |
| Convertir une classe anonyme en classe imbriquée |
new Runnable() { };
|
> |
class RunnableImplementation implements Runnable { }
|
Sur les classes anonymes |
| Remplacer par une méthode getter et setter (Encapsulation de zone) |
p.x;
|
> |
p.getX();
|
Sur les zones |
| Insérer des arguments de type déduit |
List<String> list = new ArrayList<>();
|
> |
List<String> list = new ArrayList<String>();
|
Sur des expressions de création d'instance générique (version 1.7 ou supérieure) |
Les assistants rapides suivants sont disponibles dans l'éditeur de fichier de propriétés :
Editeur Java
Correctif rapide et assistant rapide