Modern Java Features Every Fresher Should Know (Java 11 to 21)

Many freshers learn Java from tutorials that stop at Java 8. Then they join a team or sit in an interview and see code that uses record, var, switch with arrows, or text blocks, and they freeze. Modern Java is not a different language. It’s the same Java with features that remove boilerplate and make code safer and shorter. And because Spring Boot 3 requires Java 17 or higher, these features show up in real projects far more often than before.

If you’ve been searching for new features in Java 17 for freshers, Java 21 features interview questions, Java records explained, Java 8 vs Java 17 differences, what is a sealed class in Java, virtual threads in Java or Java LTS versions explained, this guide covers the features that matter, with old-way versus new-way code and a note on how likely each one is to come up in an interview.

FIRST, A QUICK MAP: JAVA VERSIONS AND LTS

Java releases a new version every six months. Some are LTS (Long-Term Support) releases that companies prefer to run in production.

Java 8   (LTS)  ── lambdas, streams, Optional          [you probably know this]

Java 8   (LTS)  ── lambdas, streams, Optional          [you probably know this]

Java 8   (LTS)  ── lambdas, streams, Optional          [you probably know this]

Feature versions above show when each feature became final (standard) in the language. Some appeared earlier as previews. Details can change, so confirm against the official Java documentation for your version.

What Freshers Should Prioritise: An Illustrative View

This is an illustrative guide, not data. It shows how likely each topic is to come up for fresher roles

Rule: master Java 8 first. Then add the features below one by one.

FEATURE 1: var (LOCAL VARIABLE TYPE INFERENCE), JAVA 10

What it does: lets the compiler infer the type of a local variable from the right-hand side.

Old way

java

Map<String, List<Integer>> marks = new HashMap<String, List<Integer>>();

Map<String, List<Integer>> marks = new HashMap<String, List<Integer>>();

Map<String, List<Integer>> marks = new HashMap<String, List<Integer>>();

New way

java

var marks = new HashMap<String, List<Integer>>();

var marks = new HashMap<String, List<Integer>>();

var marks = new HashMap<String, List<Integer>>();

Rules to remember

• Works only for local variables with an initialiser, not for fields or method parameters

• The type is still fixed at compile time. Java is still statically typed.

• var x; without a value is not allowed, and var x = null; is not allowed

Use when: the type is obvious from the right side. Avoid it when it makes the code unclear.

Interview chance: often. Typical question: “Does var make Java dynamically typed?” Answer: No, the compiler infers a fixed type at compile time.

FEATURE 2: HANDY STRING METHODS, JAVA 11

java

String s = "   Java  ";

System.out.println(s.isBlank());        // false
System.out.println(s.strip());          // "Java"
System.out.println("ab".repeat(3));     // ababab
"line1\nline2".lines().forEach(System.out::println);

String s = "   Java  ";

System.out.println(s.isBlank());        // false
System.out.println(s.strip());          // "Java"
System.out.println("ab".repeat(3));     // ababab
"line1\nline2".lines().forEach(System.out::println);

String s = "   Java  ";

System.out.println(s.isBlank());        // false
System.out.println(s.strip());          // "Java"
System.out.println("ab".repeat(3));     // ababab
"line1\nline2".lines().forEach(System.out::println);

Interview chance: sometimes, usually as “difference between trim() and strip()” or “isEmpty() vs isBlank()”.

FEATURE 3: IMMUTABLE COLLECTIONS FACTORY METHODS, JAVA 9

Old way

java

List<String> list = new ArrayList<>();
list.add("Java");
list.add("SQL");

List<String> list = new ArrayList<>();
list.add("Java");
list.add("SQL");

List<String> list = new ArrayList<>();
list.add("Java");
list.add("SQL");

New way

java

List<String> list = List.of("Java", "SQL");
Set<Integer> nums = Set.of(1, 2, 3);
Map<String, Integer> map = Map.of("A", 1, "B", 2);

List<String> list = List.of("Java", "SQL");
Set<Integer> nums = Set.of(1, 2, 3);
Map<String, Integer> map = Map.of("A", 1, "B", 2);

List<String> list = List.of("Java", "SQL");
Set<Integer> nums = Set.of(1, 2, 3);
Map<String, Integer> map = Map.of("A", 1, "B", 2);

Remember: these collections are immutable. Calling add() or put() throws UnsupportedOperationException. List.of also doesn’t allow null elements.

Interview chance: often, especially the immutability trap.

FEATURE 4: TEXT BLOCKS, JAVA 15

What it does: lets you write multi-line strings cleanly using triple quotes.

Old way

java

