Built-in Packages

Built-in packages are collections of predefined classes and interfaces provided by Java to handle common programming tasks such as language fundamentals, collections, I/O, networking, date/time, concurrency, and databases. They form the Java Standard Library and are available out of the box. This is a frequent interview topic, often asked alongside import, packages, and API usage.

Why Built-in Packages Exist

• Avoid reinventing common functionality
• Provide reliable, optimized implementations
• Promote standardization across Java programs
• Speed up development and reduce bugs

Most Important Built-in Packages (Must-Know)

1. java.lang — Core Language Support

Automatically imported (no import needed)

Common classes:

• Object
• String, StringBuilder, StringBuffer
• Math
• System
• Exception, RuntimeException
• Wrapper classes (Integer, Double, etc.)

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

2. java.util — Utilities & Collections

Used for data structures and utilities

Common classes/interfaces:

• List, ArrayList, LinkedList
• Set, HashSet
• Map, HashMap
• Iterator
• Collections, Arrays
• Scanner

import java.util.*;

List<Integer> list = new ArrayList<>();
          

3. java.io — Input / Output (File-based, Stream-based)

Used for file handling and byte/character streams

Common classes:

• File
• FileReader, FileWriter
• InputStream, OutputStream
• BufferedReader, BufferedWriter

import java.io.*;

File file = new File("data.txt");
          

4. java.nio — New I/O (Non-blocking, Faster I/O)

Introduced for high-performance I/O

Key features:

• Buffers
• Channels
• Paths & Files API

import java.nio.file.*;

Path p = Paths.get("data.txt");
          

5. java.sql — Database Connectivity (JDBC)

Used for database operations

Common interfaces/classes:

• Connection
• Statement, PreparedStatement
• ResultSet
• DriverManager

import java.sql.*;

Connection con = DriverManager.getConnection(url, user, pwd);
          

6. java.time — Date & Time API (Java 8+)

Modern replacement for Date and Calendar

Common classes:

• LocalDate
• LocalTime
• LocalDateTime
• Period, Duration

import java.time.*;

LocalDate today = LocalDate.now();
          

7. java.net — Networking

Used for network programming

Common classes:

• URL
• URLConnection
• Socket
• ServerSocket

import java.net.*;

URL url = new URL("https://example.com");
          

8. java.util.concurrent — Multithreading Utilities

Used for high-level concurrency

Common classes:

• ExecutorService
• Executors
• Future
• Callable
• ConcurrentHashMap

import java.util.concurrent.*;

ExecutorService ex = Executors.newFixedThreadPool(2);
          

9. java.math — High-Precision Arithmetic

Used for financial and scientific calculations

Classes:

• BigInteger
• BigDecimal

import java.math.*;

BigDecimal bd = new BigDecimal("123.45");
          

Package Import Rules (Quick Recap)

• java.lang → auto-imported
• Other packages → must be imported explicitly
• Wildcard imports do not import sub-packages

import java.util.*;   // only util, not util.concurrent
          

Built-in Packages Summary Table (Interview-Friendly)

Common Beginner Mistakes

• Forgetting imports (except java.lang)
• Using old Date instead of java.time
• Overusing wildcard imports
• Confusing java.io with java.nio
• Not closing I/O or DB resources

Interview-Ready Answers

Short Answer

Built-in packages are predefined Java packages that provide commonly used classes and interfaces.

Detailed Answer

Java provides built-in packages such as java.lang, java.util, java.io, java.sql, and java.time to handle core language features, collections, I/O, databases, and date/time operations. These packages help developers write efficient, standardized, and maintainable code.

Built-in Package Examples (Quick Practice)

1. java.lang – String (Auto-Imported)

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

Output

JAVA

2. java.lang – Math Class

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

Output

20
4.0
          

3. java.lang – Wrapper Classes

class Demo {
    public static void main(String[] args) {
        Integer x = Integer.parseInt("100");
        System.out.println(x + 50);
    }
}
          

Output

150

4. java.util – ArrayList

import java.util.ArrayList;

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

Output

[Java, Selenium]

5. java.util – HashSet

import java.util.HashSet;

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

Output

[10]

6. java.util – HashMap

import java.util.HashMap;

class Demo {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "API");
        System.out.println(map.get(1));
    }
}
          

Output

Java

7. java.util – Iterator

import java.util.ArrayList;
import java.util.Iterator;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");

        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}
          

Output

A
B
          

8. java.util – Collections Utility Class

import java.util.*;

class Demo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(3, 1, 2);
        Collections.sort(list);
        System.out.println(list);
    }
}
          

Output

[1, 2, 3]

9. java.util – Date

import java.util.Date;

class Demo {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d);
    }
}
          

Output

(Current date & time)

10. java.util – Scanner (User Input)

import java.util.Scanner;

class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        System.out.println(x * 2);
    }
}
          

Explanation

Reads input from console

11. java.io – File Class

import java.io.File;

class Demo {
    public static void main(String[] args) {
        File f = new File("test.txt");
        System.out.println(f.exists());
    }
}
          

Output

false   // if file not present

12. java.io – FileInputStream (Checked Exception)

import java.io.FileInputStream;

class Demo {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("test.txt");
        } catch (Exception e) {
            System.out.println("File not found");
        }
    }
}
          

Output

File not found

13. java.nio.file – Files API (Modern IO)

import java.nio.file.Files;
import java.nio.file.Paths;

class Demo {
    public static void main(String[] args) throws Exception {
        boolean exists = Files.exists(Paths.get("test.txt"));
        System.out.println(exists);
    }
}
          

14. java.time – LocalDate

import java.time.LocalDate;

class Demo {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        System.out.println(today);
    }
}
          

Output

YYYY-MM-DD

15. java.time – LocalDateTime

import java.time.LocalDateTime;

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

16. java.sql – SQLException (Exception Example)

import java.sql.SQLException;

class Demo {
    static void connect() throws SQLException {
        throw new SQLException("DB error");
    }

    public static void main(String[] args) {
        try {
            connect();
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
}
          

Output

DB error

17. java.net – URL Class

import java.net.URL;

class Demo {
    public static void main(String[] args) throws Exception {
        URL url = new URL("https://example.com");
        System.out.println(url.getHost());
    }
}
          

Output

example.com

18. java.util.concurrent – Thread Pool

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class Demo {
    public static void main(String[] args) {
        ExecutorService ex = Executors.newSingleThreadExecutor();
        ex.execute(() -> System.out.println("Task running"));
        ex.shutdown();
    }
}
          

Output

Task running

19. java.lang.System – System Properties

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

20. Interview Summary – Built-in Packages

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

class Demo {
    public static void main(String[] args) {
        System.out.println(LocalDate.now());
        System.out.println(new ArrayList<>());
    }
}
          

Key Points

• java.lang → auto-imported
• java.util → collections & utilities
• java.io / java.nio → file handling
• java.time → modern date/time
• java.sql → database support

Key Takeaway

Built-in packages are the backbone of Java development. Mastering them allows you to write powerful applications faster, cleaner, and more reliably.