Like Eclipse and NetBeans, it’s pretty easy to download, install, and get IntelliJ IDEA up and running to start coding. Note that your computer should have at least 4GB of RAM to run the IDE smoothly. In this lesson, I will guide you how to download and install IntelliJ IDEA on Windows operating system.

Although IntelliJ IDEA is bundled with JRE 8, you still need to have JDK 8 or higher installed on your computer first. That means the IDE is running on its own JRE and requires a separate JDK for Java development.

Click this URL to open the download page:

https://www.jetbrains.com/idea/download/

You will see the following screen:

Here, you can download the Ultimate edition or Community edition for Windows, Mac or Linux. On Windows, you can download either an installer (EXE) or a Zip package.

I recommend you to try the Ultimate edition to experience the full features of IntelliJ IDEA in 30 days.

1. Install IntelliJ IDEA using Installer

Click Download .EXE to start downloading the installer program. Once download completed, run the installer program and the following screen appears:

Click Next. Let it uses the suggested installation directory, or click Browse to choose a different location on your computer:

Click Next. You can choose to create desktop shortcut and file associations:

And click Next to start installing the IDE:

2. Install IntelliJ IDEA using ZIP package

In the download page, click the down arrow to the right of the Download button, and select Windows (.zip):

Once download completed, extract the Zip file to a destination directory on your computer.

3. Run IntelliJ IDEA for the first time

If you install IntelliJ IDEA from an EXE installer, launch the IDE by clicking its shortcut on desktop or in Programs menu. In case you extract from a zip file, go to the bin directory and run the idea.exe (32-bit) or idea64.exe (64-bit) file.

The Ultimate edition asks you to activate license:

Choose the option Evaluate for free to use the Ultimate edition for free in 30 days. The Community edition doesn’t ask you to activate license. Click Evaluate.

Then you are asked to choose a favorite theme:

You can choose theme Darcula (black) or IntelliJ (white). Click Next: Default Plugins:

Here, you can customize various plugins. The default is good enough, so click Skip Remaining and Set Defaults.

Then it is all set, the splash screen appears:

Then comes the Welcome dialog, which lets you to create a new or open an existing project:

That’s it! Now you can experience one of the best Java IDEs ever.

1. What is IntelliJ IDEA?

IntelliJ IDEA is a Java IDE developed by JetBrains - a software development company based on Praque, Czech Republic. The company was formerly named as IntelliJ - you know it if you used IntelliJ some years ago.

As its name implies, the IDE is designed to be intelligent - focus on providing smart code auto completion, insight and analysis in every context - to improve developer’s experience and productivity. The first version was released in 2001.

IntelliJ IDEA is written in Java so it is a cross-platform IDE - meaning that you can use it on Windows, Mac or Linux. JetBrains provides two editions for this Java IDE:

- An open-source and free edition called IntelliJ IDEA Community.

- A commercial edition called IntelliJ IDEA Ultimate.

The Community edition is very limited in features: you can develop only Java desktop and Android applications. Whereas the Ultimate edition supports development of a wide range of Java technologies and frameworks. You can use the Ultimate edition for 30-day trial period and then pay for it.

In 2014, Google announced Android Studio which is based on the open-source edition of IntelliJ IDEA.

In 2015, JetBrains released the first version of Kotlin - a new programming language for the JVM (Java Virtual Machine). Kotlin is aimed to be a “better language” than Java. And in 2017, Kotlin becomes the official language for Android development.

2. IntelliJ IDEA vs. Eclipse/NetBeans

In terms of basic development features and technologies/frameworks support, IntelliJ IDEA is similar to Eclipse and NetBeans. Virtually what you can build with IntelliJ you can do the same with Eclipse/NetBeans. If not, you can easily find plugins for Eclipse/NetBeans. So what is the real difference of IntelliJ IDEA?

From my own experience, the biggest difference is IntelliJ IDEA is smarter in terms of code auto completion, refactoring, debugging and other productivity features. For example, the auto-save feature is really cool: you don’t have to press Ctrl + S anymore - the IDE automatically saves every letter you have typed.

The IDE is able to feel the context better to provide more accurate and intelligent auto completion. For example, when you start typing the variable name for a method parameter, IntelliJ IDEA suggests only possible values that are compatible to the type of the parameter.

When you create a new HTML/JSP file, the IDE positions the cursor at the <title> tag to let you edit the webpage’s title immediately. Small feature but convenient!