String json = "{\n" +
              "  \"name\": \"Amit\",\n" +
              "  \"course\": \"Java\"\n" +
              "}";

String json = "{\n" +
              "  \"name\": \"Amit\",\n" +
              "  \"course\": \"Java\"\n" +
              "}";

String json = "{\n" +
              "  \"name\": \"Amit\",\n" +
              "  \"course\": \"Java\"\n" +
              "}";

New way

java

String json = """
        {
          "name": "Amit",
          "course": "Java"
        }
        """;

String json = """
        {
          "name": "Amit",
          "course": "Java"
        }
        """;

String json = """
        {
          "name": "Amit",
          "course": "Java"
        }
        """;

Where it helps: SQL queries, JSON, HTML snippets and long messages.

java

String query = """
        SELECT id, name
        FROM students
        WHERE course = 'Java'
        ORDER BY name
        """;

String query = """
        SELECT id, name
        FROM students
        WHERE course = 'Java'
        ORDER BY name
        """;

String query = """
        SELECT id, name
        FROM students
        WHERE course = 'Java'
        ORDER BY name
        """;

Interview chance: sometimes.

FEATURE 5: SWITCH EXPRESSIONS, JAVA 14

Old way

java

int day = 3;
String name;
switch (day) {
    case 1: name = "Mon"; break;
    case 2: name = "Tue"; break;
    case 3: name = "Wed"; break;
    default: name = "Other";
}

int day = 3;
String name;
switch (day) {
    case 1: name = "Mon"; break;
    case 2: name = "Tue"; break;
    case 3: name = "Wed"; break;
    default: name = "Other";
}

int day = 3;
String name;
switch (day) {
    case 1: name = "Mon"; break;
    case 2: name = "Tue"; break;
    case 3: name = "Wed"; break;
    default: name = "Other";
}

New way

java

int day = 3;
String name = switch (day) {
    case 1 -> "Mon";
    case 2 -> "Tue";
    case 3 -> "Wed";
    default -> "Other";
};

int day = 3;
String name = switch (day) {
    case 1 -> "Mon";
    case 2 -> "Tue";
    case 3 -> "Wed";
    default -> "Other";
};

int day = 3;
String name = switch (day) {
    case 1 -> "Mon";
    case 2 -> "Tue";
    case 3 -> "Wed";
    default -> "Other";
};

Key differences

• Uses -> instead of : and no fall-through

• It’s an expression: it returns a value

• Multiple labels allowed: case 6, 7 -> "Weekend";

• For multi-line blocks, return a value with yield

java

String type = switch (day) {
    case 6, 7 -> "Weekend";
    default -> {
        String temp = "Week";
        yield temp + "day";
    }
};

String type = switch (day) {
    case 6, 7 -> "Weekend";
    default -> {
        String temp = "Week";
        yield temp + "day";
    }
};

String type = switch (day) {
    case 6, 7 -> "Weekend";
    default -> {
        String temp = "Week";
        yield temp + "day";
    }
};

Interview chance: often, as it fixes the classic “switch fall-through” trap.

FEATURE 6: RECORDS, JAVA 16

What it does: creates a simple, immutable data carrier class with very little code.

Old way (a plain data class)

java

public class Student {
    private final String name;
    private final int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() { return name; }
    public int getAge() { return age; }

    @Override public boolean equals(Object o) { /* ... */ }
    @Override public int hashCode() { /* ... */ }
    @Override public String toString() { /* ... */ }
}

public class Student {
    private final String name;
    private final int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() { return name; }
    public int getAge() { return age; }

    @Override public boolean equals(Object o) { /* ... */ }
    @Override public int hashCode() { /* ... */ }
    @Override public String toString() { /* ... */ }
}

public class Student {
    private final String name;
    private final int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() { return name; }
    public int getAge() { return age; }

    @Override public boolean equals(Object o) { /* ... */ }
    @Override public int hashCode() { /* ... */ }
    @Override public String toString() { /* ... */ }
}

New way

java

public record Student(String name, int age) { }

public record Student(String name, int age) { }

public record Student(String name, int age) { }

What you get automatically

• A constructor

• Accessor methods named name() and age() (not getName())

• equals(), hashCode() and toString()

• All fields are private final (immutable)

java

Student s = new Student("Amit", 22);
System.out.println(s.name());   // Amit
System.out.println(s);          // Student[name=Amit, age=22]

Student s = new Student("Amit", 22);
System.out.println(s.name());   // Amit
System.out.println(s);          // Student[name=Amit, age=22]

Student s = new Student("Amit", 22);
System.out.println(s.name());   // Amit
System.out.println(s);          // Student[name=Amit, age=22]

