快速辅助

快速辅助执行本地代码变换。它们是针对 Java 编辑器中的所选内容或单个光标调用的,并且与快速修正使用相同的快捷键(Ctrl+1)。但是,当周围有错误时,快速辅助通常是隐藏的。要显示快速辅助,即使同一行中存在错误亦如此,请再次按 Ctrl+1。

可以对直接快捷键指定一组快速辅助。缺省情况下,这些快捷键是:

在 打开键首选项 常规 > 键首选项页上指定更多快捷键或更改缺省快捷键(在“源”类别中)。

可以在 打开“Java 编辑器”首选项页 Java > 编辑器首选项页上打开快速辅助灯泡。

名称 代码示例 调用位置
反转 if 语句 if (x) a(); else b(); > if (!x) b(); else a(); 带有“else”块的“if”语句
反转布尔表达式 a && !b > !a || b 布尔表达式
反转局部变量 boolean a = false;
if (a) {}
> boolean notA = true;
if (!notA) {}
布尔变量
反转等号 a.equals(b) > b.equals(a) 对于“equals”的调用
反转条件表达式 x ? b : c > !x ? c : b 条件表达式
上拉求反操作 b && c > !(!b || !c) 布尔表达式
下推求反操作 !(b && c) > !b || !c 求反的布尔表达式
除去多余的圆括号 if ((a == b) && (c != d)  {} > if (a == b && c != d)  {} 所选择的表达式
将表达式用圆括号括起来 return a > 10 ? 1 : 2; > return (a > 10) ? 1 : 2; 所选择的表达式
将表达式用圆括号括起来 if (a == b && c != d)  {} > if ((a == b) && (c != d))  {} 所选择的表达式
连接嵌套的 if 语句 if (a) { if (b) {} } > if (a && b) {} 嵌套的 if 语句
交换嵌套的 if 语句 if (a) { if (b) {} } > if (b) { if (a) {} } 嵌套的 if 语句
分割带有“与”表达式的 if 语句 if (a && b) {} > if (a) { if (b) {} } “if”语句中的“与”表达式
将所选“if”语句与 || 连接起来 if (a) x();  if (b) x(); > if (a || b) x(); 所选择的“if”语句
在 if-else-if 中连接“if”序列 if (a) x();  if (b) y(); > if (a) x();  else if (b) y(); 所选择的“if”语句
分割带有“或”表达式的 if 语句 if (a || b) x(); > if (a) x();  if (b) x(); “if”语句中的“或”表达式
If-else 赋值转化为条件表达式 if (a) x= 1; else x= 2; > x= a ? 1 : 2; “if”语句
If-else 返回转化为条件表达式 if (a) return 1;
else return 2;
> return a ? 1 : 2; “if”语句
条件表达式赋值转化为 If-else x= a ? 1 : 2; > if (a) x= 1; else x= 2; 条件表达式
条件表达式返回转化为 If-else return  a ? 1 : 2; > if (a) return 1; else return 2; 条件表达式
switch 到 If-else switch (kind) {
case 1: return -1;
case 2: return -2;
}
> if (kind == 1) {
  return -1;
} else if (kind == 2) {
  return -2;
}
switch 语句
根据枚举添加缺少的 case 语句 switch (e){
}
> switch (e){
case E1: break;
case E2: break;
}
switch 语句
交换操作数 a + b > b + a 中缀操作
强制类型转换和赋值 if (obj instanceof Vector) {
}
> if (obj instanceof Vector) {
 Vector vec= (Vector)obj;

}
“if”或“while”语句中的 instanceof 表达式
使用单独的 catch 块 try {
} catch (FileNotFoundException | InterruptedIOException e) {
}
> try {
} catch (FileNotFoundException e) {
} catch (InterruptedIOException e) {
}
在 multi-catch 块上(1.7 或更高版本)
将异常移动到单独的 catch 块 try {
} catch (FileNotFoundException | InterruptedIOException | IllegalArgumentException e) {
}
> try {
} catch (FileNotFoundException e) {
} catch (InterruptedIOException | IllegalArgumentException e) {
}
在 multi-catch 子句中的异常上(1.7 或更高版本)
组合 catch 块 try {
} catch (FileNotFoundException e) {
} catch (InterruptedIOException e) {
}
> try {
} catch (FileNotFoundException | InterruptedIOException e) {
}
在 catch 块上(1.7 或更高版本)
添加 finally 块 try {
} catch (Exception e) {
}
> try {
} catch (Exception e) {
} finally {}
try/catch 语句
添加 else 块 if (a) b(); > if (a) b(); else { } if 语句
使用块替换语句 if (a) b(); > if (a) { b(); } if 语句
打开块 { a() } > a() if/while/for 语句的块
挑选字符串 "abcdefgh" > "abc" + "de" + "fgh" 选择字符串文字的一部分
将字符串并置转换为 StringBuilder (J2SE 5.0) 或 StringBuffer "Hello " + name > StringBuilder builder= new StringBuilder();
builder.append("Hello ");
builder.append(name);
选择字符串文字
将字符串并置转换为 MessageFormat "Hello " + name > MessageFormat.format("Hello {0}", name); 选择字符串文字
分割变量 int i= 0; > int i; i= 0; 进行了初始化的变量
连接变量 int i; i= 0; > int i= 0 未进行初始化的变量
对变量赋值 foo() > X x= foo(); 表达式语句
抽取到局部变量 foo(getColor()); > Color color= getColor();
foo(color);
表达式
对字段指定参数 public A(int color) {} > Color fColor;
public A(int color) {
    fColor= color;
}
参数
用于创建数组的数组初始化方法 int[] i=  { 1, 2, 3 } > int[] i= new int[] { 1, 2, 3 } 数组初始化方法
转换为“增强型 for 循环”(J2SE 5.0) for (Iterator i= c.iterator();i.hasNext();) {
}
> for (x : c) {
}
for 循环
转换为已建立索引的“for”循环 (J2SE 5.0) for (x : c) {
}
> for (int i = 0; i < c.size(); i++) {
    x = c[i];
}
在增强型 for 循环上
转换为基于迭代器的“for”循环 (J2SE 5.0) for (x : c) {
}
> for (Iterator i= c.iterator();i.hasNext();) {
}
在增强型 for 循环上
在超类中创建方法


方法声明
文件中的重命名


标识
工作空间中的重命名


标识
抽取到局部变量 a= b*8; > int x= b*8;
a= x;
表达式
抽取到常量 a= 8; > final static int CONST= 8;
a= CONST;
表达式
抽取方法 int x= p * 5; > int x= getFoo(p); 表达式和语句
直接插入局部变量 int a= 8, b= a; > int b= 8; 局部变量
将局部变量转换为字段 void foo() { int a= 8; } > int a= 8; void foo() {} 局部变量
将匿名类转换为嵌套类 new Runnable() { }; > class RunnableImplementation implements Runnable { } 匿名类
替换为 getter 和 setter 方法(封装字段) p.x; > p.getX(); 字段
插入推断的类型参数 List<String> list = new ArrayList<>(); > List<String> list = new ArrayList<String>(); 在一般实例创建表达式上(1.7 或更高版本)

属性文件编辑器中提供以下快速辅助:

相关概念

Java 编辑器
快速修正和快速辅助

相关参考

快速修正
JDT 操作