Eclipse HotKey：如何在选项卡之间切换？

按住CTRL并按F6直到找到所需的编辑器，然后松开。UI不如窗口选择漂亮，但功能相同。

• CTRL+E（用于编辑器列表）
• CTRL+F6（用于通过列表切换到下一个编辑器）
  您可以为“Next Editor”键分配另一个快捷方式。

是两个官方快捷方式，但它们都涉及显示列表。

CTRL+Page Up/CTRL+下一页可以在不显示列表的情况下循环编辑。

最后一组快捷方式的有趣之处在于：
它们没有在要定义的Eclipse Keys快捷方式中列出。
它们可以从多页编辑器继承，使它们成为OS特定快捷方式。

关于Mac OS（OSX）上的快捷方式，Matt Ball在2011年9月抱怨无法重新映射CTRL+Page Up/CTRL+下一页：

它让我发疯，无法像在OS X中几乎所有其他选项卡程序（-左和-对）中那样翻阅打开的选项卡。

2012年3月，亚瑟回复：

，我刚刚下载了最新版本的Eclipse（3.7+）。我已经能够在编辑器中将“上一个/下一个选项卡”绑定到（-左和-对），我很确定我以前做不到。
所以我猜他们听到你了。 它就像你期望的那样工作，标签从左到右，反之亦然，不是基于历史或类似的胡说八道。

Matt Ball确认：

哦，哇，选择“编辑Java来源”实际上奏效了！
现在，不幸的是，这意味着如果我导航到非Java文件（JSP、XML、JS等），我就是SOL。 解决这个问题的方法是为这一对“复制命令”，并选择我想要的所有“时间”.
到目前为止，它至少对Java和JSP文件工作得很好。 这是一个主要的PITA设置，但这只是一次性的事情。

他的导出的偏好可在此处获得给你试试。
导入后，您应该看到所有相关类型的文档：

CTRL+F6很好用。如果你想切换到下一个/上一个选项卡，你需要做CTRL+下一页/CTRL+Page Up。

一种方法是使用VI插件，然后执行： n（和： N）在文件之间传递。

我就是干这个的。

您可以使用ALT+左转到上一个选项卡，或者ALT+对转到前进。不过，这种方法使用的是类似历史记录的选项卡切换，因此它会转到您打开的上一个选项卡，如果您已经“返回”一次或多次，则会转发。我知道有点奇怪，但它有效。您始终可以通过单击每个选项卡一次来“重置”历史记录。

如果你想简单地在当前和以前的选项卡选择之间切换，使用CTRL+F6会来回切换。要导航到历史记录中更早的选项卡，你需要在编辑器窗口打开时使用UP/下键。这适用于Helios（Eclipse 3.6）；不确定这是否适用于旧版本的Eclipse。

如果您转到首选项（例如窗口→首选项）并查看常规→键

然后搜索“下一个选项卡”和“上一个选项卡”，您可以重新映射它们。

默认值是Ctrl+F6。您可以通过转到窗口首选项来更改它。我通常将其更改为Ctrl+Tab，我们在浏览器和其他东西中切换选项卡时使用的相同。

像操作系统中的Windows一样切换（转到上次有焦点的窗口）

Eclipse中的CTRL-F 6，就像Windows中的ALT-选项卡一样，会显示一个可用的选项卡/窗口列表（如果您按下CTRL/ALT键），并突出显示您放开此键时将跳转到的选项卡。您不必选择窗口。如果您想同时遍历多个选项卡，请按住CTRL按钮并点击选项卡按钮。这与Windows中的ALT-选项卡行为相同。

从这个意义上说，eclipse中的CTRL-SHIFT-F 6是ALT-SHIFT-选项卡模拟。就个人而言，我在Eclipse中将这些绑定更改为类似于Visual Studio。即CTRL-选项卡和CTRL-SHIFT-选项卡，我这样做：

窗口>首选项>常规>密钥

然后设置“下一个编辑器”=Ctrl+Tab和“上一个编辑器”=Ctrl+Shift+Tab。在设置新绑定之前不要忘记单击“取消绑定命令”。

像浏览器一样切换（转到当前选项卡右侧的选项卡）

这是CTRL-页面下拉向右转，CTRL-向上页面向左转。令人沮丧的是，当你到达选项卡列表的末尾（比如最右边的选项卡）然后再次尝试向右转时，Eclipse不会像大多数浏览器那样循环到第一个选项卡（最左边）。

