Les choses possibles dans IntelliJ qui ne sont pas possibles dans Eclipse?

Il N'y a qu'une seule raison pour laquelle j'utilise intellij et non eclipse: Usability

Indique s'il s'agit du débogage, du refactoring, de l'auto-complétion.. Intellij est beaucoup plus facile à utiliser avec des liaisons de clés cohérentes, des options disponibles où vous les Recherchez, etc. Côté fonctionnalité, il sera difficile pour intellij de rattraper Eclipse, car ce dernier a beaucoup plus de plugins disponibles qu'intellij, et est facilement extensible.

N'est Probablement pas une question de ce qui peut/ne peut pas être fait, mais comment.

Par exemple, les deux ont un éditeur entouré de panneaux dock pour project, classpath, output, structure etc. Mais dans L'idée quand je commence à taper tous ces effondrements automatiquement laissez-moi me concentrer sur le code lui-même; dans eclipse tous ces panneaux restent ouverts laissant ma zone d'éditeur très réduite, environ 1/5 de la surface totale visible. Je dois donc saisir la souris et cliquer pour minimiser dans ces panneaux. Faire cela toute la journée est une expérience très frustrante dans eclipse.

La chose exactement opposée se produit avec la fenêtre de sortie de la vue. Dans Idea, l'exécution d'un programme amène la fenêtre/le panneau de sortie à voir la sortie du programme même si elle a été minimisée. Dans eclipse, je dois à nouveau saisir ma souris et chercher l'onglet de sortie et cliquer dessus pour afficher la sortie de mon programme, car la fenêtre/Panneau de sortie est juste un autre, comme tout le reste des fenêtres, mais dans Idea il est traité dans un spécial façon: "si l'utilisateur veut exécuter son programme, est très probable qu'il veut voir la sortie de ce programme!"Cela semble si naturel quand je l'écris, mais eclipse échoue dans ce concept d'interface utilisateur de base.

Il y a probablement un raccourci pour cela dans eclipse (fenêtre de sortie autohide lors de l'édition et autoshow lors de l'exécution du programme ) , mais comme d'autres dizaines de fonctionnalités, le raccourci doit être chassé dans les forums, l'aide en ligne, etc. alors que dans Idea est un peu plus "naturel".

Cela peut être répété pour presque toutes les fonctionnalités à la fois ont, saisie semi-automatique, word wrap, vue de la documentation rapide, tout. Je pense que l'expérience utilisateur est beaucoup plus agréable dans L'idée que dans eclipse. Alors la devise se réalise "développer avec plaisir"

Eclipse gère des projets plus grands plus rapides (+300 pots et + 4000 classes) et je pense Qu'IntelliJ Idea 8 travaille sur ce sujet.

Tout cela est bien sûr subjectif. Comment peut-on mesurer l'expérience utilisateur?

Idée 8.0 a la belle ctrl+maj+espace x 2 qui ne la suite de la saisie semi-automatique:

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

Se résout à

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

À travers un nombre quelconque de niveaux de getters / setters.

N'oubliez pas "comparer avec le presse-papiers".

Quelque chose que j'utilise tout le temps dans IntelliJ et qui n'a pas d'équivalent dans Eclipse.

