Eclipse HotKey：如何在标签之间切换？

Question

如何在Eclipse中打开的窗口之间切换？有 Ctrl + F6 ，但它问我想要哪一个，但是我希望在操作系统中将它切换为浏览器或窗口中的标签（ Cmd / Win + Tab ）没有从列表中选择文件。如何在Eclipse中轻松完成这项工作？

我尝试为事件分配热键：

• 向前
• 前进历史
• 下一页

但它不能按我想要的方式工作。

Answer 1

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

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

CTRL + Page Up / CTRL + Page Down 可以循环浏览编辑器而不显示列表。

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

---

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

  

它让我疯狂，因为我无法在OS X中的所有其他选项卡式程序中翻阅打开的选项卡（⌘ - Left 和⌘ - 右）。

嗯，2012年3月，Arthur回复：

  

，我刚刚下载了最新版本的Eclipse（3.7+）。我已经能够将“上一个/下一个选项卡”绑定到（⌘ - 左和⌘ - 右在编辑时，我很确定我以前做不到。
  所以我猜他们听到了你的声音   它的工作方式与您预期的一样，制表符从左到右，反之亦然，不是基于历史记录，也不是像这样的废话。

Matt Ball确认：

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

他的exported preferences are available here让你试试。
导入后，您应该看到所有相关类型的文档：

Answer 2

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

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

Answer 3

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

Eclipse中的

CTRL - F6 ，例如 ALT - TAB （在Windows上），显示可用的标签/窗口列表（如果保持 CTRL / ALT 键按下）并突出显示当您松开此键时您将跳转到的那个。您不必选择窗口。如果您想要一次遍历多个标签，请按住 CTRL 按钮，然后点按 TAB 按钮。这与Windows上的 ALT - TAB 完全相同。

从这个意义上说，eclipse中的 CTRL - SHIFT - F6 是 ALT - SHIFT - TAB 模拟。就个人而言，我在Eclipse中更改这些绑定就像Visual Studio一样。即 CTRL - TAB 和 CTRL - SHIFT - TAB ，我这样做：

窗口＆gt;首选项＆gt;常规＆gt;键

然后设置“Next Editor”= Ctrl + Tab 和“Previous Editor”= Ctrl + 移 + 标签 即可。在设置新绑定之前，请不要忘记单击“取消绑定命令”。

像浏览器一样切换（转到当前标签右侧的标签）

这是 CTRL - PageDown 向右走， CTRL - PageUp < / kbd> 向左走。令人沮丧的是，当你到达选项卡列表的末尾（比如右边的选项卡），然后再次尝试再向右移动Eclipse不会像大多数浏览器那样循环到第一个选项卡（最左边）。

Answer 4

您可以使用 ALT + 左转到上一个标签页，或 ALT + 右去转发。这种方法使用像历史一样的制表符切换，因此它将转到您打开的上一个选项卡，如果您已经“退回”一次或多次，则转发。我知道，有点奇怪，但它确实有效。您可以通过点击每个标签一次“重置”历史记录。

Answer 5

• Right侧移： Ctrl + page Down
• Left侧移： CTRL + page Up

附加

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

Eclipse其他人剪短

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

Answer 6

CTRL + F6 很好用。如果要切换到下一个/上一个选项卡，则需要执行 CTRL + Page Down / CTRL + Page Up

Answer 7

默认为 Ctrl + F6 。您可以转到窗口首选项进行更改。我通常将其更改为 Ctrl + Tab ，我们在浏览器和其他内容中切换标签时使用的相同。

Answer 8

  

自定义KeyBinding序列示例： CTRL + TAB 使用Eclipse RCP在可视模块或编辑器前进方向之间切换。

按第二次 CTRL + TAB 打开 另一位编辑并使用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;
    }
}

  

自定义KeyBinding序列示例： SHIFT + TAB 使用Eclipse RCP在可见模块或编辑器 Backword 方向之间切换。

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>

Answer 9

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

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

将它放在你的启动文件夹中（保存为* .ahk，必须安装AutoHotKey），Eclipse标签现在可以像Chrome或Firefox一样工作。

Answer 10

解决!!

将方案更改为Microsoft Visual Studio

窗口＆GT;设定＆gt;常规＆GT;键

寻找方案下拉列表

我的日食版：

面向Web开发人员的Eclipse Java EE IDE。

版本：Juno Service Release 1 构建ID：20120920-0800

Answer 11

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

Answer 12

返回上一个标签的快捷键

返回

Alt + LeftArrow 。

Answer 13

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

Answer 14

一种方法是使用VI Plugin，然后你只需要：n（和：N）来处理文件。

这就是我的工作。

Answer 15

从右到左： ctrl + shift + 9 或 ctrl + shift + Page Up 或 ctrl + Page Up

从左到右： ctrl + shift + 3 或 ctrl + shift + Page Down 或 ctrl + Page Down

Answer 16

我引用了VonC的回应，添加了一些内容。

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

另外，有Bug 206299可以使用 Ctrl + Tab 来切换标签，而不是 Ctrl + PgUp键（ PgDn键）。

• 由于这会破坏可访问性，因此用户应为此设置首选项。在Oomph安装期间，欢迎问卷中可能会有一个问题。

如果不满意，您可以从 Window＆gt;中为自己指定密钥绑定。偏好＆gt;一般＆gt;键。

Answer 17

您可以在首选项中设置热键 - ＆gt;一般 - ＆gt;键（或者只需在“首选项”对话框顶部的过滤器字段中键入“键”。

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

点击Apply或OK完成该过程。

Answer 18

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

我必须先将 Ctrl + Tab 设置为类似于浏览器的标签切换，甚至重置Eclipse首选项中的所有键绑定也不会消除快捷方式（它们也没有显示在任何地方）。我打开了上述文件并删除了标有<bindings>的{​​{1}}元素，这些元素与无效的快捷方式相关。

Answer 19

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

Answer 20

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

Answer 21

如果您只想在当前和之前的标签选项之间切换，使用 CTRL + F6 将来回切换。要导航到历史记录中后面的选项卡，您需要在编辑器窗口打开时使用 UP / DOWN 键。这适用于Helios（Eclipse 3.6）;不确定这是否适用于旧版本的Eclipse。

Answer 22

  

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

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