Las asistencias rápidas realizan transformaciones de código
local. Se invocan en una selección o en un cursor individual en el editor Java y utilizan el mismo acceso directo que
el de los arreglos rápidos (Control+1), pero las asistencias rápidas suelen estar ocultas cuando hay un error de
por medio. Para mostrarlas incluso con errores presentes en la misma línea, pulse Control+1 una segunda vez.
Una selección de asistencias rápidas se puede asignar a un acceso directo. Estas son, de forma predeterminada:
Asigne más accesos directos o cambie los accesos directos predeterminados en la página de preferencias
General > Teclas (en la categoría 'Fuente').
Se puede activa una bombilla de asistencia rápida en la página de preferencias
Java > Editor.
| Nombre | Ejemplo de código | Ubicación de invocación | ||
|---|---|---|---|---|
| Sentencia if inversa |
if (x) a(); else b();
|
> |
if (!x) b(); else a();
|
En sentencias 'if' con bloque 'else' |
| Expresión booleana inversa |
a && !b
|
> |
!a || b
|
En una expresión booleana |
| Invertir variable local |
boolean a = false;
|
> |
boolean notA = true;
|
En una variable boolean |
| Invertir igual |
a.equals(b)
|
> |
b.equals(a)
|
En una invocación de 'equals' |
| Expresión condicional inversa |
x ? b : c
|
> |
!x ? c : b
|
En una expresión condicional |
| Promover negación |
b && c
|
> |
!(!b || !c)
|
En una expresión booleana |
| Degradar negación |
!(b && c)
|
> |
!b || !c
|
En una expresión booleana negada |
| Eliminar paréntesis extra |
if ((a == b) && (c != d) {}
|
> |
if (a == b
&& c != d) {}
|
En expresiones seleccionadas |
| Poner expresión entre paréntesis |
return a > 10 ? 1 : 2;
|
> |
return (a > 10) ? 1 : 2;
|
En expresión seleccionada |
| Poner expresiones entre paréntesis |
if (a == b
&& c != d) {}
|
> |
if ((a == b) && (c != d)) {}
|
En expresiones seleccionadas |
| Unir sentencias if anidadas |
if (a) { if (b) {} }
|
> |
if (a && b) {}
|
En una sentencia if anidada |
| Intercambiar sentencias if anidadas |
if (a) { if (b) {} }
|
> |
if (b) { if (a) {} }
|
En una sentencia if anidada |
| Dividir sentencia if con expresión and |
if (a && b) {}
|
> |
if (a) { if (b) {} }
|
En una expresión and en 'if' |
| Unir sentencias 'if' seleccionadas con || |
if (a) x(); if (b) x();
|
> |
if (a || b) x();
|
En sentencias 'if' seleccionadas |
| Unir sentencia 'if' en if-else-if |
if (a) x(); if (b) y();
|
> |
if (a) x(); else if (b) y();
|
En sentencias 'if' seleccionadas |
| Dividir sentencia if con expresión or |
if (a || b) x();
|
> |
if (a) x(); if (b) x();
|
En una expresión or en 'if' |
| Asignación if-else de expresión condicional |
if (a) x= 1; else x= 2;
|
> |
x= a ? 1 : 2;
|
En una sentencia 'if' |
| Devolución if-else de expresión condicional |
if (a) return 1;
|
> |
return a ? 1 : 2;
|
En una sentencia 'if' |
| Asignación condicional a If-else |
x= a ? 1 : 2;
|
> |
if (a) x= 1; else x= 2;
|
En una expresión condicional |
| Devolución de expresión condicional de If-else |
return
a ? 1 : 2;
|
> |
if (a) return 1; else return 2;
|
En una expresión condicional |
| Conmutar a If-else |
switch (kind) {
|
> |
if (kind == 1) {
|
En una sentencia switch |
| Añadir sentencias de casos faltantes en enumeraciones |
switch (e){
|
> |
switch (e){
|
En una sentencia switch |
| Intercambiar operandos |
a + b
|
> |
b + a
|
En una operación infix |
| Convertir temporalmente y asignar |
if (obj instanceof Vector) {
|
> |
if (obj instanceof Vector) {} |
En una expresión instanceof en una sentencia 'if' o 'while' |
| Utilizar bloques catch separados |
try {
|
> |
try {
|
En un bloque multi-catch (1.7 o superior) |
| Mover excepciones a bloques catch aparte |
try {
|
> |
try {
|
En las excepciones en una cláusula multi-catch (1.7 o superior) |
| Combinar bloques catch |
try {
|
> |
try {
|
En un bloque catch (1.7 o superior) |
| Añadir bloque finally |
try {
|
> |
try {
|
En una sentencia try/catch |
| Añadir bloque else |
if (a) b();
|
> |
if (a) b(); else { }
|
En una sentencia if |
| Sustituir sentencia por bloque |
if (a) b();
|
> |
if (a) { b(); }
|
En una sentencia if |
| Desenvolver bloques |
{ a() }
|
> |
a()
|
En bloques, sentencias if/while/for |
| Recoger serie |
"abcdefgh"
|
> |
"abc" + "de" + "fgh"
|
seleccionar una parte de un literal de tipo serie |
| Convertir concatenación de series en StringBuilder (J2SE 5.0) o StringBuffer |
"Hello " + name
|
> |
StringBuilder builder= new StringBuilder();
|
seleccionar un literal de serie |
| Convertir concatenación de serie en MessageFormat |
"Hello " + name
|
> |
MessageFormat.format("Hello {0}", name);
|
seleccionar un literal de serie |
| Dividir variable |
int i= 0;
|
> |
int i; i= 0;
|
En una variable con inicialización |
| Unir variable |
int i; i= 0;
|
> |
int i= 0
|
En una variable sin inicialización |
| Asignar a variable |
foo()
|
> |
X x= foo();
|
En una sentencia de expresión |
| Extraer en local |
foo(getColor());
|
> |
Color color= getColor();
|
En una expresión |
| Asignar parámetro a campo |
public A(int
color) {}
|
> |
Color fColor;
|
En un parámetro |
| Inicializador de matriz por creación de matriz |
int[] i= { 1, 2, 3 }
|
> |
int[] i= new int[] { 1, 2, 3 }
|
En un inicializador de matriz |
| Convertir a 'enhanced for loop' (J2SE 5.0) |
for (Iterator
i= c.iterator();i.hasNext();) {
|
> |
for (x : c) {
|
En un bucle for |
| Convertir en bucle 'for' indexado (J2SE 5.0) |
for (x : c) {
|
> |
for (int i = 0; i < c.size(); i++) {
|
En un bucle for mejorado |
| Convertir en bucle 'for' basado en iterador (J2SE 5.0) |
for (x : c) {
|
> |
for (Iterator
i= c.iterator();i.hasNext();) {
|
En un bucle for mejorado |
| Crear método en super clase |
|
|
|
En una declaración de método |
| Redenominar en archivo |
|
|
|
En identificadores |
| Redenominar en espacio de trabajo |
|
|
|
En identificadores |
| Extraer a variable local |
a= b*8;
|
> |
int x= b*8;
|
En expresiones |
| Extraer en constante |
a= 8;
|
> |
final static int CONST= 8;
|
En expresiones |
| Extraer método |
int x= p * 5;
|
> |
int x= getFoo(p);
|
En expresiones y sentencias |
| Incorporar variable local |
int a= 8, b= a;
|
> |
int b= 8;
|
En variables locales |
| Convertir variable local en campo |
void foo() { int a= 8; }
|
> |
int a= 8; void foo() {}
|
En variables locales |
| Convertir anónimo en clase anidada |
new Runnable() { };
|
> |
class RunnableImplementation implements Runnable { }
|
En clases anónimas |
| Sustituir por métodos de obtención y de establecimiento (Encapsular campo) |
p.x;
|
> |
p.getX();
|
En campos |
| Insertar argumentos de tipo inferido |
List<String> list = new ArrayList<>();
|
> |
List<String> list = new ArrayList<String>();
|
En expresiones de creación de instancias genéricas (1.7 o superior) |
Las asistencias rápidas siguientes están disponibles en el Editor de archivo de propiedades:
Editor Java
Arreglo rápido y Asistencia rápida