Validation using a compact constructor

java

public record Student(String name, int age) {
    public Student {
        if (age < 0) throw new IllegalArgumentException("Age cannot be negative");
    }
}

public record Student(String name, int age) {
    public Student {
        if (age < 0) throw new IllegalArgumentException("Age cannot be negative");
    }
}

public record Student(String name, int age) {
    public Student {
        if (age < 0) throw new IllegalArgumentException("Age cannot be negative");
    }
}

Limits to remember

• A record can’t extend another class (it implicitly extends java.lang.Record) but can implement interfaces

• Fields are final, so there are no setters

• Great for DTOs, API responses and value objects

Interview chance: often. Typical questions: “What is a record?”, “Record vs class?”, “Can a record have setters?”

FEATURE 7: PATTERN MATCHING FOR instanceof, JAVA 16

Old way

java

if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

New way

java

if (obj instanceof String s) {
    System.out.println(s.length());
}

if (obj instanceof String s) {
    System.out.println(s.length());
}

if (obj instanceof String s) {
    System.out.println(s.length());
}

The cast disappears. The variable s is available inside the if branch where the check is true.

Interview chance: sometimes.

FEATURE 8: SEALED CLASSES, JAVA 17

What it does: lets you control which classes are allowed to extend or implement a type.

java

public sealed interface Shape permits Circle, Rectangle { }

public record Circle(double radius) implements Shape { }
public record Rectangle(double width, double height) implements Shape { }

public sealed interface Shape permits Circle, Rectangle { }

public record Circle(double radius) implements Shape { }
public record Rectangle(double width, double height) implements Shape { }

public sealed interface Shape permits Circle, Rectangle { }

public record Circle(double radius) implements Shape { }
public record Rectangle(double width, double height) implements Shape { }

Rules

• Use sealed and permits to list the allowed subtypes

• Each permitted subclass must be final, sealed or non-sealed

• Records are implicitly final, so they work nicely as permitted subtypes

Why it matters: the compiler knows every possible subtype, which makes switch handling safer (see the next feature).

Interview chance: sometimes. Typical question: “What is a sealed class and why use it?”

FEATURE 9: PATTERN MATCHING FOR switch, JAVA 21

What it does: lets switch match on types and extract values in one step

java

static double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.width() * r.height();
    };
}

static double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.width() * r.height();
    };
}

static double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.width() * r.height();
    };
}

Because Shape is sealed and only has two permitted subtypes, the compiler can check that the switch covers all cases, so no default is needed.

Record patterns (Java 21) also let you deconstruct a record directly:

java

static String describe(Object obj) {
    return switch (obj) {
        case Circle(double r) -> "Circle with radius " + r;
        case Rectangle(double w, double h) -> "Rectangle " + w + " x " + h;
        default -> "Unknown shape";
    };
}

static String describe(Object obj) {
    return switch (obj) {
        case Circle(double r) -> "Circle with radius " + r;
        case Rectangle(double w, double h) -> "Rectangle " + w + " x " + h;
        default -> "Unknown shape";
    };
}

static String describe(Object obj) {
    return switch (obj) {
        case Circle(double r) -> "Circle with radius " + r;
        case Rectangle(double w, double h) -> "Rectangle " + w + " x " + h;
        default -> "Unknown shape";
    };
}

Interview chance: sometimes, and growing.

FEATURE 10: Stream.toList(), JAVA 16

Old way

java

List<String> names = students.stream()
        .map(Student::name)
        .collect(Collectors.toList());

List<String> names = students.stream()
        .map(Student::name)
        .collect(Collectors.toList());

List<String> names = students.stream()
        .map(Student::name)
        .collect(Collectors.toList());

New way

java

List<String> names = students.stream()
        .map(Student::name)
        .toList();

List<String> names = students.stream()
        .map(Student::name)
        .toList();

List<String> names = students.stream()
        .map(Student::name)
        .toList();

Remember: toList() returns an unmodifiable list, while Collectors.toList() returns a modifiable one (the exact type isn’t guaranteed).

FEATURE 11: SEQUENCED COLLECTIONS, JAVA 21

What it does: adds methods to access the first and last elements and to reverse collections that have a defined order

java

List<String> list = new ArrayList<>(List.of("A", "B", "C"));

System.out.println(list.getFirst());   // A
System.out.println(list.getLast());    // C
System.out.println(list.reversed());   // [C, B, A]

List<String> list = new ArrayList<>(List.of("A", "B", "C"));

System.out.println(list.getFirst());   // A
System.out.println(list.getLast());    // C
System.out.println(list.reversed());   // [C, B, A]