When you are editing a SQL statement in Java code, the IDE automatically suggests table and field names accordingly - if you set up an appropriate data source.

When you write HTML, CSS and Javascript code, IntelliJ IDEA knows what CSS and Javascript files you refer in the HTML document and provides auto completion like suggesting CSS class names and Javascript functions. Very cool!

If you are new to this IDE, you will find it a little bit difficult to use, especially if you are familiar with Eclipse or NetBeans. And over the time, you will feel more comfortable with IntelliJ IDEA.

However, IntelliJ IDEA is not all good. I used both Community and Ultimate editions to develop several kinds of applications like Java web/enterprise, Swing, JavaFX, Spring framework… and come to conclude that using IntelliJ IDEA is not as easy as Eclipse/NetBeans.

For example, when creating a Java servlet class via wizards, IntelliJ IDEA is lack of options to configure URL mappings or choosing HTTP methods to implement. When design Swing GUI, the designer in IntelliJ is worse than the one in NetBeans. And Tomcat in doesn’t reload changes like in Eclipse.

Therefore, if you want to develop Android, Kotlin and Java enterprise applications with frameworks, IntelliJ IDEA is a good choice. Otherwise you can still use Eclipse or NetBeans.

3. Advantages of IntelliJ IDEA

Here are some cool features of IntelliJ IDEA that make our development experience more productivity and joyful:

- Fast loading time, fast and intelligent code auto completion.

- Auto-save: IntelliJ IDEA saves everything you type instantly. So you never miss a single bit.

- Download JAR libraries from Maven repository: if a dependency is missing, say MySQL Connector Java, the IDE lets you download it from Maven website and add it to the project’s lib directory. Very convenient - you don’t have to leave your IDE to open a browser.

- Automatic labeling for method arguments: when you pass values directly as arguments to a method, IntelliJ automatically shows the names of the parameters to improve code readability:

- Support code completion for SQL statement right inside Java code:

- Code Inspection: this feature allows you to quickly scan code for issues and recommendations from the IDE:

- Support for developing Kotlin applications. You can convert Java code to Kotlin and vice-versa.

- Support for developing Android applications.

- Support for developing a wide range of Java technologies and frameworks (Ultimate edition only):

- And you can quickly search and perform any action in the IDE, just by using the shortcut key Ctrl + Shift + A:

4. Disadvantages of IntelliJ IDEA

IntelliJ IDEA is not a perfect IDE. Here are some of its weaknesses:

- The Community edition is very limited in development support. It allows you to develop only Java desktop and Android applications. And the Ultimate edition is costly.

- Java web development (JSP/Servlet) is not easy and intuitive like Eclipse/NetBeans.

- The Swing GUI Designer in IntelliJ IDEA cannot be compared with the one in NetBeans.

References:

JetBrains Homepage

IntelliJ IDEA Homepage

In this tutorial, I will to walk you through the step-by-step process of developing a simple database program in Java using IntelliJ IDEA Ultimate edition. To get familiar with an IDE, nothing better than working directly on it, right?

Before starting, make sure that you have JDK, IntelliJ IDEA and MySQL database server installed on your computer, and read these 2 articles first:

• Introduction to IntelliJ IDEA for beginner
• How to download and install IntelliJ IDEA

1. Setup MySQL database

Create a new database named sales with one table named product with the following structure:

This table has 5 columns: id, name, brand, madein and price. You can create this table by executing the following MySQL script in MySQL Workbench tool:

CREATE TABLE `product` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(45) NOT NULL,
  `brand` varchar(45) NOT NULL,
  `madein` varchar(45) NOT NULL,
  `price` float NOT NULL,
  PRIMARY KEY (`id`)
)

Note: Later you will see you can even create a database (schema) and tables within the IDE.

2. Create new project

Open IntelliJ IDEA and click Create New Project in the welcome screen (or File > New Project if you’re already in the IDE). The New Project dialog appears:

You can see IntelliJ IDEA supports many types of projects. But we’re creating a simple Java program, so select only Java at the top left and click Next. Click Next again to skip create project from template.

In the next screen, enter project name and location as follows:

Click Finish, and click OK if it asks to create the directory. Then you can see the workspace looks like this:

As you can see, the default views include Project, Structure, Terminal, Databases… and IntelliJ IDEA hints the 4 shortcut keys in the center. The workspace looks similar to Eclipse/NetBeans but it intelligently tells you the most frequently needed shortcuts.

