O que é possível no IntelliJ que não é possível no Eclipse?

Ouvi falar de pessoas que mudaram de um lado para outro e juram por um ou pelo outro.

Sendo um grande fã do Eclipse, mas sem ter tido tempo de experimentar o IntelliJ, estou interessado em ouvir dos usuários do IntelliJ que são "ex-Eclipsianos" algumas coisas específicas que você pode fazer com o IntelliJ e que não pode fazer com o Eclipse.

Nota : Esta não é uma questão subjetiva, nem pretende se transformar em uma guerra santa do IDE. Voto negativo todas as respostas flamebait .

CTRL-click funciona em qualquer lugar

CTRL-click que leva você aonde o objeto clicado é definido funciona em todos os lugares - não apenas nas classes e variáveis ​​Java no código Java, mas na configuração Spring (você pode clicar no nome da classe, propriedade ou nome do bean), no Hibernate (você pode clicar no nome ou na classe da propriedade ou no recurso incluído), você pode navegar com um clique da classe Java para onde é usado como bean Spring ou Hibernate; clicar na tag JSP ou JSTL incluída também funciona; clicar com a tecla Ctrl pressionada na variável ou função JavaScript leva ao local definido ou exibe um menu se houver mais de um local, incluindo outros arquivos .js e código JS em HTML ou JSP arquivos.

Preenchimento automático para muitos idiomas

Hibernate

Preenchimento automático em expressões HSQL, na configuração do Hibernate (incluindo classe, propriedade e nomes de colunas do banco de dados), na configuração do Spring

<property name="propName" ref="<hit CTRL-SPACE>"

e mostrará uma lista daqueles beans que você pode injetar nessa propriedade.

Java

Preenchimento automático muito inteligente no código Java:

interface Person {
    String getName();
    String getAddress();
    int getAge();
}
//---
Person p;
String name = p.<CTRL-SHIFT-SPACE>

e mostra SOMENTE getName () , getAddress () e toString () (apenas eles são compatíveis por tipo) e getName () é o primeiro da lista porque possui um nome mais relevante. A versão mais recente 8, que ainda está no EAP, tem preenchimento automático ainda mais inteligente.

interface Country{
}
interface Address {
    String getStreetAddress();
    String getZipCode();
    Country getCountry();
}
interface Person {
    String getName();
    Address getAddress();
    int getAge();
}
//--- 
Person p;
Country c = p.<CTRL-SHIFT-SPACE>

e silenciosamente o completará automaticamente para

Country c = p.getAddress().getCountry();

Javascript

Preenchimento automático inteligente em JavaScript.

function Person(name,address) {
    this.getName = function() { return name };
    this.getAddress = function() { return address };
}

Person.prototype.hello = function() {
    return "I'm " + this.getName() + " from " + this.get<CTRL-SPACE>;
}

e mostra ONLY getName () e getAddress () , não importa como você pode obter os métodos * que você possui em outros objetos JS em seu projeto e clique com a tecla Ctrl pressionada em this.getName () leva você a onde este está definido, mesmo se existem outras funções getName () no seu projeto.

HTML

Eu mencionei o preenchimento automático e a tecla Ctrl pressionada nos caminhos dos arquivos, como <script src = "", <img src = "", etc?

Preenchimento automático nos atributos da tag HTML. Preenchimento automático no atributo de estilo de tags HTML, nomes e valores de atributos. Preenchimento automático nos atributos de classe também.
Digite <div class = "<CTRL-SPACE> e ele mostrará uma lista das classes CSS definidas em seu projeto. Escolha uma, clique com a tecla Ctrl pressionada e você será redirecionado para onde está definido.

Destacamento fácil de linguagem própria

A versão mais recente possui injeção de idioma, para que você possa declarar que a tag JSTL customizada geralmente contém JavaScript e destacará o JavaScript dentro dela.

<ui:obfuscateJavaScript>function something(){...}</ui:obfuscateJavaScript>

Pesquisa indexada em todo o projeto.