List<String> list = new ArrayList<>(List.of("A", "B", "C"));

System.out.println(list.getFirst());   // A
System.out.println(list.getLast());    // C
System.out.println(list.reversed());   // [C, B, A]

Before Java 21, you’d write list.get(0) and list.get(list.size() - 1).

FEATURE 12: VIRTUAL THREADS, JAVA 21

What they are: very lightweight threads managed by the JVM, designed to let you handle a huge number of concurrent tasks (especially waiting on I/O such as network or database calls) without the cost of traditional platform threads.

Start one

java

Thread.ofVirtual().start(() -> System.out.println("Hello from a virtual thread"));

Thread.ofVirtual().start(() -> System.out.println("Hello from a virtual thread"));

Thread.ofVirtual().start(() -> System.out.println("Hello from a virtual thread"));

Use an executor

java

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 5; i++) {
        int id = i;
        executor.submit(() -> System.out.println("Task " + id));
    }
}

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 5; i++) {
        int id = i;
        executor.submit(() -> System.out.println("Task " + id));
    }
}

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 5; i++) {
        int id = i;
        executor.submit(() -> System.out.println("Task " + id));
    }
}

Key points to remember

• They’re cheap to create, so you can run very many

• They shine for blocking I/O workloads, not CPU-heavy computation

• You write simple, blocking-style code instead of complex asynchronous code

Interview chance: sometimes, usually as “What are virtual threads?” or “Platform thread vs virtual thread?”

QUICK COMPARISON: JAVA 8 VS JAVA 17/21 STYLE

WHERE THESE FEATURES SHOW UP IN SPRING BOOT PROJECTS

• Records as DTOs: request and response objects with little code

• Text blocks: SQL queries and JSON samples in tests

• Switch expressions: mapping status or type to behaviour cleanly

• var: shorter local variables in service code

• Java 17 baseline: Spring Boot 3 requires Java 17 or higher, so modern syntax is usable everywhere

Example: a record as a response DTO

java

public record StudentResponse(Long id, String name, String course) { }

@GetMapping("/{id}")
public StudentResponse getStudent(@PathVariable Long id) {
    Student s = service.findById(id);
    return new StudentResponse(s.getId(), s.getName(), s.getCourse());
}

public record StudentResponse(Long id, String name, String course) { }

@GetMapping("/{id}")
public StudentResponse getStudent(@PathVariable Long id) {
    Student s = service.findById(id);
    return new StudentResponse(s.getId(), s.getName(), s.getCourse());
}

public record StudentResponse(Long id, String name, String course) { }

@GetMapping("/{id}")
public StudentResponse getStudent(@PathVariable Long id) {
    Student s = service.findById(id);
    return new StudentResponse(s.getId(), s.getName(), s.getCourse());
}

MYTH VS REALITY

DIAGNOSTIC TABLE: IF THIS HAPPENS, CHECK THIS

CHECK YOURSELF: 5-QUESTION MINI QUIZ

Q1. What does var x = "Java"; infer the type of x as?
Q2. What accessor does record Student(String name) generate for name?
Q3. What happens if you call add() on a list created with List.of("A")?
Q4. Does an arrow-style switch fall through to the next case?
Q5. Which kind of work do virtual threads suit best?

Answers

1. String, fixed at compile time.

2. name(), not getName().

3. It throws UnsupportedOperationException.

4. No, there is no fall-through.

5. Many concurrent I/O-bound tasks.

A 7-DAY PLAN TO LEARN MODERN JAVA

HOW VIBRANTMINDS HELPS YOU LEARN MODERN JAVA

VibrantMinds Technologies Pvt. Ltd. trains freshers in Pune on Java in a way that connects fundamentals to what projects and interviews use today.

• Core Java and Full Stack Java training: The Core Java course (about 1 to 2 months) and the Full Stack Java Development programme (about 4 to 6 months) cover syntax, OOP, collections, exceptions, strings, JDBC, SQL, Spring Boot and REST APIs. Please check the candidate portal for the latest syllabus and the Java version used.

• Project work: Applying new features, such as records for DTOs, inside a Spring Boot project makes them stick.

• Aptitude, communication and interview preparation are part of the programme, so you can explain what you’ve learned.

• Placement support: The placement pipeline includes screening, drive coordination and interview support. Check the campus-drives portal at https://candidates.vibrantminds.in/ for current openings.

• Honesty first: VibrantMinds offers placement support, not a guaranteed job, and no legitimate recruiter should ask you to pay to be interviewed.