已解决！！

将方案更改为Microsoft Visual Studio

窗口>首选项>常规>密钥

查找计划下拉列表

我的eclipse版本：

EclipseJava面向Web开发人员的EE IDE。

版本：Juno服务第1版 编译id：20120920-0800

由于某种原因，我的Eclipse设置已损坏，因此我不得不手动编辑文件/.plugins/org.eclipse.e4.workbench/workbench.xmi

我之前必须将Ctrl+Tab设置为类似浏览器的选项卡切换，甚至重置Eclipse首选项中的所有键绑定也不会摆脱快捷方式（它们也不会显示在任何地方）。我打开上面提到的文件并删除与无功能快捷方式相关的<tags>type:user</tags>标记的<bindings>元素。

• Right侧移：Ctrl+页面下拉
• Left侧移：CTRL+页面向上

额外

• 获取打开标签列表：Ctrl+F6

日食其他捷径

• 链接：http://www.shortcutworld.com/en/win/Eclipse.html
• PDF：http://eclipse-tools.sourceforge.net/Keyboard_shortcuts_%283.0%29.pdf

您可以在首选项->通用->键中设置热键（或者在首选项对话框顶部的过滤器字段中键入“键”）。

选择键部分后，找到下一个选项卡和上一个选项卡，并通过单击“绑定”字段，然后键入您的热键，为它们分配您自己的热键。

点击应用或确定以完成该过程。

没有人会阅读我的答案，但无论如何……如果你在Mac OS X上，你会喜欢Eclipse中用于历史导航的多点触控手势：http://sourceforge.net/apps/mediawiki/eclipsemultitch/

在Windows上，如果您有5键鼠标，您可以使用前进和后退来代替ALT+左和ALT+右。

3行AutoHotKey脚本（在Windows上，无论如何）：

#IfWinActive ahk_class SWT_Window0
^+Tab::^PgUp
^Tab::^PgDn

将其放入启动文件夹（另存为*. ahk，必须安装AutoHotKey），Eclipse选项卡现在将像Chrome或Firefox一样工作。

在SLES12机器上，默认情况下，您可以使用Ctrl+PageUp和Ctrl+分页下拉在选项卡之间导航。您可以随时通过浏览“常规”类别下的“键”部分从首选项窗口更改这些键。 上面的Victor和VonC很好地解释了这个过程。

我引用VonC的回复，添加一些东西。

• Ctrl+PgUp（PgDn）在当前堆栈中的选项卡之间切换（包括编辑器和视图）
• Ctrl+E使用过滤列表在当前堆栈中的选项卡之间切换
• Ctrl+F6在编辑器之间切换，无论哪个堆栈
• Ctrl+F7在视图之间切换，无论哪个堆栈

此外，还有错误206299开放请求使用Ctrl+Tab切换选项卡，而不是Ctrl+PgUp（PgDn）。

• 由于这会破坏可访问性，用户应该为此设置偏好。也许在Oomph安装期间，欢迎问卷中应该有一个问题。

如果不满意，您可以从窗口>首选项>常规>密钥为自己分配密钥绑定。

快捷键返回到上一个选项卡

Alt+左箭返回。

自定义键绑定序列示例： 点击+选项卡 在可视模块或编辑器之间切换前进方向使用Eclipse RCP。

第二次按点击+选项卡 打开 另一个编辑器并使用RCP Eclipse关闭以前的编辑器。

package rcp_demo.Toolbar;


import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.handlers.HandlerUtil;
import rcp_demo.Editor.EmployeeEditor;
import rcp_demo.Editor.EmployeeEditorInput;
import rcp_demo.Editor.ProductEditor;
import rcp_demo.Editor.ProductEditorInput;
import rcp_demo.Editor.UserEditor;
import rcp_demo.Editor.UserEditorInput;