Você pode usar Localizar usos de qualquer classe ou método Java e encontrará onde é usado, incluindo não apenas as classes Java, mas também o Hibernate, Spring, JSP e outros locais. A renomeação do método Renomear renomeia o método não apenas nas classes Java, mas em qualquer lugar incluindo comentários (não é possível ter certeza se a sequência nos comentários é realmente o nome do método, portanto, será solicitado). E ele encontrará apenas seu método, mesmo se houver métodos de outra classe com o mesmo nome. Boa integração de controle de fonte (o SVN suporta listas de alterações? A IDEA as suporta para todos os controles de origem), capacidade de criar um patch com suas alterações para que você possa enviar suas alterações para outro membro da equipe sem enviá-las.

Depurador aprimorado

Quando olho para o HashMap na janela de inspeção do depurador, vejo a visão lógica - chaves e valores, da última vez que o fiz no Eclipse, mostrava entradas com hash e campos seguintes - não estou realmente depurando o HashMap , só quero ver conteúdo.

Validação de configuração do Spring & Hibernate

Ele valida a configuração do Spring e do Hibernate quando você a edita, portanto, não preciso reiniciar o servidor para saber que escrevi incorretamente o nome da classe ou adicionei parâmetro construtor para que meu cfg do Spring seja inválido.

Na última vez que tentei, não consegui executar o Eclipse no Windows XP x64.

e sugerirá você person.name ou person.address . Pressione Ctrl e clique em person.name para navegar pelo método getName () da classe Person .

Digite Pattern.compile("");put \\ there, pressione CTRL-SPACE e veja dicas úteis sobre o que você pode colocar em sua expressão regular. Você também pode usar a injeção de linguagem aqui - defina seu próprio método que usa o parâmetro string, declare na caixa de diálogo de opções do IntelliLang que seu parâmetro é expressão regular - e também lhe será preenchido automaticamente. Escusado será dizer que destaca expressões regulares incorretas.

Outras características

Existem alguns recursos que não tenho certeza de que estão presentes no Eclipse ou não. Porém, pelo menos cada membro de nossa equipe que usa o Eclipse também usa alguma ferramenta de mesclagem para mesclar alterações locais com alterações do controle de origem, geralmente o WinMerge. Eu nunca preciso disso - incorporar o IDEA é suficiente para mim. Por 3 cliques, posso ver a lista de versões de arquivos no controle de origem; por mais 3 cliques, posso comparar versões anteriores ou anteriores e atuais e, possivelmente, mesclar.

Ele permite especificar que eu preciso de todos os .jars dentro da WEB-INF\libpasta, sem selecionar cada arquivo separadamente; portanto, quando alguém envia um novo .jar para essa pasta, ele é automaticamente capturado .

Mencionado acima é provavelmente 10% do que faz. Eu não uso Maven, Flex, Swing, EJB e muitas outras coisas, por isso não sei dizer como isso os ajuda. Mas sim.

Há apenas um motivo pelo qual eu uso o intellij e não o eclipse: Usabilidade

Seja depuração, refatoração, preenchimento automático. O Intellij é muito mais fácil de usar com ligações de teclas consistentes, opções disponíveis onde você as procura, etc. Em termos de recursos, será difícil para o intellij alcançar o Eclipse, como o O último possui muito mais plugins disponíveis que o intellij e é facilmente extensível.

Provavelmente não se trata do que pode / não pode ser feito, mas como .

Por exemplo, ambos têm um editor cercado de painéis de encaixe para projeto, caminho de classe, saída, estrutura etc. No eclipse, todos esses painéis ficam abertos, deixando minha área de editor muito reduzida, cerca de 1/5 da área total visível. Então eu tenho que pegar o mouse e clicar para minimizar nesses painéis. Fazer isso o dia todo é uma experiência muito frustrante no eclipse.

O exato oposto acontece com a janela de saída da visualização. No Idea, a execução de um programa traz a janela / painel de saída para ver a saída do programa, mesmo que isso tenha sido minimizado. No eclipse, tenho que pegar meu mouse novamente e procurar a guia de saída e clicar nele para visualizar a saída do meu programa, porque a janela / painel de saída é apenas mais uma, como todas as demais janelas, mas no Idea é tratada em uma maneira especial: "Se o usuário deseja executar seu programa, é muito provável que ele queira ver a saída desse programa!" Parece tão natural quando eu o escrevo, mas o eclipse falha neste conceito básico de interface do usuário.

