Eclipse HotKey：如何在标签之间切换？-Java 学习之路

632

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

我试图为事件分配热键：

前进
前进历史
下一页

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

22 回答

855

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

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

回复于 2024-04-26T03:18:14+08:00
1

在操作系统中像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 我这样做：

窗口>首选项>常规>键

然后设置"Next Editor" = Ctrl+Tab 和"Previous Editor" = Ctrl+Shift+Tab . 在设置新绑定之前，请不要忘记单击"Unbind Command" .

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

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

回复于 2024-04-26T03:18:14+08:00
2
- Right 侧移： Ctrl + page Down
- Left 侧移： CTRL + page Up
Additional
- 获取打开的标签列表： Ctrl + F6
Eclipse others Short Cuts
- 链接：http://www.shortcutworld.com/en/win/Eclipse.html
- Pdf：http://eclipse-tools.sourceforge.net/Keyboard_shortcuts_%283.0%29.pdf
回复于 2024-04-26T03:18:14+08:00
8

解决了！！

将方案更改为Microsoft Visual Studio

窗口>首选项>常规>键

寻找Schemes下拉列表

我的日食版：

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

版本：Juno Service Release 1 Build id：20120920-0800

回复于 2024-04-26T03:18:14+08:00
0

用于返回上一个选项卡的快捷键

Alt LeftArrow返回 .

回复于 2024-04-26T03:18:14+08:00
0

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

回复于 2024-04-26T03:18:14+08:00
14

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

回复于 2024-04-26T03:18:14+08:00
3

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

回复于 2024-04-26T03:18:14+08:00
2

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

回复于 2024-04-26T03:18:14+08:00
92
- CTRL E（编辑器列表）
- CTRL F6（通过列表切换到下一个编辑器）
  您可以为'Next Editor'键指定另一个快捷方式 .
是两个官方快捷方式，但它们都涉及显示的列表 .

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

最后一组快捷方式的有趣之处在于：
they are not listed in the Eclipse Keys shortcuts to be defined.
它们可以从多页面编辑器继承，使它们成为 OS specific shortcut .

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

令我疯狂的是，我几乎无法在OS X中的所有其他选项卡式程序（⌘-Left和⌘-Right）中翻阅打开的标签 .

那么，在2012年3月，Arthur回复：

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

Matt Ball确认：

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

他的exported preferences are available here给你试试 .
导入后，您应该看到所有相关类型的文档：
回复于 2024-04-26T03:18:14+08:00
5

一种方法是使用VI Plugin，然后你只需要：n（和：N）介于文件之间 .

我就是做这个的 .

回复于 2024-04-26T03:18:14+08:00
1

您可以在“首选项” - >“常规” - >“键”中设置热键（或者只需在“首选项”对话框顶部的“过滤器”字段中键入“键” .

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

点击Apply或OK完成该过程 .

回复于 2024-04-26T03:18:14+08:00
184

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

回复于 2024-04-26T03:18:14+08:00
12

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

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

回复于 2024-04-26T03:18:14+08:00
6

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

回复于 2024-04-26T03:18:14+08:00
1
3行AutoHotKey脚本（在Windows上，无论如何）：
```
#IfWinActive ahk_class SWT_Window0
^+Tab::^PgUp
^Tab::^PgDn
```
把它放在你的启动文件夹中（保存为* .ahk，必须安装AutoHotKey），Eclipse标签现在可以像Chrome或Firefox一样工作 .
回复于 2024-04-26T03:18:14+08:00
0
我引用了VonC的回应，添加了一些内容 .
- Ctrl PgUp（PgDn）在当前堆栈中的选项卡之间切换（编辑器和视图）
- Ctrl E使用筛选列表在当前堆栈中的选项卡之间切换
- Ctrl F6可在编辑器之间切换，无论哪个堆栈
- Ctrl F7可在视图之间切换，无论哪个堆栈
另外，有Bug 206299打开请求使用Ctrl Tab切换选项卡而不是Ctrl PgUp（PgDn） .
- 由于这会破坏可访问性，因此用户应为此设置首选项 . 在Oomph安装期间，欢迎问卷中可能会有一个问题 .
如果不满意，可以从Window> Preferences> General> Keys为自己分配Key Binding .
回复于 2024-04-26T03:18:14+08:00
55

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

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

回复于 2024-04-26T03:18:14+08:00

自定义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在可视模块或编辑器后退方向之间切换 .

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>

回复于 2024-04-26T03:18:14+08:00

1

默认为Ctrl F6 . 您可以转到“窗口”首选项来更改它 . 我通常将其更改为Ctrl Tab，我们在浏览器和其他内容中切换选项卡时使用的相同 .

回复于 2024-04-26T03:18:14+08:00
1

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

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

回复于 2024-04-26T03:18:14+08:00
0

您可以使用ALT Left转到上一个选项卡，或ALT Right转到前转 . 但是，这种方法使用像历史记录一样的制表符切换，因此它将转到您打开的上一个标签页，如果您已经过了一次或多次，则转发 . 我知道，有点奇怪，但它确实有效 . 通过单击每个选项卡，您可以始终"reset"历史记录 .

回复于 2024-04-26T03:18:14+08:00

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

22 回答

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

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

相关问题