Mon raccourci préféré dans IntelliJ qui n'a pas d'équivalent dans Eclipse (que j'ai trouvé) s'appelle 'Go to symbol'. CTRL-ALT-SHIFT-n vous permet de commencer à taper et glob up classes, noms de méthodes, noms de variables, etc., à partir de l'ensemble du projet.

J'ai essayé de passer à IntelliJ à cause du nouveau Studio Android. Mais je suis très déçu aujourd'hui. J'utilise Eclipse avec le PluginCode Recommanders . Voici un exemple simple pourquoi Eclipse est si génial:

Je veux créer un nouveau SimpleTimeZone. SimpleTimeZone n'a pas de constructeur avec zéro argument.

Ctrl + Espace dans Eclipse

Ctrl + Espace dans l'Ide,

Dans IntelliJ Je ne reçois aucune information Quel genre de constructeurs SimpleTimeZone A.

Après entrez dans Eclipse

J'obtiens le constructeur précédemment sélectionné rempli de noms de variables prédéfinis. Et je peux voir le type de chaque argument. Avec le Code Recommanders Eclipse devine le bon constructeur par les types de variables précédemment définis dans la portée actuelle et remplit le constructeur avec ces variables.

Après entrez dans IntelliJ rien ne se passe. Je reçois un constructeur vide. Je dois appuyer sur Ctrl + P pour voir les arguments attendus.

Si vous avez le curseur sur une méthode, alors CTRL+SHIFT+I affichera l'implémentation de la méthode. Si la méthode est une méthode interface, vous pouvez utiliser les flèches haut et bas pour parcourir les implémentations:

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

Où / est (par exemple) où se trouve votre curseur.

IntelliJ a des inspections de code assez avancées (comparables mais différentes de FindBugs).

Bien que je manque sérieusement un plugin FindBugs lors de l'utilisation D'IntelliJ (L'intégration Eclipse/FindBugs est assez cool).

Voici une liste officielle de CodeInspections supportées par IntelliJ

EDIT: enfin, il y a un FindBugs-plugin pour IntelliJ. Il est encore un peu bêta, mais la combinaison des Inspections de Code et FindBugs est tout simplement génial!

Loin, loin, beaucoup plus de refactorings.

Une chose que j'utilise régulièrement est de définir un point d'arrêt, mais de contrôler ce qu'il fait. (À mon dernier travail, la plupart des autres ont utilisé Eclipse... Je me souviens avoir été surpris que personne ne puisse trouver comment faire cela dans Eclipse.)

Par exemple, le point d'arrêt peut ne pas s'arrêter réellement, mais simplement enregistrer un message sur la console. Ce qui signifie, Je n'ai pas à jeter mon code avec " système.hors.println(...)" et puis recompiler.

Il y a beaucoup de choses que l'idée résout d'une manière beaucoup plus simple, ou il n'y a pas d'équivalent:

• Actions de saisie semi-automatique: faire ctrl+Maj+a Vous pouvez appeler n'importe quelle action idea à partir du clavier sans se souvenir de sa combinaison de touches... Pensez à gnome-do ou launchy dans windows, et vous avez l'idée! En outre, cette fonctionnalité prend en charge les abréviations CamelCasing ;)

• Étagère: vous permet de garder facilement quelques morceaux de code à part, puis de les examiner à travers le diff spectateur.

• Histoire locale: c'est beaucoup mieux géré, et plus simple.

• Annotations SVN et historique: plus simple à inspecter, et vous pouvez facilement voir l'historique uniquement pour une telle partie d'un fichier source entier.

• Saisie semi-automatique partout, comme les fenêtres évaluer l'expression et la condition du point d'arrêt.

• Intégration Maven... beaucoup, beaucoup plus simple, et bien intégré.

• Refactors beaucoup plus près de la main, tels que des boucles insertion, encapsulation/casting, renommage et ajout de variables.

• Trouver beaucoup puissant et bien organisé. Même dans les grands projets

• Beaucoup stable pour travailler avec plusieurs branches d'un grand projet en même temps (comme un ancien bugfixer de 1,5 Go par des sources de branche, et la nécessité de travailler en eux simultanément, idea a montré ses capacités solides comme le roc)

• Interface plus propre et plus simple...

• Et, plus simples à utiliser uniquement avec le clavier, laissant en dehors de la nécessité d'utiliser la souris pour beaucoup de taks simples, vous faire gagner du temps et vous donner plus d'attention sur le code... là où c'est important!

Et maintenant, étant opensource... la base D'utilisateurs Idea va croître de façon exponentielle.

Recherche structurelle et remplacer.

Par exemple, recherchez quelque chose comme:

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

Où $string$ est un littéral, et $expr$ est une expression de type ma.paquet.et.Classe, puis remplacer par:

  $expr$.inspect($string$);

Mon timing peut être un peu décalé en termes de ce fil, mais je devais juste répondre.

Je suis un énorme fan d'eclipse - je l'utilise depuis sa première apparition. Un ami m'a alors dit (il y a plus de 10 ans) que ce serait un joueur. Il a droit.

Cependant! Je viens de commencer à utiliser IntelliJ et si vous n'avez pas vu ou utilisé changelists - vous manquez de programmer heaven.

La possibilité de suivre mes fichiers modifiés (sur ma branche de développement ala clearcase) était quelque chose que je cherchais dans un plugin pour eclipse. Intellij suit toutes vos modifications pour un seul commit, extrêmement facile. Vous pouvez isoler les fichiers modifiés avec des listes personnalisées. Je l'utilise pour les fichiers de configuration qui doivent être uniques localement, mais qui sont constamment marqués lorsque je synchronise ou compare avec le référentiel - en les listant sous une liste de modifications,je peux les surveiller, mais les ranger soigneusement afin que je puisse me concentrer sur les ajouts réels que je fais.

En outre, il y a un plugin de journal de validation qui affiche un texte de toutes les modifications pour les SCCS qui ne sont pas intégrés à votre logiciel de suivi des bogues. Le collage du journal dans l'historique de travail d'un ticket capture les fichiers, leur version, la date / heure et la branche/les balises. C'est cool comme l'enfer.

Tout cela pourrait être pris en charge via des plugins (ou des améliorations futures) dans eclipse, je parie; pourtant, Intellij en fait un jeu d'enfant.

Enfin, je suis vraiment excité par l'amour grand public pour ce produit-les frappes, donc c'est douloureux, mais amusement.

Le débogueur IntelliJ a une fonctionnalité très pratique appelée "Evaluate Expression", qui est de loin meilleure que eclipses pendentif. Il a une complétion de code complète et je pense qu'il est généralement "plus utile".

Eh bien, pour moi, c'est mille petites choses. Certaines des macros, la disposition de L'interface graphique en général dans Eclipse je trouve horrible. Je ne peux pas ouvrir plusieurs projets dans différentes fenêtres dans Eclipse. Je peux ouvrir plusieurs projets, mais alors son système basé sur la vue échange un tas de choses sur moi quand je change de fichiers. Les inspections de code d'IntelliJ semblent meilleures. Ses aides popup pour résoudre les problèmes communs est agréable. Beaucoup de choses simples d'utilisation comme la barre latérale où je peux survoler un point chaud et ça me le dira chaque sous-classe implémentant une méthode ou la méthode que j'implémente et d'où.

Chaque fois que j'ai dû utiliser, ou regarder quelqu'un utiliser, Eclipse il semble qu'ils peuvent faire la plupart des choses que je peux faire dans IntelliJ, mais cela leur prend plus de temps et c'est plus clunkier.

Introduire la variable. ( Ctrl + Alt + V sous Windows, Cmd + Alt + V sous OSX)

Disons que vous appelez une méthode, service.listAllPersons() Appuyez sur Ctrl + Alt + V et Entrez , et la variable pour la valeur de retour de l'appel de méthode est insérée:

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

Vous permet d'économiser en tapant, et vous n'avez pas à vérifier le type de retour de la méthode que vous appelez. Particulièrement utile lors de l'utilisation de génériques, par exemple

new ArrayList<String>()

[introduire la variable]

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

(bien sûr, vous pouvez facilement changer le nom de la variable avant de frapper Entrez )

IntelliJ a intellisense et le support de refactoring du code dans les documents jspx.

Pour moi, C'est le support Maven D'IDEA, en particulier dans la version 9 est incomparable. La synchronisation à la volée du projet avec le modèle maven est tout simplement fantastique et rend le développement agréable.

Intellij a un plug-in SVN bien supérieur à Subversive ou Subclipse et cela fonctionne! La quantité de temps que nous avons gaspillé à fusionner des fichiers source en utilisant Eclipse ne supporte pas de penser. Ce n'est pas un problème avec IntelliJ parce que le plugin vous aide beaucoup plus.

En outre, le plugin Subclipse n'est pas fiable - nous avons régulièrement des cas où le plugin ne pense pas qu'il y ait eu de code vérifié dans SVN par D'autres développeurs, mais il y a - le serveur CI les a traités!

Émulateur VIM . Ce plugin fournit une émulation vi/vim/gvim presque complète lors de l'édition de fichiers dans IDEA. Les fonctionnalités suivantes sont prises en charge:

• Touches de mouvement
• Suppression / Modification
• Insérer des commandes de mode
• Marque
• registres
• vim annuler / rétablir
• commandes en mode visuel
• quelques commandes Ex
• Certains :définir les options
• expressions régulières Vim complètes pour la recherche et la recherche/remplacement
• Macros
• Diagraphes
• historique de la ligne de commande
• historique de Recherche
• Jumplists
• AIDE VIM

Quelques commentaires sur ce plugin de http://plugins.jetbrains.net/plugin/?id=164

Je ne peux pas voir jamais revenir à un autre ide à cause de ce plugin.. Le meilleur des deux mondes... Fantastique!. c'est ce qui me manquait dans toutes les IDE.

L'un des bons points à mon avis est la matrice de structure de dépendance : http://www.jetbrains.com/idea/features/dependency_analysis.html#link0

Il y a une bonne introduction à L'utilisation et aux avantages de DSM dans le site Web de Lattix (un produit autonome): http://www.lattix.com/files/dl/slides/s.php?directory=4tour

Quelques autres choses:

• propage les paramètres / exceptions lorsque modification de la signature de la méthode, très pratique pour la mise à jour des méthodes profondes à l'intérieur de la pile d'appels
• validation du code SQL dans les chaînes passées comme arguments aux appels jdbc (et l'ensemble nouvellement empaqueté langue d'injection de trucs)
• implémenté dans / écrasé dans les icônes pour les interfaces et les classes (et leurs méthodes) et la navigation de mise en œuvre intelligente (Ctrl + Alt + clic ou Ctrl + Alt + B)
• lien entre L'EJB 2.1 interfaces et classes de bean (y compris le support de refactoring); Vieux un, mais toujours immensément précieux lorsque vous travaillez sur des projets plus anciens

Deux choses Qu'IntelliJ fait que Eclipse ne fait pas sont très précieuses pour moi:

Séparateurs de méthode: ces faibles lignes grises entre les méthodes rendent le code Beaucoup plus lisible

Anti-aliasing de texte: rend le code si agréable dans L'IDE

Une caractéristique très utile est la possibilité de construire partiellement un projet de réacteur Maven afin que seules les pièces dont vous avez besoin soient incluses.

Pour rendre cela un peu plus clair, considérons le cas d'une collection de fichiers WAR avec beaucoup de ressources communes (par exemple JavaScript, fichiers de configuration Spring, etc.) partagés entre eux en utilisant la technique de superposition . Si vous travaillez sur une page web (en cours d'exécution dans Jetty) et que vous voulez changer une partie du code de superposition qui se trouve dans un module séparé ensuite, vous vous attendez normalement à devoir arrêter la jetée, exécuter la construction Maven, recommencer la jetée et continuer. C'est le cas avec Eclipse et à peu près tous les autres IDE avec lesquels j'ai travaillé. Ce n'est pas IntelliJ. À l'aide des paramètres du projet, vous pouvez définir la facette du module que vous souhaitez inclure dans une version d'arrière-plan. Par conséquent, vous vous retrouvez avec un processus qui semble transparente. Vous apportez une modification à peu près n'importe quel code dans le projet et instantanément il est disponible après avoir actualisé le navigateur.