3. Connect to MySQL database in IntelliJ IDEA

Now, let’s see how to connect to MySQL database right inside the IDE. First, we need to define a data source.

Click the Database view, then click the + sign at the top left corner, point to Data Source and click MySQL:

Then in the Data Sources and Drivers dialog, you need to specify database connection information and JDBC driver to use. Type in user, pass and Database name as shown in the following screenshot:

And click Driver: MySQL (4) > Go to Driver. Select a version for MySQL JDBC driver as follows:

Then IntellIJ IDEA automatically downloads the required JAR file (this saves time in finding jar files on the Internet).

Here, you need to choose the correct driver class name, e.g. com.mysql.jdbc.Driver for MySQL Connector/J version 5.1.47. Then click OK, the IDE will connect to the database and open the console editor that allows you to type SQL statement directly, as shown in the following screenshot:

Now, you can experiment database development support in IntelliJ IDEA. Play around with the Database view to see the table structure; type a SELECT statement in the console editor and execute it; see the result set, which is empty because we haven’t inserted any rows to the product table yet.

Note that the Database view allows you to create new database (schema) and tables directly, so you don’t have to use any external database tools. Awesome!

So, as you have seen, IntelliJ IDEA makes it easy to work with a database right inside from the IDE (you don’t have to open any external programs) in just few clicks. That means our productivity is increased.

4. Code a batch insert program

Next, let’s code the first Java program that inserts 100 rows into the product table using JDBC batch update feature.

Right click on the src folder in the Project view, and select New > Package:

Then enter the name for the package, e.g. net.codejava – as shown below:

Click OK to create the package. Then right-click on the package name, select New > Class:

Enter the name of the new class is BatchInsertApp, as below:

As you can see, IntelliJ IDEA suggests you to create a class (default), interface, enum or annotation – so you can easily change without going one step backward.

Hit Enter to create the class. Then type the word main – you can see the IDE instantly suggests you to create the main method:

Press Enter to insert the main method. Then type the following initial code for the main method:

String url = "jdbc:mysql://localhost:3306/sales";
String username = "root";
String password = "password";

try {
    Connection connection = getConnection(url, username, password);
    String sql = "";
    PreparedStatement statement = connection.prepareStatement(sql);
    
} catch (SQLException e) {
    e.printStackTrace();
}

The IDE automatically suggests code completion as you type. You can press Ctrl + Space to force the IDE showing code suggestion; and Alter + Enter to show hints.

Now let’s modify the sql variable to write a SQL Insert statement to experiment the auto completion for SQL statement, something as shown below:

You see? It’s very quick and convenient as the IDE hints the table name, field names and other SQL keywords.

Then write the complete code as follows:

package net.codejava;

import java.sql.*;

public class JdbcBatchInsertTest {
    public static void main(String[] args) {
        String dbURL = "jdbc:mysql://localhost:3306/sales?useSSL=false";
        String username = "root";
        String password = "password";

        try (Connection connection = DriverManager.getConnection(dbURL, username, password)) {
            
            String sql = "INSERT INTO product (name, brand, madein, price) VALUES (?, ?, ?, ?)";

            PreparedStatement statement = connection.prepareStatement(sql);
            for (int i = 1; i <= 10; i++) {
                String name = "Name-" + i;
                String brand = "Brand-" + i;
                String madein = "Madein-" + i;
                float price = 1000f;

                statement.setString(1, name);
                statement.setString(2, brand);
                statement.setString(3, madein);
                statement.setFloat(4, price);

                statement.addBatch();

            }

            statement.executeBatch();

        } catch (SQLException ex) {
            ex.printStackTrace();
        }

    }
}

While writing the code, try to use the auto completion for try-catch (Press Alt + Enter to show hints and choose action), for loop (type fori) and print statement (type sout).

Next, we need to add a dependency of MySQL JDBBC driver to the project, so it can run. Right-click on the project name and click Open Module Settings (or press F4 key).

Then in the Project Structure dialog, under the Modules section, click the + button to add a library from Maven, as shown below:

In the search dialog, type mysql-connector-java and click the search button. Wait for a moment, while the IDE is searching on Maven online repository. Then choose the library mysql-connector-java version 5.1.47, like this:

Then check the option Download to and click OK:

And click OK again to confirm in the Configure Library dialog. Then choose the scope Runtime for the dependency:

Click OK to close the Project Structure dialog. As you have seen, IntelliJ IDEA makes it easy to get a JAR file from Maven’s online repository. Even you don’t have to open your browser program.