VibrantMinds works as a talent ecosystem connecting candidates, colleges and companies, with 1900+ partner colleges and 600+ hiring companies. Learn more on the official website: https://vibrantminds.in/

VIBRANTMINDS COURSES AT A GLANCE

Fees, syllabus and batch dates are on https://candidates.vibrantminds.in/. Please confirm them directly before enrolling.

THE VIBRANTMINDS PLACEMENT PIPELINE: SIX STEPS

REAL OUTCOMES: WHAT TO EXPECT AND WHAT NOT TO

Past students have shared positive feedback about the training and support, and have gone on to roles at companies such as Aress Software and Education Technologies, Saama Technologies and Three M Software. Results vary by candidate, skill level, effort and market conditions, so please confirm details directly with the VibrantMinds team. No one can honestly promise a guaranteed job.

JOIN THE VIBRANTMINDS WHATSAPP GROUPS FOR FRESHER JOB AND DRIVE ALERTS

Fresher openings, campus drives and walk-in interviews are shared here as they come in. Join whichever group has space; all three carry the same type of updates.

• VibrantMinds Fresher IT Jobs, Group 1: https://chat.whatsapp.com/CUCS1derlmTFee2c9dyUHd

• VibrantMinds Fresher IT Jobs, Group 2: https://chat.whatsapp.com/FvMf1fGYQYnHppQ8AwFX40

• VibrantMinds Fresher IT Jobs, Group 3: https://chat.whatsapp.com/I7RNnGMkb2L8S8HibdyWpQ

Never pay to apply. Legitimate recruiters do not charge candidates for tests, interviews or offer letters. Do not share sensitive personal or financial details in any group chat.

VISIT OR CONTACT VIBRANTMINDS IN PUNE

• Company: VibrantMinds Technologies Pvt. Ltd.

• Address: Viva Academy Building, Warje, Pune, Maharashtra 411052

• Phone: +91 95035 79517

• Email: support@vibrantmindstech.com

• Website: https://vibrantminds.in/

• Candidate portal and courses: https://candidates.vibrantminds.in/

FREQUENTLY ASKED QUESTIONS

What are the new features in Java 17 that freshers should know?
The most important ones are records, sealed classes, pattern matching for instanceof, switch expressions, text blocks and var. Several of these arrived in versions between 10 and 17 and are standard in Java 17.

What is a record in Java?
A record is a compact way to declare an immutable data class. The compiler generates the constructor, accessor methods, equals(), hashCode() and toString() for you.

What is the difference between a record and a normal class?
A record is designed for immutable data carriers with automatically generated members, and its fields are final. A normal class gives you full control and can hold mutable state and complex behaviour.

Does var make Java dynamically typed?
No. var only lets the compiler infer the type of a local variable at compile time, and the type stays fixed.

What is a sealed class in Java?
A sealed class or interface restricts which classes can extend or implement it using the permits clause, which helps the compiler check that switch statements cover all cases.

What are virtual threads in Java 21?
Virtual threads are lightweight threads managed by the JVM that let applications handle very large numbers of concurrent, mostly I/O-bound tasks with simple blocking-style code.

Which Java version should a fresher learn?
Learn Java 8 fundamentals first, then practise on a modern LTS such as 17 or 21, because many current projects and Spring Boot 3 use Java 17 or higher. Check which LTS is current when you start.

Is Java 8 still asked in interviews?
Yes. Lambdas, streams and Optional remain very common interview topics, while newer features appear increasingly as follow-ups.

What is an LTS version of Java?
LTS stands for Long-Term Support. These releases receive updates for longer periods and are preferred by many companies for production use. Java 8, 11, 17 and 21 are well-known LTS versions.

Does VibrantMinds teach modern Java?
VibrantMinds offers Core Java and Full Stack Java training with Spring Boot, REST APIs and project work, along with interview preparation and placement support. Please confirm the exact Java version and syllabus on the candidate portal. VibrantMinds does not guarantee a job.

FINAL CHECKLIST

• ☐ I know my Java version and which features it supports

• ☐ I can explain var, records and switch expressions with an example

• ☐ I know that List.of creates immutable collections

• ☐ I can describe sealed classes and virtual threads in two sentences each

• ☐ I’ve used at least one new feature in a real project

• ☐ I still revise Java 8, OOP and collections first

Modern Java won’t replace the fundamentals, but knowing it shows interviewers that you’re learning the language as it is used today. Start with var, records and switch expressions, use them in a Spring Boot project, and add the rest over time. If you’re in Pune and want guided Java training with placement support, visit https://vibrantminds.in/, check the candidate portal at https://candidates.vibrantminds.in/, and join the WhatsApp groups above for the next drive.