Beginner Java Interview Questions and Answers

• JVM (Java Virtual Machine): runs compiled Java bytecode, and JIT-compiles hot code to native machine code.
• JRE (Java Runtime Environment): the JVM plus the standard class libraries needed to run Java programs.
• JDK (Java Development Kit): the JRE plus development tools such as the javac compiler, javadoc and jar. You need the JDK to write Java programs.

Source (.java) is compiled by javac to bytecode (.class), which any JVM can run: "write once, run anywhere".

Java has 8 primitive types (byte, short, int, long, float, double, char, boolean), whose variables hold the value directly and cannot be null. Everything else (String, arrays, every class) is a reference type: the variable holds a reference to an object on the heap, can be null, and has methods.

Each primitive has a wrapper class (int → Integer) used where objects are required, such as in collections.

== compares values for primitives, but references (identity) for objects. equals() compares contents, as defined by the class.

public class Main {
    public static void main(String[] args) {
        String a = new String("java");
        String b = new String("java");
        System.out.println(a == b);
        System.out.println(a.equals(b));
    }
}

false
true

Always compare strings (and other objects) with equals.

A String's contents can never change; methods like toUpperCase() return a new string. Benefits:

• String pool: identical literals can share one object safely, saving memory.
• Security and reliability: values used as file names, URLs or map keys cannot be changed by other code.
• Thread safety: immutable objects can be shared between threads without locks.
• Cached hash codes: strings make fast, reliable HashMap keys.

Use StringBuilder to build strings in loops; StringBuffer is a legacy synchronized version.

A static member belongs to the class rather than to any object. A static field has one shared copy; a static method can be called on the class name (Math.max(2, 3)) without creating an object, but it cannot use instance fields or this. main is static so the JVM can call it before any object exists.

• final variable: can be assigned only once (for a reference, the variable cannot point elsewhere, but the object can still change).
• final method: cannot be overridden by subclasses.
• final class: cannot be extended (for example String).

• Overloading: same method name, different parameter lists, usually in the same class; chosen at compile time from the argument types.
• Overriding: a subclass provides its own implementation of an inherited method with the same signature; chosen at run time from the actual object (dynamic dispatch). Mark it with @Override.

Always pass by value. For primitives, the value is copied. For objects, the reference is copied, so a method can change the object's contents, but cannot make the caller's variable point to a different object.

import java.util.ArrayList;
import java.util.List;

public class Main {
    static void modify(List<String> list) {
        list.add("added");          // visible to the caller
        list = new ArrayList<>();   // only changes the local copy of the reference
        list.add("lost");
    }

    public static void main(String[] args) {
        List<String> items = new ArrayList<>();
        modify(items);
        System.out.println(items);
    }
}

[added]

Fields (class and instance variables) get default values: 0 for numeric types, 0.0 for double/float, false for boolean, '\u0000' for char, and null for references. Local variables get no default; the compiler rejects reading one before it is assigned.

public class Main {
    static boolean isPrime(int n) {
        if (n < 2) return false;
        for (int d = 2; (long) d * d <= n; d++) {
            if (n % d == 0) return false;
        }
        return true;
    }

    public static void main(String[] args) {
        for (int n : new int[] {1, 2, 17, 21, 97}) {
            System.out.println(n + (isPrime(n) ? " prime" : " not prime"));
        }
    }
}

1 not prime
2 prime
17 prime
21 not prime
97 prime

Checking divisors only up to √n makes it O(√n). The long cast prevents d * d from overflowing for large n.

Track the best value so far, or use a stream.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] v = {12, 45, 7, 89, 23};

        int largest = v[0];
        for (int x : v) {
            if (x > largest) largest = x;
        }
        System.out.println(largest + " " + Arrays.stream(v).max().getAsInt());
    }
}

89 89

Mention the empty-array case: v[0] throws, and max() returns an empty OptionalInt.