5. Run the program

Now, let’s run our program. You can see there are two green arrows on the left side, near the beginning of the class. Click on the first arrow, and choose the first Run option:

Wait for a few seconds while it is building the project, and you will see the output:

You see, it prints the output “Running time: 3115” which is the time it took to insert 100 rows into the database. The red line above is a warning message from MySQL JDBC driver, and the exit code 0 indicates that the program terminates normally.

Now, switch to the MySQL console view and execute the SELECT statement again. You will see the data appears in table format like this:

In this view, you can even add new row and commit to the database. Very convenient!

So far you have done your first project using IntelliJ IDEA to get familiar with it. As you experience, IntelliJ is smart and greatly improve developer’s productivity by the ability of doing everything within the IDE itself.

Challenge for you today: Code the 2^nd program that allows the user to search for data in the product table (by name, brand and madein fields).

In this article, I’d like to share with you guys on how to create and build a Java Maven project that consists of multiple modules using IntelliJ IDEA.

Given a scenario in which we need to develop a Java project that has two types of apps: Console app and Desktop app. Each app has its own code, and they also share some common code which is in a Shared Library, as depicted in the following picture:

So there would be 3 different projects: Shared Library, Console App and Desktop App. The Console App and Desktop App projects have to use the common code in the Shared Library project.

Using Maven, we will need to create a project acts as the root project for the modules. Each module is a separate project right inside the root project, as shown below:

Note that the packaging type of the root project must be pom. And the packaging type of modules can be jar or war.

Now, let’s create this multi-module project in IntelliJ IDEA.

1. Create the root Maven project

In IntelliJ IDEA’s welcome dialog, click New Project. Choose Maven and click Next:

Enter project name and specify artifact coordinates information as below:

Click Finish. It will create a simple Maven project.

2. Create the SharedLibrary project

Next, we create the first Maven module for the shared library project. Right-click on the root project, and select New > Module:

Then enter the module name as SharedLibrary. Note that the parent module is CompanyProject:

Click Finish. IntelliJ IDEA will create the SharedLibrary project under CompanyProject. You can notice the pom.xml file of the root project was updated:

<project ...>
    
    [...]
    
    <groupId>com.mycompany</groupId>
    <artifactId>CompanyProject</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    
    <modules>
        <module>SharedLibrary</module>
    </modules>

    [...]    

</project>

You see, it specifies the packaging type is pom, and adds a module named SharedLibrary. And in this SharedLibrary project’s pom.xml file, it specifies the parent information as below:

<project ...>

    <parent>
        <artifactId>CompanyProject</artifactId>
        <groupId>com.mycompany</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>SharedLibrary</artifactId>

    [...]
    
</project>

And code a simple class in this project as follows:

package com.mycompany;

public class CommonUtility {

    public static String getAppName() {
        return "My Company App Beta version";
    }
}

The static method getAppName() will be used by both console app and desktop app.

3. Create the ConsoleApp project

Similarly, create the second Maven module for the ConsoleApp project. And in order to reference the SharedLibrary project, you should declare the dependency in the pom.xml file of the ConsoleApp project as follows:

<project ...>
    [..]

    <artifactId>ConsoleApp</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.mycompany</groupId>
            <artifactId>SharedLibrary</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

    [..]

</project>

Note: You may need to Reload Maven project to update the dependency information.

Then code a simple console program like this:

package com.mycompany;

public class ConsoleApp {

    public static void main(String[] args) {
        String appName = CommonUtility.getAppName();
        System.out.println("Welcome to " + appName);
    }
}

You see, this class makes use of the CommonUtility class from the SharedLibrary project. 

4. Create the DesktopApp project

Similar to the ConsoleApp project, create the third Maven module for the DesktopApp project. We would end up having the modules declared in the root project like this:

<project ...>

    <groupId>com.mycompany</groupId>
    <artifactId>CompanyProject</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    
    <modules>
        <module>SharedLibrary</module>
        <module>ConsoleApp</module>
        <module>DesktopApp</module>
    </modules>

    [...]

</project>

For demo purpose, code a simple Swing program for the desktop app with the following code:

package com.mycompany;

import javax.swing.*;
import java.awt.*;

public class DesktopApp extends JFrame {
    static String appName = CommonUtility.getAppName();

    public DesktopApp() {
        super(appName);
        init();
    }