Provavelmente, existe um atalho para isso no eclipse (ocultar automaticamente a janela de saída durante a edição e exibi-la automaticamente durante a execução do programa), mas como outras dezenas de recursos, o atalho deve ser procurado em fóruns, ajuda on-line etc., enquanto o Idea for um pouco mais " natural".

Isso pode ser repetido para quase todos os recursos que ambos têm, preenchimento automático, quebra de linha, visualização rápida da documentação, tudo. Acho que a experiência do usuário é muito mais agradável no Idea do que no eclipse. Então, o lema se torna realidade "Desenvolva com prazer"

O Eclipse lida com projetos maiores e mais rápidos (+300 jars e +4000 classes) e acho que o IntelliJ Idea 8 está trabalhando nisso.

Tudo isso, é claro, é subjetivo. Como podemos medir a experiência do usuário?

A Idea 8.0 possui o adorável ctrl+shift+spacex 2 que executa o seguinte preenchimento automático:

 City city = customer.<ctrl-shift-space twice>

resolve

 City city = customer.getAddress().getCity();

através de qualquer número de níveis de getters / setters.

Não se esqueça de "comparar com a área de transferência".

Algo que eu uso o tempo todo no IntelliJ e que não tem equivalente no Eclipse.

Meu atalho favorito no IntelliJ que não tem equivalente no Eclipse (que eu encontrei) é chamado 'Ir para o símbolo'. CTRL-ALT-SHIFT-Npermite que você comece a digitar e adicionar classes, nomes de métodos, nomes de variáveis ​​etc. a partir de todo o projeto.

Tentei mudar para o IntelliJ por causa do novo Android Studio. Mas estou muito decepcionado agora. Estou usando o Eclipse com o plug-in Code Recommanders . Aqui está um exemplo simples de por que o Eclipse é tão incrível:

Eu quero criar um novo SimpleTimeZone.SimpleTimeZonenão tem Construtor com zero argumentos.

Ctrl + Space no Eclipse

Ctrl + Space no IntelliJ

No IntelliJ, não recebo informações sobre o tipo de construtor SimpleTimeZone.

Depois Enterno Eclipse

Eu recebo o construtor selecionado anteriormente preenchido com nomes de variáveis ​​predefinidos. E eu posso ver o tipo de cada argumento. Com os Recomendadores de código, o Eclipse adivinha o construtor certo pelos tipos de variáveis ​​definidos anteriormente no escopo atual e preenche o construtor com esses vars.

Depois Enterno IntelliJ nada acontece. Eu recebo um construtor vazio. Eu tenho que pressionar Ctrl + Ppara ver os argumentos esperados.

Se você tiver o cursor em um método, CTRL+SHIFT+Iserá exibida a implementação do método. Se o método for um interfacemétodo, você poderá usar as setas para cima e para baixo para percorrer as implementações:

Map<String, Integer> m = ...
m.contains|Key("Wibble");

Onde | é (por exemplo) onde está o cursor.

O IntelliJ possui algumas inspeções de código bastante avançadas (comparáveis ​​mas diferentes do FindBugs).

Embora eu sinta muita falta de um plug-in FindBugs ao usar o IntelliJ (a integração Eclipse / FindBugs é bem legal).

Aqui está uma lista oficial de CodeInspections suportados pelo IntelliJ

EDIT: Finalmente, existe um plugin findbugs para o IntelliJ. Ainda é um pouco beta, mas a combinação de Code Inspections e FindBugs é simplesmente incrível!

Muito, muito, muito mais refatorações.

Uma coisa que uso regularmente é definir um ponto de interrupção, mas depois controlar o que ele faz. (No meu último trabalho, quase todo mundo usava o Eclipse ... Lembro-me de me surpreender que ninguém conseguisse descobrir como fazer isso no Eclipse.)

Por exemplo, o ponto de interrupção não pode realmente parar, mas apenas registrar uma mensagem no console. O que significa que não tenho que desarrumar meu código com "System.out.println (...)" e recompilar.

Há muitas coisas que a idéia resolve de uma maneira muito mais simples, ou não há equivalente:

