IDEs — IntelliJ IDEA, Eclipse, and VS Code

What is an IDE — and Why Does It Exist?

Before IDEs, Java development meant a text editor plus a terminal: write the file, run javac, read the compiler's line-number errors, switch back to the editor, repeat. Every piece of context — which classes exist, whether a method call is valid, whether a variable is null-safe — lived only in the developer's head. An IDE's actual job is to make that context machine-visible: it parses your entire codebase (and its dependencies) into an in-memory symbol index so it can answer "does this method exist / is this type correct / where is this used" in milliseconds, continuously, before you ever run a compile.

// BEFORE — editor + terminal, zero live feedback
$ vim OrderService.java
$ javac OrderService.java
OrderService.java:14: error: cannot find symbol
    customerRepository.findByEmail(email)
                        ^
  symbol:   method findByEmail(String)
  location: variable customerRepository of type CustomerRepository
// The error is discovered only after a full compile — and all you get
// is a line number, not a fix.

// AFTER — IDE with live semantic indexing
// The IDE flags the missing method the instant you type it — a red
// underline, no compile step required — and offers to generate the
// method stub directly on CustomerRepository via a quick fix.
public interface CustomerRepository extends JpaRepository<Customer, Long> {
    Optional<Customer> findByEmail(String email);   // generated in one keystroke
}

This is the actual value proposition of an IDE, and it's worth stating precisely because it's what separates a real IDE from "a text editor with syntax highlighting": a full semantic model of your code, kept live as you type, that powers code completion, error detection, navigation, and mechanical refactoring — all without a compile-run cycle.

The 2026 Java IDE Landscape — and How Each One Actually Sees Your Code

The three mainstream options solve the "semantic model" problem with genuinely different architectures, and that architectural choice is why their behavior on large codebases diverges:

• IntelliJ IDEA builds its own proprietary semantic model — the PSI (Program Structure Interface) — a full syntax and type tree maintained entirely by JetBrains, independent of any external compiler. This is why its refactoring and code-completion tend to stay accurate even across huge multi-module Maven/Gradle projects.
• Eclipse uses the JDT (Java Development Tools) — its own incremental Java compiler that re-parses and re-type-checks only the files that changed. JDT predates the Language Server Protocol and was built directly into Eclipse's architecture.
• VS Code has no built-in Java understanding at all. Its Java support comes from wrapping Eclipse's own JDT as a Language Server (JDT.LS), communicated over the Language Server Protocol (LSP) — the same underlying engine as Eclipse, exposed through a different editor shell.

IntelliJ IDEA

IntelliJ IDEA, developed by JetBrains, is the default choice for most professional Java teams — its PSI-based engine gives it the strongest refactoring and framework-aware completion of the three mainstream options.

Editions

• Community Edition — free, open-source, covers core Java SE, JUnit, and basic Maven/Gradle support
• Ultimate Edition — paid, adds Spring/Spring Boot-aware completion, Jakarta EE tooling, database tools, and JavaScript/TypeScript support for full-stack work

Key Features

// Framework-aware completion (Ultimate) — knows Spring bean wiring, not just syntax
@Service
public class OrderService {
    private final CustomerRepository customerRepository;

    public OrderService(CustomerRepository customerRepository) {
        this.customerRepository = customerRepository;
    }
    // Gutter icon links this constructor directly to the Spring bean graph —
    // click it to jump to every place this bean is injected.
}

// Real-time null-safety analysis
Customer customer = customerRepository.findById(id).orElse(null);
customer.getEmail();  // flagged: "Method invocation may produce NullPointerException"

// Quick Fix (Alt+Enter) on a missing null check
public void notify(Customer customer) {
    // Alt+Enter here offers to wrap in an Objects.requireNonNull or an if-null guard
}

Live Templates

// Type the abbreviation and press Tab to expand

// "psvm" →
public static void main(String[] args) { }

// "sout" →
System.out.println();

// "iter" → enhanced for-loop over the inferred collection type
for (OrderItem item : order.getItems()) { }

Essential Keyboard Shortcuts

Eclipse IDE

Eclipse is a free, open-source IDE built on the OSGi plugin architecture (Equinox) — every feature, including Java support itself, is a plugin. This is why it's historically been the IDE of choice for teams needing deep customization or vendor application-server tooling built as Eclipse plugins.

Eclipse Packages

• Eclipse IDE for Java Developers — core Java SE development
• Eclipse IDE for Enterprise Java and Web Developers — Jakarta EE, JAX-RS, application-server integration

Key Features

// Content Assist (Ctrl+Space)
Order order = orderRepository.findById(orderId);
order.  // Ctrl+Space lists every accessible member of Order

// Quick Fix (Ctrl+1) on an unresolved type
// Hover the error, Ctrl+1 → "Import 'Order' (com.shop.model)"

// Organize Imports (Ctrl+Shift+O) — adds missing, removes unused

Essential Keyboard Shortcuts

Workspace Structure

workspace/
├── .metadata/                  # Eclipse settings — never commit this
├── order-service/
│   ├── .project                # project descriptor
│   ├── .classpath              # classpath entries
│   └── src/main/java/com/shop/order/
└── customer-service/
    └── ...

Visual Studio Code