public class Forward_Editor extends AbstractHandler{


static String Editor_name;  //  Active Editor name store in Temporary
static int cnt;             //  close editor count this variable
@Override
public Object execute(ExecutionEvent event) throws ExecutionException {


IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindow(event);
IWorkbenchPage page = window.getActivePage();


UserEditorInput std_input = new UserEditorInput();
EmployeeEditorInput emp_input=new EmployeeEditorInput();
ProductEditorInput product_input=new ProductEditorInput();


IEditorReference[] editors = page.getEditorReferences();


//Blank Editor Window to execute..
if(editors.length==0)
{
//First time close editor can open Student_Editor
if(cnt==1 && Editor_name.equals("Student_Editor"))
{
try {
page.openEditor(emp_input, EmployeeEditor.Id);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("EMP>>Len:: "+editors.length+"..EDi::"+Editor_name);
} catch (PartInitException e) {
e.printStackTrace();
}
}
//First time close editor can open Employee_Editor
else if(cnt==1 && Editor_name.equals("Employee_Editor"))
{
try {
page.openEditor(product_input,ProductEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("PRO>>Len:: "+editors.length+"..EDi::"+Editor_name);
} catch (PartInitException e) {e.printStackTrace();
}
}
//First time close editor can open Product_Editor
else if(cnt==1 && Editor_name.equals("Product_Editor"))
{
try {
page.openEditor(std_input, UserEditor.ID);
System.out.println("student Editor open");
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("Close::"+Editor_name);
} catch (PartInitException e) {
e.printStackTrace();
}
}
//First Time call // empty editors
else{
try {
page.openEditor(std_input, UserEditor.ID);
System.out.println("student Editor open");
Editor_name=page.getActiveEditor().getTitle();
} catch (PartInitException e) {
e.printStackTrace();
}
}
}//End if condition


//AvtiveEditor(Student_Editor) close to open Employee Editor
else if(page.getActiveEditor().getTitle().equals("Student_Editor"))
{
try {
//page.closeAllEditors(true);
page.closeEditor(page.getActiveEditor(), true);
page.openEditor(emp_input, EmployeeEditor.Id);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("EMP>>Len:: "+editors.length+"..EDi::"+Editor_name);
} catch (PartInitException e) {
e.printStackTrace();
}
}
//AvtiveEditor(Employee_Editor) close to open Product Editor
else if(page.getActiveEditor().getTitle().equals("Employee_Editor"))
{
try {
page.closeAllEditors(true);
page.openEditor(product_input,ProductEditor.ID);


cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("PRO>>Len:: "+editors.length+"..EDi::"+Editor_name);


} catch (PartInitException e) {
e.printStackTrace();
}
}
//AvtiveEditor(Product_Editor) close to open Student Editor
else if(page.getActiveEditor().getTitle().equals("Product_Editor"))
{
try {
page.closeAllEditors(true);
page.openEditor(std_input, UserEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("stud>>Len:: "+editors.length+"..EDi::"+Editor_name);
} catch (PartInitException e) {
e.printStackTrace();
}
}
//by default open Student Editor
else
{
try {
page.closeAllEditors(true);
page.openEditor(std_input, UserEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("stud_else>>Len:: "+editors.length+"..EDi::"+Editor_name);
} catch (PartInitException e) {
e.printStackTrace();
}
}
return null;
}
}


>Custom KeyBinding sequence example : <kbd> SHIFT + TAB </kbd> to switch between visilble Modules or Editors **Backword** direction using Eclipse RCP.




package rcp_demo.Toolbar;


import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.handlers.HandlerUtil;
import rcp_demo.Editor.EmployeeEditor;
import rcp_demo.Editor.EmployeeEditorInput;
import rcp_demo.Editor.ProductEditor;
import rcp_demo.Editor.ProductEditorInput;
import rcp_demo.Editor.UserEditor;
import rcp_demo.Editor.UserEditorInput;


public class Backword_Editor extends AbstractHandler{


static String Editor_name;   // Active Editor name store in Temporary
static int cnt;


@Override
public Object execute(ExecutionEvent event) throws ExecutionException {


IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindow(event);
IWorkbenchPage page = window.getActivePage();
//Three object create in EditorInput
UserEditorInput std_input = new UserEditorInput();
EmployeeEditorInput emp_input=new EmployeeEditorInput();
ProductEditorInput product_input=new ProductEditorInput();


IEditorReference[] editors = page.getEditorReferences();
System.out.println("Length : "+editors.length);


if(editors.length==0)
{
//First time close editor can open Student_Editor
if(cnt==1 && Editor_name.equals("Product_Editor"))
{
try {
page.openEditor(emp_input, EmployeeEditor.Id);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("EMP>>Len:: "+editors.length+"..EDi::"+Editor_name);
} catch (PartInitException e) {
e.printStackTrace();
}
}
//First time close editor can open Employee_Editor
else if(cnt==1 && Editor_name.equals("Employee_Editor"))
{
try {
page.openEditor(std_input, UserEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("Student>>Len:: "+editors.length+"..student::"+Editor_name);


} catch (PartInitException e) {
e.printStackTrace();
}
}
//First time close editor can open Product_Editor
else if(cnt==1 && Editor_name.equals("Student_Editor"))
{
try {
page.openEditor(product_input,ProductEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("PRO>>Len:: "+editors.length+"..EDi::"+Editor_name);


} catch (PartInitException e) {
e.printStackTrace();
}
}
//First Time or empty editors to check this condition
else{
try {
page.openEditor(product_input,ProductEditor.ID);
System.out.println("product Editor open");
} catch (PartInitException e) {
e.printStackTrace();
}
}
}
//AvtiveEditor(Product_Editor) close to open Employee Editor
else if(page.getActiveEditor().getTitle().equals("Product_Editor"))
{
System.out.println("Product:: "+page.getActiveEditor().getTitle());
try {
page.closeAllEditors(true);
page.openEditor(emp_input, EmployeeEditor.Id);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("Employee Editor open");
} catch (PartInitException e) {
e.printStackTrace();
}
}
//AvtiveEditor(Employee_Editor) close to open Student Editor
else if(page.getActiveEditor().getTitle().equals("Employee_Editor"))
{
System.out.println("Emp:: "+page.getActiveEditor().getTitle());
try {
page.closeAllEditors(true);
page.openEditor(std_input, UserEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("student Editor open");
} catch (PartInitException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//AvtiveEditor(Student_Editor) close to open Product Editor
else if(page.getActiveEditor().getTitle().equals("Student_Editor"))
{
System.out.println("Product:: "+page.getActiveEditor().getTitle());
try {
page.closeAllEditors(true);
page.openEditor(product_input,ProductEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("product Editor open");
} catch (PartInitException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//by default open Student Editor
else
{
try {
page.closeAllEditors(true);
page.openEditor(product_input,ProductEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("product Editor open");
} catch (PartInitException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return null;
}
}

自定义键绑定序列示例： SHIFT+选项卡 在可视模块或编辑器之间切换背景词方向使用Eclipse RCP。

package rcp_demo.Toolbar;


import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.handlers.HandlerUtil;
import rcp_demo.Editor.EmployeeEditor;
import rcp_demo.Editor.EmployeeEditorInput;
import rcp_demo.Editor.ProductEditor;
import rcp_demo.Editor.ProductEditorInput;
import rcp_demo.Editor.UserEditor;
import rcp_demo.Editor.UserEditorInput;


public class Backword_Editor extends AbstractHandler{


static String Editor_name;   // Active Editor name store in Temporary
static int cnt;


@Override
public Object execute(ExecutionEvent event) throws ExecutionException {


IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindow(event);
IWorkbenchPage page = window.getActivePage();
//Three object create in EditorInput
UserEditorInput std_input = new UserEditorInput();
EmployeeEditorInput emp_input=new EmployeeEditorInput();
ProductEditorInput product_input=new ProductEditorInput();


IEditorReference[] editors = page.getEditorReferences();
System.out.println("Length : "+editors.length);


if(editors.length==0)
{
//First time close editor can open Student_Editor
if(cnt==1 && Editor_name.equals("Product_Editor"))
{
try {
page.openEditor(emp_input, EmployeeEditor.Id);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("EMP>>Len:: "+editors.length+"..EDi::"+Editor_name);
} catch (PartInitException e) {
e.printStackTrace();
}
}
//First time close editor can open Employee_Editor
else if(cnt==1 && Editor_name.equals("Employee_Editor"))
{
try {
page.openEditor(std_input, UserEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("Student>>Len:: "+editors.length+"..student::"+Editor_name);


} catch (PartInitException e) {
e.printStackTrace();
}
}
//First time close editor can open Product_Editor
else if(cnt==1 && Editor_name.equals("Student_Editor"))
{
try {
page.openEditor(product_input,ProductEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("PRO>>Len:: "+editors.length+"..EDi::"+Editor_name);


} catch (PartInitException e) {
e.printStackTrace();
}
}
//First Time or empty editors to check this condition
else{
try {
page.openEditor(product_input,ProductEditor.ID);
System.out.println("product Editor open");
} catch (PartInitException e) {
e.printStackTrace();
}
}
}
//AvtiveEditor(Product_Editor) close to open Employee Editor
else if(page.getActiveEditor().getTitle().equals("Product_Editor"))
{
System.out.println("Product:: "+page.getActiveEditor().getTitle());
try {
page.closeAllEditors(true);
page.openEditor(emp_input, EmployeeEditor.Id);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("Employee Editor open");
} catch (PartInitException e) {
e.printStackTrace();
}
}
//AvtiveEditor(Employee_Editor) close to open Student Editor
else if(page.getActiveEditor().getTitle().equals("Employee_Editor"))
{
System.out.println("Emp:: "+page.getActiveEditor().getTitle());
try {
page.closeAllEditors(true);
page.openEditor(std_input, UserEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("student Editor open");
} catch (PartInitException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//AvtiveEditor(Student_Editor) close to open Product Editor
else if(page.getActiveEditor().getTitle().equals("Student_Editor"))
{
System.out.println("Product:: "+page.getActiveEditor().getTitle());
try {
page.closeAllEditors(true);
page.openEditor(product_input,ProductEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("product Editor open");
} catch (PartInitException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//by default open Student Editor
else
{
try {
page.closeAllEditors(true);
page.openEditor(product_input,ProductEditor.ID);
cnt=1;
Editor_name=page.getActiveEditor().getTitle();
System.out.println("product Editor open");
} catch (PartInitException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return null;
}
}

密钥序列

M1表示 CTRL

M2表示SHIFT

plugin.xml

<extension point="org.eclipse.ui.commands">
<command
defaultHandler="rcp_demo.Toolbar.Forward_Editor"
id="RCP_Demo.Toolbar.Forward_editor_open_cmd"
name="Forward_Editor">
</command>
<command
defaultHandler="rcp_demo.Toolbar.Backword_Editor"
id="RCP_Demo.Toolbar.backwards_editor_open_cmd"
name="Backword_Editor">
</command>
</extension>
<extension point="org.eclipse.ui.bindings">
<key
commandId="RCP_Demo.Toolbar.Forward_editor_open_cmd"
schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
sequence="M1+TAB">
</key>
<key
commandId="RCP_Demo.Toolbar.backwards_editor_open_cmd"
schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
sequence="M2+TAB">
</key>
</extension>

从右到左：ctrl+转变+9或ctrl+转变+Page Up或ctrl+Page Up

从左到右：ctrl+转变+3或ctrl+转变+下一页或ctrl+下一页

如何在Eclipse中打开的窗口之间切换

CTRL+F7在这里工作-Windows上的Eclipse Photon。

出于某种原因，仅仅添加一个新的绑定似乎不起作用（eclipse 2021-06）。

而是：

• 使用Copy Command克隆Next Tab和Previous Tab
• 将“何时”更改为In Windows
• 添加您的新绑定
• Apply and Close

@Gillfish在对另一个答案的评论中提到了这一点，但我认为最好明确地提出解决方案。

2022-03之前的Eclipse版本曾经有CTRL+Tab以LRU顺序在编辑器之间切换，与CTRL+E相同-我相信它是相同的功能。从2022版本开始，CTRL+Tab不再是这种情况，而是使用CTRL+Tab移动到不同的窗格（即从编辑器移动到底部窗格，或从底部窗格移动到侧栏之一）。

无论哪种情况，CTRL+Tab都没有在Windows->首选项->通用->密钥配置对话框中显示为已使用的绑定-它似乎是硬编码的。

这真的让我很恼火，因为我非常习惯使用CTRL+Tab在多选项卡应用程序中切换选项卡，无论如何，它比CTRL+E更容易快捷方式。

我的解决方案是进入按键配置对话框并将“快速切换编辑器”快捷方式从CTRL+E替换为CTRL+Tab。

“快速切换编辑器”基本上是我需要的-按一次并快速释放，然后你回到以前使用的编辑器；按一次并按住修饰符-你会得到一个菜单，你可以在其中导航到LRU顺序的不同编辑器。