Tutoriel sur les nouveautés d'IntelliJ IDEA 12.1, premières impressions

C'est la version communautaire d'IntelliJ. Elle est gratuite et le code source est disponible sous GitHub. Cette version contient toutes les fonctionnalités nécessaires pour créer un projet simple.

Avec cette version, vous allez pouvoir :

• créer un projet standard (Java, Scala, Groovy, Clojure)
• utiliser les outils de versionning : Git, Svn, Mercurial et Gradle
• utiliser des outils de build : Maven, Ant, Gradle et Gant
• faire des applications pour Android

C'est la version que nous avons testé dans cet article. Elle est disponible en version 30 jours d'évaluation.

Le prix d ' une licence personnelle est de 179 € HT et de 89 € pour une licence académique.
Pour plus d'informations, vous pouvez consulter ce lien :
www.jetbrains.com/idea/buy/index.jsp

En plus des fonctionnalités offertes par la version communautaire, elle offre :

• le support de frameworks tels que Spring, JEE, Play ;
• le support de serveurs d'applications tels que JBoss, Tomcat, Weblogic… ;
• le support de HTML, CSS, JavaScript ;
• …

Vous pouvez comparer les fonctionnalités offertes par la version communautaire et la version Ultimate à l'adresse suivante :

http://www.jetbrains.com/idea/features/editions_comparison_matrix.html

Lors de l'installation de la version Ultimate, IntelliJ nous propose une liste de plugins possibles par défaut. On peut soit tous les sélectionner soit retiré ceux dont on sait que l'on n'utilisera pas. Voici une liste des plugins disponibles au démarrage dans la version Ultimate :

Outils de build et gestionnaire de version : Ant support, ClearCase Integration, CVS Integration, Git, Github, hg4idea, Maven Integration, Maven Integration Extension, Perforce Integration, Gradle, Subversion Integration, Visual SourceSafe Integration, TFS Integration, Tapestry support ;

JEE : CDI support, Bean Validation Support, Java EE Integration, Java Server Pages Integration, JSF Support, JSR45 Integration ;

Jboss : Drools Support, JBoss Integration, JBoss jBPM, Seam Pageflow Support, Seam Support

Spring : Spring Batch, Spring Data, Spring Integration Patterns, Spring OSGi, Spring Roo Console, Spring Security, Spring Support, Spring Web Flow, Spring Web Services, Spring-AOP, DmServer support ;

Android : Android designer, Android support ;

Langage : AspectJ support, Base Cucumber, CoffeeScript, CSS Support, Cucumber pour Groovy, Cucumber pour Java, Groovy, JavaFX, JavaScript Debugger, JavaScript Intention Power Pack, JavaScript Support, CFML support, Flash/Flex Support ;

Cloud : Cloud Foundry Integration, CloudBees Integration, Google App Engine Integration, FreeMarker, HAML, HTML Tools, I18n for Java, Inspection-JS, J2ME, LESS support, QuirksMode, @AspectJ support, SQL support, W3C Validators true, YAML ;

Web Framework : GWT Support, Grails, Hibernate, Playframework Support, Persistence Frameworks Support, Struts 1.x, Struts 2 ;

Code source : Coverage, Emma, Junit, TestNG, UML Support ;

EDI : Application Server view, Commander, Copyright, Byte Code viewer, Eclipse Integration, GenerateToString, Structural Search, ASP, IDEtalk, Inspection Gadgets, IntelliLang, Intention Power Pack, JarFinder, Plugin DevKit, Properties Support, Remote Hosts Access, Refactor-X, SSH Remote Run, UI Designer, UI Designer (Core), Task Management, Vaadin Support, Type Migration ;

Database : Database support, DSM Analysis ;

Serveur d'application : Geronimo, GuiceyIDEA, Jetty Integration, Glassfish Integration, Resin Integration, Tomcat and TomEE Integration, WebSphere Integration, WebLogic Integration ;

Autre: REST Client true SASS support, Osmorc, Velocity support, WebServicesPlugin, XpathView, XSLT Support, XSLT-Debugger, ZKM-Unscramble

