Disable Wildcard Import in IntelliJ

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

1. Overview

In Java development, proper import statements are important in maintaining code readability and avoiding potential conflicts.

IntelliJ IDEA is a popular integrated development environment (IDE) for Java. So, in this quick tutorial, we’ll explore how to disable wildcard imports in IntelliJ.

2. IntelliJ’s Optimize Imports Feature

IntelliJ ships with the “optimize imports” feature, which can automatically rearrange import statements, such as applying a predefined style, adjusting the order, cleaning the unused imports, etc.

We can apply “optimize imports” to the current Java file through the menu item: Code -> Optimize imports:

Of course, we can also optimize imports in the current Java file using shortcuts.

3. The Import Settings in IntelliJ

Wildcard import is a common practice that imports all classes within a package, such as import java.util.*. Wildcard imports can save keystrokes. However, they may introduce ambiguity and make code harder to understand.

To disable the wildcard import, we open the Settings popup window: File -> Settings (or “Preferences” on macOS).

Then, in the Settings window, we navigate to the Java imports setting tab: Editor -> Code Style -> Java ->Imports:

Under the “Imports” tab, three settings can affect if IntelliJ will use wildcard imports in the Java file:

Next, let’s take a closer look at them.

4. The General Switch – “Use single class import”

The first checkbox, “Use single class import” is the general switch to specify if we want to enable wildcard import or not in Java source files. If we don’t check this option, IntelliJ always uses wildcard imports.

Let’s say a Java file only has two import statements:

import java.time.Instant;
import java.util.ArrayList;

If we don’t check the “Use single class import” option and let IntelliJ “Optimize Imports” for us. The two imports above turn into this:

import java.time.*;
import java.util.*;

So, we should check the “Use single class import” option if we want to disable wildcard imports in Java source files.

5. The “Class count to use import with ‘'”* Option

Next, let’s look at the “Class count to use import with ‘*’” configuration. We can set the value of this option to a desired number. IntelliJ automatically switches from explicit imports to wildcard imports when the number of imported classes exceeds the given value.

Consider the imports in one of our Java files:

import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

Let’s say we have these two settings in IntelliJ:

“Use single class import” option – Checked
“Class count to use import with ‘*’” – 5

Now, if we ask IntelliJ to optimize imports automatically, we’ll see the following:

import java.time.Instant;
import java.util.*;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

As we can see since we have imported more than five classes from the java.util package, the import statements become java.util.*.

So, if we want to disable the wildcard imports, we can set the value of “Class count to use import with ‘*’” to a large number, such as 100 or even 999.

6. Exceptions: the “Packages to Use Imports with ‘’*” Table

Finally, let’s look at the “Packages to Use Imports with ‘*’” table. The table allows us to add packages that always use wildcard imports no matter if we checked the “Use single class import” option or which number we set for the “Class count to use import with ‘*’” configuration.

Let’s say we have the following settings in IntelliJ:

“Use single class import” option – Checked
“Class count to use import with ‘*’” – 100
“Packages to Use Imports with ‘*”‘ – java.util.* (with sub-packages)

Now, if we optimize the imports of the Java file in the previous section, we will get the following:

import java.time.Instant;
import java.util.*;
import java.util.function.*;
import java.util.stream.*;

Since we have the “java.util.*” entry in the “Packages to Use Imports with ‘*” table, IntelliJ uses wildcard imports for any classes in the java.util package.

Therefore, the table should be empty if we want to disable wildcard imports completely.

7. Imports Configuration Using .editorconfig File

IntelliJ IDEA allows us to manage all code style settings for different types of files with EditorConfig support.

Create a .editorconfig file in the root directory with the following content:

[*.java] 
ij_java_use_single_class_imports = true 
ij_java_class_count_to_use_import_on_demand = 100 
ij_java_names_count_to_use_import_on_demand = 100 
ij_java_packages_to_use_import_on_demand = java.awt.*,javax.swing.*

Now, when you use IntelliJ IDEA’s Optimize Imports feature, the imports in .java files will be optimized according to this configuration.