    private void init() {
        setLayout(new FlowLayout());
        add(new JLabel("Welcome to " + appName));
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setSize(640, 480);
        setLocationRelativeTo(null);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                new DesktopApp().setVisible(true);
            }
        });
    }
}

You see, this class also makes use of the CommonUtility class from the SharedLibrary project. 

5. Build a Multi-Module Maven project in IntelliJ IDEA

To build the whole multi-module Maven project in IntelliJ IDEA, open Maven view. Select the root project, and click button Execute Maven Goal, and double click mvn install from the list, as shown below:

Then you should see the Maven’s build success output as follows:

Now you can check the target directory in each project. Maven should have generated jar file for each project there.

That’s how to create a multi-module Maven project in IntelliJ IDEA. To see the steps and coding in action, I recommend you to watch the following video:

https://www.youtube.com/watch?v=XqC1zeFdxMs

Related Articles:

• Introduction to IntelliJ IDEA for beginner
• How to download and install IntelliJ IDEA
• Getting Familiar with IntelliJ IDEA - Tutorial for beginner

In this short post, I’d like to share with you how to completely remove an instance of IntelliJ IDEA from Windows operating system, either it is installed by installer or from ZIP archive.

Basically, to completely uninstall IntelliJ IDEA, you need to:

- Run installer program, or delete folder extracted from Zip archive

- Delete folders that store settings and cache

1. Remove IntelliJ IDEA using Uninstaller

On Windows, click Start menu > Settings, and click Apps in Settings window. Under Apps & Features, look for IntelliJ IDEA, and click Uninstall:

Click Uninstall again to confirm. You will the Intellij IDEA uninstaller:

Check the two delete options to delete caches and settings of IntelliJ IDEA. Then click Uninstall to proceed. It will remove the IDE under 1 minute or 2.

2. Uninstall IntelliJ IDEA installed from Zip archive

If you have an instance of IntelliJ IDEA extracted from ZIP archive, just delete the whole directory. And then you have to manually delete some folders that store settings and caches.

With IntelliJ IDEA 2020.1 or newer. Delete these folders:

%APPDATA%\JetBrains\<product><version>

%LOCALAPPDATA%\JetBrains\<product><version>

Example:

C:\Users\Username\AppData\Roaming\JetBrains\IntelliJIdea2021.2

C:\Users\Username\AppData\Local\JetBrains\IntelliJIdea2021.2

With IntelliJ IDEA 2019.3 or older, delete this folder:

%USERHOME%\.<product><version>\config

Example:

C:\Users\Username\.IntelliJIdea2019.3\config

That’s how to completely uninstall IntelliJ IDEA from Windows computer. To see the steps in action, I recommend you watch the video below:

https://www.youtube.com/watch?v=bP9jVwybSJ0

Other Uninstallation Guides:

• How to Uninstall NetBeans IDE completely from Windows
• How to Completely Uninstall Eclipse IDE from Windows computer

IntelliJ IDEA comes with a very cool feature that provides auto completion and inspection for writing SQL statements write inside Java code such as SQL syntax suggestion; table and column names suggestion for the configured datasources in the project.

If somehow the SQL autocomplete feature is not working in IntelliJ IDEA, you can follow the following two steps to fix it.

1. Set language reference as SQL

If IntelliJ doesn’t recognize the SQL literal (with SQL keywords are in orange color), place the caret inside the SQL literal and press Alt + Enter to show the available hints:

Then choose Inject language or reference, and select SQL from the list of languages:

The you will see IntelliJ recognizes the String literal as SQL statement, as shown below:

Now, if you press Ctrl + Space, you will see the autocomplete for SQL keywords – not for names of tables and columns in the configured data sources. So perform the last step below.

2. Set SQL Dialect

Press Shift two times (double Shift) to see the quick search dialog, and type SQL dialects:

Wait a couple of seconds to see the SQL Dialects Settings and click it. Then in the Settings dialog, choose the appropriate SQL dialect, e.g. MySQL:

Click OK, and come back to edit the SQL statement, you should see the auto completion for table names and column names:

That’s 2 steps to fix the SQL autocomplete not working issue in IntelliJ IDEA. Enjoy coding!

To see the solution in action, watch this video:

https://www.youtube.com/watch?v=2XEqoiKV464

Related Articles:

• Introduction to IntelliJ IDEA for beginner
• How to download and install IntelliJ IDEA
• Getting Familiar with IntelliJ IDEA - Tutorial for beginner