• Ações de preenchimento automático: ctrl+shift+avocê pode chamar qualquer ação da ideia a partir do teclado sem lembrar a combinação de teclas ... Pense em gnome-do ou launchy no Windows, e você conseguiu a idéia! Além disso, esse recurso suporta abreviações do CamelCasing;)

• Prateleira: permite que você mantenha facilmente alguns trechos de código separados e depois revise-os através do visualizador de diferenças.

• Histórico local: é muito melhor gerenciado e mais simples.

• Anotações e histórico do SVN: mais simples de inspecionar, e também é possível ver facilmente o histórico apenas para uma parte do arquivo de origem inteiro.

• Preenchimento automático em qualquer lugar, como as janelas de expressão de avaliação e condição de ponto de interrupção.

• Integração com o Maven ... muito, muito mais simples e bem integrada.

• Refatores muito mais próximos da mão, como inserção de loops, quebra / moldagem, renomeação e adição de variáveis.

• Encontre muito poderoso e bem organizado. Mesmo em grandes projetos

• Muito estável para trabalhar com várias ramificações de um grande projeto ao mesmo tempo (como um ex-consertador de erros de 1,5 Gb por fontes de ramificação e a necessidade de trabalhar nelas simultaneamente, a idéia mostrou seus recursos sólidos)

• Interface mais limpa e simples ...

• E, mais simples de usar apenas com o teclado, deixando de lado a necessidade de usar o mouse para muitas tarefas simples, economizando tempo e dando mais foco ao código ... onde é importante!

E agora, sendo de código aberto ... a base de usuários do Idea aumentará exponencialmente.

Pesquisa estrutural e substituição.

Por exemplo, procure algo como:

  System.out.println($string$ + $expr$);

Onde $ string $ é um literal e $ expr $ é uma expressão do tipo my.package.and.Class e substitua por:

  $expr$.inspect($string$);

Meu tempo pode estar um pouco desligado em termos desse segmento, mas eu apenas tive que responder.

Eu sou um grande fã de eclipses - usá-lo desde a sua primeira aparição. Um amigo me disse então (há mais de 10 anos) que seria um jogador. Ele estava certo.

Contudo! Acabei de começar a usar o IntelliJ e, se você não viu ou usou listas de alterações, está perdendo a programação.

A capacidade de rastrear meus arquivos alterados (no meu ramo de desenvolvimento, ala clearcase) era algo que eu procurava em um plugin para eclipse. O Intellij rastreia todas as suas alterações para uma única confirmação, extremamente fácil. Você pode isolar arquivos alterados com listas personalizadas. Eu uso isso para arquivos de configuração que devem ser exclusivos localmente, mas são constantemente sinalizados quando sincronizo ou comparo com o repositório - listando-os em uma lista de alterações, eu posso monitorá-los, mas cuidadosamente colocá-los para que eu possa me concentrar nas adições reais Eu estou fazendo.

Além disso, há um plug-in Commit Log que gera um texto de todas as alterações para os SCCS que não estão integrados ao seu software de rastreamento de erros. Colar o log no histórico de trabalho de um ticket captura os arquivos, sua versão, data / hora e a ramificação / tags. É legal como o inferno.

Tudo isso poderia ser suportado por plugins (ou melhorias futuras) no eclipse, aposto; No entanto, Intellij torna isso uma brisa.

Por fim, estou realmente empolgado com o amor predominante por esse produto - as teclas digitadas, por isso é doloroso, mas divertido.

O depurador IntelliJ possui um recurso muito útil chamado "Avaliar Expressão", que é de longe melhor do que o eclipse pendente. Possui completo preenchimento de código e considero que geralmente é "mais útil".

Bem, para mim são mil pequenas coisas. Algumas das macros, o layout da GUI em geral no Eclipse, são terríveis. Não consigo abrir vários projetos em janelas diferentes no Eclipse. Posso abrir vários projetos, mas o sistema com base em visualização troca várias coisas ao meu redor quando troco de arquivo. As inspeções de código do IntelliJ parecem melhores. Seus auxiliares pop-up para corrigir problemas comuns são bons. Muitas coisas simples de usabilidade, como a barra lateral onde posso passar o mouse sobre um ponto de acesso, e isso me diz todas as subclasses de implementação de um método ou o método que estou implementando e de onde.