VS Code is a lightweight, cross-platform editor turned into a Java IDE entirely through extensions — its Java intelligence, as covered above, comes from wrapping Eclipse's JDT as a language server rather than a purpose-built Java engine.

Essential Java Extensions

• Extension Pack for Java (Microsoft) — bundles Language Support for Java (Red Hat), Debugger for Java, Test Runner for Java, and Maven for Java
• Spring Boot Extension Pack — bean navigation, application.properties completion

VS Code Java Shortcuts

AI-Assisted Development in the IDE

Every mainstream IDE now ships an integrated AI layer — GitHub Copilot (IntelliJ, Eclipse, VS Code), JetBrains AI Assistant and its autonomous coding agent Junie, and AI-native editors like Cursor and Windsurf with agentic "auto-accept" modes. These sit on top of the semantic engines from Section 1 — they don't replace them, and the distinction matters in production.

// A plausible-looking AI suggestion for a repository query method
@Query("SELECT o FROM Order o WHERE o.customer.email = :email")
List<Order> findOrdersForCustomer(@Param("email") String email);

// Looks correct and compiles. What the assistant didn't know:
// this project's convention is soft-deleted orders (deletedAt IS NULL),
// enforced everywhere else via a @Where clause the assistant never saw
// because it wasn't in the file it was editing. The generated method
// silently returns cancelled/deleted orders too.

Where it genuinely helps

• Boilerplate the IDE can't template-generate — mapping DTOs, writing parameterized test cases across a matrix of inputs
• Explaining unfamiliar code in a legacy module before you refactor it
• Drafting a first pass at a Javadoc or a commit message, always edited afterward

IDE Comparison

Debugging in IDEs

Local debugging

public void processOrder(Order order) {
    BigDecimal total = BigDecimal.ZERO;         // breakpoint here

    for (OrderItem item : order.getItems()) {
        total = total.add(item.getUnitPrice()
                    .multiply(BigDecimal.valueOf(item.getQuantity())));
    }

    applyDiscount(order, total);         // Step Into (F7 / F5) to follow the call
    order.setTotal(total);               // Step Over to stay at this level
}

// Conditional breakpoint: right-click the breakpoint → add a condition
// Example: item.getQuantity() > 100 — stops only for bulk-order edge cases

// Watch expression: order.getItems().size() — evaluated live at every stop

Remote debugging — attaching to a running container

In a microservices e-commerce stack, the service misbehaving in staging is usually already running inside a Docker container or a Kubernetes pod — you don't reproduce it locally, you attach to it.

# Enable the JDWP debug agent when starting the JVM inside the container
JAVA_TOOL_OPTIONS="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005"

# docker-compose.yml — expose the debug port alongside the app port
services:
  order-service:
    environment:
      - JAVA_TOOL_OPTIONS=-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005
    ports:
      - "8080:8080"
      - "5005:5005"

// IntelliJ: Run → Edit Configurations → + → Remote JVM Debug → host, port 5005
// Eclipse: Run → Debug Configurations → Remote Java Application

Project Configuration

Setting up the JDK

// IntelliJ IDEA: File → Project Structure → Project → SDK
// Eclipse: Window → Preferences → Java → Installed JREs

// VS Code — settings.json, multiple JDKs for polyglot service work
{
    "java.configuration.runtimes": [
        { "name": "JavaSE-17", "path": "/opt/jdk-17" },
        { "name": "JavaSE-21", "path": "/opt/jdk-21", "default": true }
    ]
}

Importing a multi-module project

// e-commerce-platform/
//   ├── order-service/pom.xml
//   ├── customer-service/pom.xml
//   └── shared-domain/pom.xml   ← common Customer/Order/Product model

// IntelliJ: File → Open → select the root pom.xml → "Open as Project"
//   (multi-module Maven reactor is detected and each module becomes a
//   separate IntelliJ module with correct inter-module dependencies)

// Eclipse: File → Import → Maven → Existing Maven Projects → select all modules
// VS Code: open the root folder — the Java extension detects the reactor automatically

Productivity and Team-Wide Configuration

# .editorconfig — committed at repo root, read by all three IDEs
root = true

[*.java]
indent_style = space
indent_size = 4
max_line_length = 120
insert_final_newline = true
trim_trailing_whitespace = true

Code generation, on the actual domain

// Generate constructor, accessors, equals/hashCode, toString
// (Alt+Insert in IntelliJ, Source menu in Eclipse)
public class Customer {
    private Long id;
    private String email;
    private String fullName;
    private LocalDate registeredAt;

    // Generated constructor
    public Customer(Long id, String email, String fullName, LocalDate registeredAt) {
        this.id = id;
        this.email = email;
        this.fullName = fullName;
        this.registeredAt = registeredAt;
    }

    // Generated equals/hashCode — based on id, the natural identity for an entity
    @Override
    public boolean equals(Object o) { /* ... */ }

    @Override
    public int hashCode() { return Objects.hash(id); }
}

Generated equals()/hashCode() on a JPA entity should key off the identifier, not every field — see Entity Relationships for why field-based equality breaks inside collections once Hibernate's persistence context is involved.

Choosing the Right IDE by Use Case

Best Practices and Common Pitfalls

Interview Questions