Très soigné et très rapide.

Je ne pouvais pas imaginer coder un front end dans quelque chose comme YUI sauvegarde sur DWR/SpringMVC sans elle.

Préambule de ma réponse: mon utilisation D'Eclipse est limitée. Nous avions besoin D'un IDE Java pour fonctionner à la fois sur Windows et Mac et le port Mac a ralenti jour après jour. C'était il y a des années et je suis sûr que ça va maintenant. Mais c'est ce qui nous a permis de passer à IntelliJ et nous en avons été heureux.

Maintenant, pour ma réponse: une grande différence que je n'ai pas encore vue est que le support technique est meilleur avec IntelliJ/Jet Brains. Nous envoyons un e-mail à JetBrains et obtenons une réponse définitive en moins d'une heure. La recherche de réponses aux problèmes D'éclipse entraîne les réponses habituelles, "vous idiot stupide" (généralement un petit nombre de réponses) avec le plus grand nombre de réponses utiles et utiles. Mais il faut un peu de tri pour obtenir la vraie réponse.

Quelque chose que j'utilise dans IntelliJ tout le temps est refactoring comme je tape. J'ai réécrit des classes à partir d'une impression (écrite à l'origine dans eclipse) en utilisant les deux IDE et j'ai utilisé environ 40% moins de touches/clics de souris pour écrire les mêmes classes dans IntelliJ qu'eclipse.