Sempre que eu tive que usar ou assistir alguém usar, o Eclipse parece que eles podem fazer a maioria das coisas que eu posso fazer no IntelliJ, mas isso leva mais tempo e é mais desajeitado.

Introduzir variável. ( Ctrl+Alt+Vno Windows, Cmd+Alt+Vno OSX)

Digamos que você chame um método, service.listAllPersons() Hit Ctrl+Alt+Ve Enter, e a variável para o valor de retorno da chamada de método seja inserida:

List<Person> list = service.listAllPersons();

Economiza a digitação e você não precisa verificar o tipo de retorno do método que está chamando. Especialmente útil ao usar genéricos, por exemplo

new ArrayList<String>()

[introduzir variável]

ArrayList<String> stringArrayList = new ArrayList<String>();

(é claro que você pode alterar facilmente o nome da variável antes de pressionar Enter)

O IntelliJ tem suporte a intellisense e refatoração de código em documentos jspx.

Para mim, o suporte inteligente da IDEA, especialmente na versão 9, é inigualável. A sincronização on-the-fly do projeto para o modelo maven é simplesmente fantástica e torna o desenvolvimento agradável.

O Intellij possui um plug-in SVN muito superior ao Subversive ou Subclipse e funciona! A quantidade de tempo que perdemos ao mesclar arquivos de origem usando o Eclipse não suporta pensar. Este não é um problema no IntelliJ, porque o plug-in ajuda muito mais.

Além disso, o plug-in Subclipse não é confiável - regularmente temos instâncias em que o plug-in não acha que houve código verificado no SVN por outros desenvolvedores, mas houve - o servidor de CI os processou!

Emulador VIM . Esse plug-in fornece emulação vi / vim / gvim quase completa ao editar arquivos no IDEA. A seguinte funcionalidade é suportada:

• Teclas de movimento
• Exclusão / Alteração
• Comandos do modo Inserir
• Marcas
• Registros
• Desfazer / refazer VIM
• Comandos do modo visual
• Alguns comandos Ex
• Alguns: definir opções
• Expressões regulares completas do VIM para pesquisa e pesquisa / substituição
• Macros
• Diagramas
• Histórico da linha de comando
• Histórico de busca
• Jumplists
• Ajuda do VIM

alguns comentários sobre este plugin de http://plugins.jetbrains.net/plugin/?id=164

Um dos pontos positivos na minha opinião é a Matriz da Estrutura de Dependência : http://www.jetbrains.com/idea/features/dependency_analysis.html#link0

Há uma boa introdução ao uso e benefícios do DSM no site da Lattix (um produto independente): http://www.lattix.com/files/dl/slides/s.php?directory=4tour

Algumas outras coisas:

• propagar parâmetros / exceções ao alterar a assinatura do método, muito útil para atualizar métodos dentro da pilha de chamadas
• Validação de código SQL nas strings passadas como argumentos para chamadas jdbc (e todo o material de injeção de linguagem recém-incluído)
• implementado / substituído em ícones para interfaces e classes (e seus métodos) e a navegação inteligente de implementação (Ctrl + Alt + Click ou Ctrl + Alt + B)
• vinculação entre as interfaces EJB 2.1 e classes de bean (incluindo suporte à refatoração); antigo, mas ainda imensamente valioso ao trabalhar em projetos mais antigos

Duas coisas que o IntelliJ faz que o Eclipse não faz e que são muito valiosas para mim:

Separadores de métodos: essas linhas cinzas entre os métodos tornam o código muito mais legível

Anti-aliasing de texto: torna o código tão bonito no IDE

Um recurso muito útil é a capacidade de construir parcialmente um projeto de reator Maven, para que apenas as peças necessárias sejam incluídas.