IntelliJ fournit un repository centralisé qui contient la liste de tous les plugins pour IntelliJ en version Ultimate et Community (http://plugins.jetbrains.com/). L'avantage, c'est qu'il est unique donc si on cherche un plugin, c'est ici qu'il faut chercher !

Si vous souhaitez avoir une liste de plugins indispensables pour Eclipse et IntelliJ, vous pouvez voir la présentation faite par Romain Maton sur « 24 plugins chrono » où il liste des plugins très intéressants pour Eclipse et IntelliJ :

• A Devoxx : http://www.devoxx.com/display/FR13/24+Plugins+Chrono . Cette présentation sera bientôt disponible sur Parleys.com) ;
• Au Poitou Charente JUG : www.parleys.com/play/5148922b0364bc17fc56ca47.

Cette barre située sur la droite affiche des couleurs en rapport avec votre code. Elle permet d'identifier rapidement les lignes qui contiennent des warnings, des erreurs, des TODO…

C'est la boîte à outils qui va contenir l'arborescence du projet. Cette boîte à outils est très similaire à la vue projet d'éclipse. Dans cette boîte à outils, on peut par exemple utiliser des filtres pour afficher seulement les répertoires de tests. Pour cela, il suffit de cliquer dans la zone Projet et de choisir le scope Test.

De nombreuses options sont disponibles. Pour plus de détails, consultez http://www.jetbrains.com/idea/webhelp/project-tool-window.html

Cette boîte à outils va afficher la liste des méthodes et attributs de la classe en cours d'édition.

Il est possible de paramétrer l'affichage dans cette vue à l'aide de filtre en cliquant sur l'icône de paramétrage. On peut par exemple choisir d'afficher ou non les membres private.

De plus afin d'identifier si plus facilement les différents éléments, IntelliJ utilise des symboles.

Voici quelques exemples :

	Classe
	Classe abstraite
	Interface
	Attribut
	Enum
	Méthode

Certaines icônes viennent compléter les icônes principales.

	Private
	Static
	Protected

Pour la liste complète des symboles, vous pouvez consulter le lien suivant : http://www.jetbrains.com/resharper/webhelp/Reference__Symbol_Icons.html.

Pour plus d'informations, veuillez consulter le document d'IntelliJ sur la vue structure  : http://www.jetbrains.com/idea/webhelp/structure-tool-window-file-structure-popup.html.

Cette fonctionnalité vous permet de mettre en favoris une ligne de code et ainsi de pouvoir retourner dessus très rapidement.

Le raccourci F11 vous permet d'ajouter un bookmark et le raccourci SHIFT-F11 vous permet d'accéder à la liste des bookmarks.

En plus des fonctions standards de recherche, IntelliJ fournit le moyen d'effectuer des recherches à l'aide d'expressions rationnelles et d'effectuer les remplacements correspondants.

Exemple :

Cette fonctionnalité est accessible seulement en version Ultimate.

En plus des recherches standards et de la recherche par expressions rationnelles, vous avez la possibilité d'effectuer des recherches « structurelles ». Cette fonctionnalité complète les deux autres. Elle permet d'effectuer les recherches à l'aide de templates prédéfinis ou vos propres templates.

Exemple :

Vous pouvez accéder à cette fonctionnalité dans Edit | Find | Search Structurally, ou Edit | Find | Replace Structurally.
Vous pouvez aussi utiliser le raccourci :  Ctrl+Shift+S  ou  Ctrl+Shift+M  .

Vous pouvez aussi effectuer un « remplacement structurel ».

Dans l'exemple ci-dessus, nous avons utilisé des templates de variables. Elles se définissent de la manière suivante :

$MaReference$

Ce template de variables doit être entre « $ ».  « MaReference » est un nom de variable que vous définissez. Il doit respecter les règles de nommage standards Java.

Pour plus d'informations, vous pouvez consulter le lien suivant : http://www.jetbrains.com/idea/documentation/ssr.html.

Le refactoring sous IntelliJ ne se limite pas seulement au langage Java. Le refactoring peut se faire dans plein de langages et de frameworks et aussi en fonction du contexte.

Prenons un exemple.

Vous souhaitez renommer une classe dans une requête JPA. IntelliJ va automatiquement reconnaître JPA et vous proposer de renommer la classe correspondante :

Cette fonctionnalité va vous permettre de changer le type d'un champ et IntelliJ va effectuer le refactoring adéquat :

Avec IntelliJ, vous pouvez changer le nom d'un booléen et sa valeur.

Par exemple, si vous définissez :

                boolean available = true;
                String name = customer.getName();
                String result = "";
                if (name == null) {
                    result = "FAILED";
                    available = false;
                }
                if (available && name.startsWith("idea")) {
                    result = "OK";    
                } else if (!available && (name.startsWith("br")) ) {
                    result = "KO";
                } else {
                    if ((available == false) && (result.equals("FAILED"))) {
                        result = "TEST";    
                    }
                    available = false;
                }

Le refactoring d'inversion de booléen aura le résultat suivant :

                boolean available = false;
                String name = customer.getName();
                String result = "";
                if (name == null) {
                    result = "FAILED";
                    available = true;
                }
                if (!available && name.startsWith("idea")) {
                    result = "OK";
                } else if (available && (name.startsWith("br")) ) {
                    result = "KO";
                } else {
                    if ((!available == false) && (result.equals("FAILED"))) {
                        result = "TEST";
                    }
                    available = true;
                }

IntelliJ offre la possibilité de détecter les doublons dans le code et d'effectuer le refactoring nécessaire.

Exemple

Dans le code suivant, on constate l'utilisation de la valeur zéro au lieu de la variable ZERO :

public class Test {

    public static final int ZERO = 0;

    Test(int val) {
        changeStatus(0, 0, 0);
    }

    public void changeStatus(int a,int b, int c) {
        // some code
    }
}

IntelliJ va vous permettre de chercher et remplacer toutes les valeurs à 0 par la variable ZERO.

Pour cela, il faut faire clic droit puis refactor et choisir « Find and replace code duplicate ».

IntelliJ offre la possibilité d'effectuer des vérifications lors de la suppression (variable, méthode, classe…). Il suffit de sélectionner l'élément en question et de faire un clic droit puis refactor puis « safe delete ». Si l'élément est utilisé, IntelliJ vous avertira.

• Première remarque : il n'y a rien à télécharger, rien à installer et pas de configuration à faire.
• Que l'on utilise Git, Subversion ou un autre gestionnaire de versions, le mode d'utilisation est le même. Les commandes du gestionnaire de versions pour faire par exemple des commits ou des updates sont accessibles avec un clic droit. Les changements locaux ou distants sont accessibles dans la vue Change. Les repositories dans la vue repositories.
• Si le projet utilise Subversion, alors le menu Subversion sera accessible automatiquement sans qu'il y ait besoin d'effectuer des configurations. Idem, pour un projet Git.
• L'authentification  :
  lorsque l'on commence à utiliser le gestionnaire de versions, on cherche où mettre les paramètres d'authentification et on ne trouve pas l'écran correspondant ! En fait, l'authentification se fait au premier commit. Ensuite, les données d'authentification sont conservées sur le disque. Idea vous redemande un login et mot de passe seulement s'il ne trouve pas.

Cette vue affiche la liste des repositories SVN. Voici quelques remarques concernant cette vue.

• Par défaut la vue est vide.

Étant donné que j'avais déjà un projet Subversion de configurer, je m'attendais à voir le repository de mon projet. Ce n'est pas le cas. Il faut obligatoirement l'ajouter.

• L'ajout de repositoy est très facile. En effet, il suffit de saisir l'URL.
• Dans cette vue, il est possible de faire un checkout.

La vue SVN Repositories nous permet d'effectuer un checkout dans l'arborescence. On peut ainsi récupérer des tags, le trunk ou même un répertoire très facilement.

Par contre, à la fin de la procédure du checkout, IntelliJ nous demande si on veut créer un nouveau projet à partir des sources que l'on vient de récupérer. Si on clique oui, il va nous proposer de créer un nouveau projet. Il aurait été bien de mettre la possibilité d'ajouter un module.

• À l'aide du clic droit, on peut facilement comparer le trunk avec des branches ou des tags

  

• On peut effectuer les opérations courantes sur les branches/tags avec la boîte de dialogue « Branch or tags » accessible via un clic droit.

Cette vue permet de visualiser les modifications de fichiers dans différents onglets.

Il y a un onglet pour :

• les modifications locales ;
• toutes les modifications effectuées dans le repository ;
• les updates à venir ;
• les informations locales du repository ;
• les commits dans les branches locales et sur les repositories distant. (uniquement pour Git et mercurial).

L'avantage de cette vue est de regrouper tous les changements au même endroit.

De plus, cette vue offre la possibilité de faire un shelf. Ce mécanisme existe en natif sous Git sous le nom de « stash ». Par contre, il n'existe pas sous Subversion et à donc été implémenté par IntelliJ.

Un « shelf » va vous permettre de conserver vos modifications dans un endroit temporaire

Parfois, nous avons besoin de mettre en suspens des modifications pour faire un travail plus urgent. On stocke donc les modifications en cours dans un « shelf » puis plus tard, on pourra appliquer les modifications et reprendre où on en était.

• Il est possible de comparer deux versions d'un même fichier ou même de comparer une branche avec une autre. Par contre, je n'ai pas trouvé comment comparer deux révisions d'un même projet pour voir par exemple l'ensemble des fichiers modifiées.
• J'ai trouvé l'utilisation de subversion un peu déroutante au début.

Cela est dû au fait que la gestion du versionning se fait à plusieurs endroits : il y a un endroit pour le repository (SVN repositories), un pour les changements (Changes), un autre qui affiche les différentes versions d'un fichier (Version Control) et dans certains cas ce n'est pas très intuitif.

Prenons un exemple.

Je modifie un fichier et je veux faire un shelve dessus. Je m'attendrais à avoir la fonctionnalité de shelf en faisant clic droit -> subversion. Ce n'est pas le cas, il faut aller dans Change et faire shelves.

Les points remarquables de cette vue sont :

- il est possible de choisir un profil Maven ;

- il est possible d'ignorer les tests unitaires en cliquant sur l'icône suivante  ;

- la vue avec arborescence est très pratique. Elle permet de voir rapidement les profiles, targets et plugins qui sont disponibles ;

- il est possible de travailler en mode offline en cliquant sur l'icône .

Il est recommandé de définir un raccourci pour afficher la boîte à outils Maven. Pour cela, il faut aller dans File-> settings->keymap.

Pour importer un projet Maven, il suffit de cliquer sur et de sélectionner un fichier pom.xml. Vous verrez ainsi apparaître un nouveau module dans l'arborescence des projets et dans la boîte à outils.

• Il est possible de créer des targets personnalisées par contre, c'est un peu dommage mais il n'existe pas de boutons pour créer des targets personnalisées. Si on veut créer une target personnalisée, il faut sélectionner un goal ou une étape du cycle de vie dans la boîte à outils Maven et faire un clic droit dessus. Ensuite il faut sélectionner create '…'.
• De plus, si on crée une target personnalisée, elle n'apparaît pas dans l'arborescence. Elle apparaît dans la toolbar (cf II.A.2).

• IntelliJ détecte les modifications effectuées dans le fichier pom.xml. Si une nouvelle dépendance est ajoutée alors IntelliJ la télécharge automatiquement dans son repository local et l'ajoute dans son CLASSPATH.

• La complétion est possible dans le pom.xml

  Si vous saisissez le caractère '<', l'éditeur va alors vous proposer l'ensemble des balises disponibles.

  Il est possible de faire de la complétion dans le fichier pom.xml. La complétion se fait sur les balises mais aussi sur les variables définies dans le pom.xml.

• Il est possible de voir la structure d'un pom.xml :

On regrette cependant qu'il n'ait pas un nom pour les dependency et les repository.

• Voir les variables du pom.xml

  on pourra afficher le contenu de ${crsh.snapshots.repo.url} en faisant CTRL + survol de la souris sur la variable.

  Il est possible de voir les valeurs des variables contenues dans un pom.xml :

   

  Sélectionnez

      <snapshotRepository>
        <id>repository.exoplatform.org</id>
        <url>${crsh.snapshots.repo.url}</url>
      </snapshotRepository>

  si on prend le cas suivant :

• Ajout de dépendances

L'ajout de dépendance à l'aide de l'éditeur n'est pas très intuitif au premier abord. En effet, je n'ai pas trouvé de boutons pour ajouter une dépendance.

En fait, il suffit de faire ALT + INSER et une fenêtre de recherche s'affiche avec la liste de toutes les dépendances :

Il faut souligner le fait que la recherche est très rapide.

Lorsque vous importez un projet Maven qui contient des modules dans les fichiers pom.xml, IntelliJ va automatiquement vous créer l'arborescence correspondante. Dans cette vue, chaque module (icône avec le carré bleu) représente un module Maven.

• Complétion

La complétion se fait sur :

- les tags

IntelliJ fait la complétion sur tous les éléments HTML. Il vous suffit de saisir '<' et de saisir les premières lettres. Par exemple, si vous saisissez :<h, vous aurez dans la liste proposée h1, h2, h3…

- la fermeture de tags

- les attributs

Si vous saisissez :

<input type="

Et que vous faites CTRL+SPACE, vous aurez la liste des attributs possibles : button, checkbox, date…

- le style

- les références de fichier

J'ai rencontré un cas où la complétion ne fonctionnait pas bien. Je saisissais <inpu et dans la liste proposée, j'avais seulement un composant Spring en complétion : <form:input
alors que je m'attendais à avoir l'élément HTML : input.

• Zen coding

IntelliJ permet d'utiliser la complétion « zen coding ». Cette complétion va vous permettre de générer des balises avec leur contenu.

Exemple :

Si vous saisissez :

div.feature>p[TAB]

Vous obtiendrez :

            <div class="feature">
               
            </div>

Plus d'informations sur le zen coding à l'URL suivante : https://code.google.com/p/zen-coding/.

• Code folding

Le code folding vous permet de masquer les parties non utilisées. Ainsi vous allez pouvoir réduire un div à une seule ligne.

• Complétion

La complétion se fait sur les mots-clés, les valeurs, les propriétés, classes, html ID.

Exemple.

Si vous saisissez :

body {    
    mar

et que vous faites CTRL + ESPACE, l'éditeur va vous proposer margin, margin-bottom…

si vous choisissez margin et que vous refaites CTRL + SPACE, vous aurez la liste suivante : auto, inherit, length, percentage.

• pré-visualisation

Vous pouvez voir le contenu d'une classe css en prévisualisation à l'aide du raccourci CTRL + SHIT + I

Ce raccourci fonctionne aussi dans le code Java.

Cette fonctionnalité fonctionne aussi dans la liste proposée en complétion.

Dans cette partie, nous allons récupérer un projet Spring existant :

Git clone https://github.com/crashub/spring-ehcache-demo.git

Ce projet a été utilisé pour illustrer l'utilisation de CRaSH : un shell qui étend la plate-forme Java. Pour plus d'informations, reportez-vous sur l'article : ici

Ensuite, dans IntelliJ, nous ouvrons un projet existant en faisant : File ? Open project.

Le projet s'ouvre et IntelliJ télécharge les dépendances Maven. Il affiche également le message suivant dans la barre de statut :« Frameworks detected : Spring framework is detected in the project Configure »

En cliquant sur Configure, la fenêtre suivante s'affiche :

Si on ouvre le fichier MainController dans le package fr.dr.sandbox.controller, on constate deux icônes :

Ces icônes permettent de naviguer plus facilement. Ainsi, en cliquant sur l'icône devant « public class MainController », on ira directement dans le fichier de configuration correspondant.

La création de bean est très rapide. Une fois dans le fichier XML de Spring, il vous suffit de faire ALT + INSER et de choisir Spring beans. La structure XML de bean est alors créée :

    <bean id="" class="">

      

    </bean>

Le curseur est positionné automatiquement entre les guillemets dans l'attribut class. Ceci vous permet de saisir le chemin de la classe. La complétion vous permet de trouver rapidement votre bean.

Si votre bean, n'existe pas encore, il vous suffira une fois l'édition de class et id terminés, de faire ALT + INSER pour créer automatiquement la classe correspondante.

Pour changer la version de Spring, il suffit de cliquer sur l'icône « Project Structure »:

Il faut ensuite sélectionner la dépendance Maven Spring ayant une icône de feuille :

Il suffit ensuite de cliquer sur change version :

Dans cette section, nous avons abordé seulement quelques fonctionnalités d'un projet Spring.

Si vous souhaitez avoir une vue d'ensemble des fonctionnalités d'IntelliJ avec Spring, vous pouvez consulter les vidéos sur le site http://www.jetbrains.com/idea/features/spring_framework-tutorials.jsp

Voici quelques éléments de vocabulaire, qui vont vous permettre de mieux comprendre les fonctionnalités d'IntelliJ.

Eclipse permet de faire de l'autocomplétion. IntelliJ va beaucoup plus loin. En effet, on peut utiliser la complétion absolument partout ! On peut faire de la complétion dans les fichiers Java, HTML, CSS, JavaScript dans les pom.xml… Il en va de même pour le refactoring !

Vous pouvez consulter la partie III et IV pour plus de détails sur l'autocomplétion et le refactoring.

IntelliJ est livré avec beaucoup de plugins. Du coup, on ne perd pas de temps à installer des plugins communs à tous les projets (exemple : SVN).

Pour plus d'informations, reportez-vous à la section plugins.

Il faut noter qu'IntelliJ est très stable. Je n'ai pas constaté de bogue.

Une des difficultés pour migrer vers un nouvel EDI, c'est l'apprentissage de nouveau raccourcis. IntelliJ fournit une keymap pour Eclipse. Ainsi, on peut conserver ses habitudes et migrer en douceur vers IntelliJ.

IntelliJ fournit aussi des keymaps pour Netbeans, Jbuilder, Visual Studio et Emacs.

IntelliJ fournit des raccourcis pour plusieurs environnements : KDE, GNOME, Mac…

Vous pouvez aussi voir une conférence faite à Devoxx sur Parleys.com :
http://www.devoxx.com/display/FR13/IDE+Java+++astuces+de+productivite+pour+le+quotidien

Eclipse est gratuit et IntelliJ en version community.

Un premier élément de réponse est le type de projet que vous souhaitez faire. En effet, avec Eclipse, vous pourrez faire tous les projets alors qu'avec IntelliJ vous serez limité au projet standards.

Plus d'informations sur : http://www.jetbrains.com/idea/features/editions_comparison_matrix.html

Ensuite, si vous choisissez un projet standard, j'espère que cet article vous aura donné quelques éléments de réponse…

Jetbrains améliore constamment IntelliJ en proposant très régulièrement des mises à jour qui permettent d'ajouter des nouvelles fonctionnalités et de corriger des nouveaux bogues. (environ toutes les semaines) à l'aide d'une boîte de dialogue qui nous y invite. Cela permet d'avoir un EDI constamment à jour alors qu'avec Eclipse, on a tendance à mettre à jour son EDI seulement lors d'un passage à une version majeure.

On ne voit pas toujours les erreurs sur un fichier. Pour voir les erreurs sur un fichier, on est obligé d'ouvrir le fichier ou d'effectuer une compilation. Ce n'est pas le cas d'Éclipse qui, une fois le fichier sauvegardé, va surligner le fichier en rouge.

La fonctionnalité Recherche Structurelle n'est pas présente dans la version Community. Les principales différences entre la version Community et la version Ultimate concernent le support de framework donc c'est un peu dommage de ne pas retrouver une fonctionnalité de recherche dans la version Community

Pour acquérir IntelliJ, il faudra débourser :179 € HT pour une licence personnelle et 89 € HT pour une licence étudiante.

Pour plus d'information sur le prix, vous pouvez aller voir http://www.jetbrains.com/idea/buy/index.jsp.

• Si vous utilisez OpenJDK, vous risquez d'avoir des problèmes de performance :

OpenJDK Runtime Environment (IcedTea6 1.12.3) (6b27-1.12.3-0ubuntu1~12.10.1)
OpenJDK Server VM (build 20.0-b12, mixed mode)
WARNING : You are launching the IDE using OpenJDK Java runtime.

 ITS KNOWN TO HAVE PERFORMANCE AND GRAPHICS ISSUES !
 SWITCH TO THE ORACLE (SUN) JDK BEFORE REPORTING PROBLEMS!

NOTE : If you have both Oracle (Sun) JDK and OpenJDK installed
     please validate either IDEA_JDK, JDK_HOME, or JAVA_HOME environment variable points to valid Oracle (Sun) JDK installation.
     See http://ow.ly/6TuKQ for more info on switching default JDK.

Pour ma part, cela est arrivé une fois. Je n'arrivais plus à voir l'arborescence de mon projet. En tout cas, j'étais prévenu ;-)

L'ouverture de popup, la navigation entre les différents éléments sont très fluides. Il n'y a pas de temps de latence.

Une des premières choses que l'on remarque lorsque l'on utilise IntelliJ, c'est le confort d'utilisation. Une fois que l'on a pris un peu en main l'EDI, on navigue très rapidement entre les différents éléments. Voici quelques raccourcis indispensables à connaître pour naviguer entre les différents éléments :

• CTRL - NUM : pour ouvrir différents éléments (project, structure…)

• ALT-RIGHT - ALT-LEFT : permet de naviguer entre les différents fichiers.

Lors de l'installation, le setup vous demande quels sont les plugins que vous souhaitez utiliser. Vous pouvez choisir ceux que vous utiliserez plus. Ainsi, vous n'avez pas besoin d'effectuer des configurations supplémentaires et vous pourrez directement commencer votre projet. De manière générale, on peut dire qu'avec IntelliJ, on ne passe pas du temps à installer des plugins.

Une des grandes forces d'IntelliJ, c'est les raccourcis. Le problème des raccourcis, c'est qu'il faut les apprendre !

IntelliJ propose un moyen simple en natif pour apprendre les raccourcis : le productivity guide . Ce guide affiche des statistiques sur l'utilisation des fonctionnalités et des raccourcis d'IntelliJ :