Je ne voudrais pas utiliser Eclipse tant qu'ils ne supportent pas autant de refactoring avec des morceaux de code incomplets.

Voici une liste plus longue des fonctionnalités D'IntelliJ 8.0 / 8.1 [http://www.jetbrains.com/idea/features/index.html]

Il y a une chose Qu'IntelliJ fait beaucoup mieux Qu'Eclipse et qui est de vider vos poches!

Je préfère cependant l'utiliser et un gros avantage qu'il a sur Eclipce est la façon dont il se synchronise avec le système de fichiers, pour les grands projets et les ordinateurs lents (oui dans les environnements de travail, les PC sont beaucoup plus lents que les nôtres à la maison) Eclipse semble lutter là où IntelliJ semble être plus rapide

IntelliJ Community edition évidemment rend l'utilisation gratuite, mais vous voulez bientôt ces refactoring supplémentaires et de jolis petits goodies non inclus dans L'édition CC.

À mon avis, c'est généralement une meilleure expérience utilisateur, mais si cela vaut le coût est une question à laquelle chaque développeur doit répondre.

Mais soyons reconnaissants, nous avons jusqu'à trois grands IDE pour Java en ce moment avec NetBeans de mieux en mieux tout le temps.

Analyse de flux de données : Analyse de flux ascendant inter-procédural et analyse de flux ascendant, comme décrit ici. Mes expériences sont basées sur Community Edition, qui effectue assez bien l'analyse des flux de données. Il a échoué (refusé de faire quoi que ce soit) dans quelques cas où le code est très complexe.

Tout d'Abord j'aime intellij. Il y a au moins une centaine de fonctionnalités qu'il a ce manque d'éclipse. Je parle de magnitudes mieux dans la fiabilité et l'intelligence qu'aucune hyperbole ne peut décrire quand il s'agit de refactoring, de renommage, de déplacement et d'autres qui ont déjà été mentionnés.

Mais, il y a une chose qu'intellij ne permet pas à eclipse. Il ne permet pas d'exécuter plusieurs projets à la fois sous la même machine virtuelle.

Lorsque vous avez des projets distincts pour avant, milieu, noyau, agents..etc, où ils ont tous d'interagir les uns avec les autres, vous ne pouvez pas modifier rapidement et déboguer en même temps, afaik. La seule façon de faire face à cela est d'utiliser des scripts ant pour déployer et mettre à jour des fichiers JAR dans des projets dépendants, ou utiliser maven.

Eclipse permet de déboguer plusieurs projets sous une instance de machine virtuelle ide.