Para deixar isso um pouco mais claro, considere o caso de uma coleção de arquivos WAR com muitos recursos comuns (por exemplo, JavaScript, arquivos de configuração do Spring etc.) compartilhados entre eles usando o técnica de sobreposição. Se você estiver trabalhando em alguma página da Web (executando no Jetty) e quiser alterar parte do código de sobreposição mantido em um módulo separado, normalmente esperaria interromper o Jetty, execute a compilação do Maven, inicie o Jetty novamente e continuar. Este é o caso do Eclipse e de quase todos os outros IDE com os quais trabalhei. Não é assim no IntelliJ. Usando as configurações do projeto, você pode definir qual faceta de qual módulo você gostaria de incluir em uma construção em segundo plano. Conseqüentemente, você acaba com um processo que parece transparente. Você faz uma alteração em praticamente qualquer código do projeto e fica instantaneamente disponível após a atualização do navegador.

Muito arrumado e muito rápido.

Eu não podia imaginar codificar um front end em algo como o YUI fazendo backup no DWR / SpringMVC sem ele.

Preâmbulo da minha resposta: Meu uso do Eclipse é limitado. Precisávamos de um Java IDE para trabalhar no Windows e no Mac, e a porta do Mac diminuía dia após dia. Isso foi há anos e tenho certeza que está tudo bem agora. Mas foi isso que nos levou a mudar para o IntelliJ e ficamos felizes com isso.

Agora, minha resposta: uma grande diferença que ainda não vi mencionada é que o suporte técnico é melhor com o IntelliJ / Jet Brains. Enviamos um e-mail para o JetBrains e recebemos uma resposta definitiva em menos de uma hora. Procurar respostas para os problemas do Eclipse resulta nas respostas usuais: "Seu idiota estúpido" (geralmente um pequeno número de respostas) junto com um número muito maior de respostas úteis e perspicazes. Mas é preciso uma triagem para obter a resposta real.

Algo que uso no IntelliJ o tempo todo é refatorado enquanto digito. Reescrevi as aulas de uma impressão (originalmente escrita em eclipse) usando os IDEs e usei cerca de 40% menos pressionamentos de tecla / cliques do mouse para escrever as mesmas classes no IntelliJ do que no eclipse.

Eu não gostaria de usar o Eclipse até que eles suportem tanta refatoração com partes incompletas de código.

Aqui está uma lista mais longa de recursos no IntelliJ 8.0 / 8.1 [ http://www.jetbrains.com/idea/features/index.html]

Há uma coisa que o IntelliJ faz muito melhor que o Eclipse e que está vazio nos bolsos!

No entanto, prefiro usá-lo e uma grande vantagem que tem sobre o Eclipce é a maneira como ele se sincroniza com o sistema de arquivos, para grandes projetos e computadores lentos (sim, em ambientes de trabalho, os PCs são muito mais lentos que os nossos em casa). luta em que o IntelliJ parece ser mais rápido, embora com um tempo de indexação inicial mais lento.

A edição da comunidade IntelliJ obviamente torna o uso gratuito, mas em breve você deseja refatoração extra e pequenos itens legais não incluídos na edição CC.

Na minha opinião, geralmente é uma experiência melhor para o usuário, mas se vale a pena o custo é uma pergunta para cada desenvolvedor responder a si mesmo.

Mas vamos agradecer por termos até três excelentes IDEs para Java no momento, com o NetBeans melhorando o tempo todo.

Análise de fluxo de dados : análise de fluxo reverso entre procedimentos e análise de fluxo direto, conforme descrito aqui . Minhas experiências são baseadas no Community Edition, que faz uma análise do fluxo de dados razoavelmente bem. Ele falhou (recusou-se a fazer qualquer coisa) em alguns casos quando o código é muito complexo.

Primeiro de tudo, eu amo intellij. Existem pelo menos uma centena de recursos que faltam no eclipse. Estou falando melhor de magnitudes em confiabilidade e inteligência que nenhum hipérbole pode descrever quando se trata de refatorar, renomear, mover e outros que já foram mencionados.

MAS, há uma coisa que intellij não permite que eclipse permita. Não permite a execução de vários projetos ao mesmo tempo na mesma vm.

Quando você tem projetos separados para a frente, o meio, o núcleo, os agentes ... etc, onde todos precisam interagir entre si, não é possível modificar e depurar rapidamente ao mesmo tempo. Atualmente, a única maneira de lidar com isso é usar scripts ant para implantar e atualizar jars em projetos dependentes ou usar o maven.

O Eclipse permite que vários projetos sejam depurados em uma instância de ide vm.