← Back to Home

import Statement

The import statement in Java is used to make classes and interfaces from other packages accessible in the current source file without using their fully qualified names. It improves readability, maintainability, and developer productivity. This is a high-frequency interview topic, closely tied to packages and access control.

What Is the import Statement?

Allows access to classes from other packages
Eliminates need for fully qualified names
Used at compile time
Improves code clarity

import packageName.ClassName;

Why import Is Needed

Without import:

java.util.ArrayList list = new java.util.ArrayList();

With import:

import java.util.ArrayList;
ArrayList list = new ArrayList();

✔ Cleaner and more readable

Where import Statement Is Written

After package statement
Before class definition

package com.example.app;
import java.util.List;
import java.util.ArrayList;
public class Test { }

Types of import Statements

1️⃣ Single-Class Import

Imports one specific class.

import java.util.ArrayList;

✔ Most preferred
✔ Avoids ambiguity

2️⃣ Wildcard Import (*)

Imports all classes from a package.

import java.util.*;

⚠️ Does not import sub-packages
⚠️ May reduce readability

3️⃣ Static Import (Preview)

Imports static members of a class.

import static java.lang.Math.sqrt;
double r = sqrt(16);

✔ Used for constants and utility methods

Automatic Import (java.lang)

All classes in java.lang are automatically imported.

String s = "Java";
System.out.println(s);

✔ No import required

import vs Fully Qualified Name

Aspect	import	Fully Qualified Name
Readability	High	Low
Usage	Preferred	Rare
Scope	Whole file	Single usage
Performance	Same	Same

✔ import does not impact performance

Import and Name Conflicts (Interview Favorite)

import java.util.Date;
import java.sql.Date;

❌ Compile-time error: ambiguous reference

Solution 1: Use Fully Qualified Name

java.util.Date d = new java.util.Date();

Solution 2: Import One, Qualify the Other

import java.util.Date;
java.sql.Date d2 = new java.sql.Date();

Multiple Imports in a File

✔ Allowed
✔ Order does not matter

import java.util.List;
import java.util.Map;

Importing User-Defined Packages

import com.mycompany.util.MathUtil;

✔ Same rules apply as built-in packages

Common Beginner Mistakes

Forgetting import statement
Assuming wildcard imports include sub-packages
Importing unused classes
Confusing static import with normal import
Thinking imports increase runtime memory usage

Interview-Ready Answers

Short Answer

The import statement allows access to classes from other packages without using fully qualified names.

Detailed Answer

In Java, the import statement is used to make classes and interfaces from other packages available in the current source file. It improves code readability and is processed at compile time. The java.lang package is imported automatically.

Import Statement Examples (1 to 20)

1. Importing a Single Class

import java.util.ArrayList;

class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        System.out.println(list);
    }
}

Explanation

Imports only ArrayList
Most recommended style

2. Importing Multiple Classes Explicitly

import java.util.ArrayList;
import java.util.HashMap;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        HashMap<Integer, String> map = new HashMap<>();
        System.out.println("OK");
    }
}

3. Wildcard Import (*)

import java.util.*;

class Demo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Set<Integer> set = new HashSet<>();
        System.out.println(list + " " + set);
    }
}

Explanation

Imports all public classes in the package
Does not include sub-packages

4. Wildcard Import Does NOT Import Sub-Packages

import java.util.*;
// import java.util.concurrent.*; // needed separately

class Demo {
    public static void main(String[] args) {
        System.out.println("Compile error if concurrent classes used");
    }
}

5. Fully Qualified Name (No import)

class Demo {
    public static void main(String[] args) {
        java.util.ArrayList<String> list = new java.util.ArrayList<>();
        System.out.println(list);
    }
}

Explanation

Avoids import
Used to resolve name conflicts

6. Import Conflict – Same Class Name

import java.util.Date;
import java.sql.Date; // ❌ conflict

class Demo {
    public static void main(String[] args) {
        // Date d = new Date(); // ambiguous
    }
}

7. Resolving Import Conflict Using Fully Qualified Name

import java.util.Date;

class Demo {
    public static void main(String[] args) {
        Date d1 = new Date();
        java.sql.Date d2 = new java.sql.Date(System.currentTimeMillis());
        System.out.println(d1);
        System.out.println(d2);
    }
}

8. Static Import – Single Member

import static java.lang.Math.sqrt;

class Demo {
    public static void main(String[] args) {
        System.out.println(sqrt(25));
    }
}

Output

5.0

9. Static Import – Multiple Members

import static java.lang.Math.max;
import static java.lang.Math.min;

class Demo {
    public static void main(String[] args) {
        System.out.println(max(10, 20));
        System.out.println(min(10, 20));
    }
}

10. Static Wildcard Import

import static java.lang.Math.*;

class Demo {
    public static void main(String[] args) {
        System.out.println(pow(2, 3));
        System.out.println(abs(-10));
    }
}

11. Static Import from User-Defined Class

package util;

public class Constants {
    public static final int TIMEOUT = 30;
}

import static util.Constants.TIMEOUT;

class Demo {
    public static void main(String[] args) {
        System.out.println(TIMEOUT);
    }
}

12. Importing User-Defined Package Class

import com.app.util.MathUtil;

class Demo {
    public static void main(String[] args) {
        System.out.println(MathUtil.add(2, 3));
    }
}

13. Importing Same Package Classes (Not Required)

package com.demo;

class A {}

class B {
    A a; // no import needed
}

Explanation

Classes in the same package don’t need import

14. java.lang Package – No Import Needed

class Demo {
    public static void main(String[] args) {
        String s = "Java";
        System.out.println(s.length());
    }
}

Explanation

java.lang is auto-imported

15. Import Order (Convention)

import java.util.*;             // standard library
import com.app.util.Helper;     // user-defined
import static java.lang.Math.*; // static imports

Explanation

Improves readability
Follow industry standards

16. Importing Interface

import java.util.List;

class Demo {
    public static void main(String[] args) {
        List<String> list;
    }
}

17. Importing Abstract Class

import java.util.AbstractList;

class Demo {
    public static void main(String[] args) {
        System.out.println("Abstract class imported");
    }
}

18. Import Is Compile-Time Only

import java.util.ArrayList;

class Demo {
    public static void main(String[] args) {
        System.out.println("Import has no runtime impact");
    }
}

Explanation

Imports do not affect runtime behavior

19. Common Interview Trap

import java.util.*;

class Demo {
    public static void main(String[] args) {
        // Scanner sc; // OK
        // File f;     // ❌ File is in java.io, not java.util
    }
}

20. Interview Summary – import Statement

import java.util.List;
import static java.lang.Math.PI;

class Demo {
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

Key Points

Used to access classes without full names
Wildcard does not include sub-packages
static import imports members, not classes
java.lang needs no import
Import happens at compile time only

Key Takeaway

import improves readability, not performance. Use specific imports for clarity and avoid wildcard imports unless justified.