In Lecture 3 you learned to control the flow of a program with conditionals, switch expressions and loops. This lecture adds the three building blocks that every real Java program is made of: methods (named, reusable blocks of logic), arrays (fixed-size containers that hold many values of one type) and Strings (text, which is what almost all business data eventually becomes: names, addresses, JSON, SQL, log lines).

Open any production codebase, whether it is a Spring Boot microservice at a Bengaluru fintech, an Android app or a batch job at a bank, and you will find the same pattern everywhere: methods that accept parameters, work on arrays or collections, and build or parse strings. A controller method validates a request string, a service method computes totals over an array of amounts, and a repository method builds a query string. If you are weak on these fundamentals, every later topic (OOP, collections, streams, Spring) feels harder than it should.

These topics are also an interview favourite because they expose whether you really understand the JVM. Classic questions include: is Java pass-by-value or pass-by-reference? Why is String immutable? What is the difference between == and equals()? Why is StringBuilder faster inside a loop? What is the string pool? By the end of this lecture you will be able to answer all of them with confidence and with code.

We will go step by step: define methods, understand how arguments are passed, overload them, accept variable arguments, write recursive methods, then move to arrays and the Arrays helper class, and finally spend a large part of the lecture on Strings, because that is where beginners make the most expensive mistakes.

A method is a named block of code that performs one task. Instead of copying the same ten lines in five places, you write them once and call the method by name. The general form is: modifiers, then the return type, then the method name, then a parameter list in parentheses, then the body in braces.

• Return type — the type of value the method gives back, or void if it gives back nothing. A non-void method must end every path with a return statement of that type, otherwise the code does not compile.
• Parameters — typed variables declared in the parentheses. The values you pass when calling the method are called arguments. Parameter names are local to the method.
• Method signature — the method name plus the ordered list of parameter types. The return type and parameter names are not part of the signature. This matters for overloading, which we cover next.
• static — for now all our methods are static, which means they belong to the class and can be called without creating an object. Instance methods come in the next lecture on OOP.

Naming conventions: method names are verbs in camelCase such as calculateGst, isValidPan, findCustomerById. A good method does one thing, has a name that says what it does, and is short enough to read on one screen. Prefer early returns for guard conditions instead of deeply nested if blocks.

Calling a method pushes a new stack frame onto the call stack holding its parameters and local variables; when the method returns, the frame is discarded. This is why local variables of one method are invisible to another.

This is one of the most misunderstood topics in Java interviews, so let us be precise: Java is always pass-by-value. When you call a method, the value of each argument is copied into the parameter. There is no pass-by-reference in Java at all.

The confusion comes from what the "value" is:

• For a primitive (int, double, boolean, char...), the value is the number itself. The method gets a copy; changing the parameter never affects the caller's variable.
• For an object (arrays, Strings, your own classes), the variable holds a reference (think of it as the address of the object on the heap). The method receives a copy of that reference. Both the caller and the method now point to the same object, so if the method modifies the object's contents (for example sets arr[0] = 99), the caller sees the change. But if the method reassigns its parameter to a new object (arr = new int[5]), only the method's local copy of the reference changes; the caller's variable still points to the original object.

A simple mental model: the method gets a photocopy of your key, not your key. With the photocopy it can open your locker and rearrange things inside (modify the object), but if it throws the photocopy away and picks up another key (reassignment), your original key is unaffected.

This is also why a classic swap(int a, int b) method does nothing in Java, and why String parameters appear "unchangeable" inside methods: Strings are immutable, so there is nothing to modify in place, and reassigning the parameter is invisible to the caller.

Method overloading means defining several methods with the same name but different parameter lists in one class. The parameter lists must differ in the number, types or order of parameters. Changing only the return type is not overloading and will not compile, because the return type is not part of the signature.

Overloading is everywhere in the JDK: System.out.println has versions for int, double, char[], String, Object and more, so you never have to remember separate method names. Use it when the operation is conceptually the same and only the input differs.

How does the compiler choose? At compile time (not runtime) it looks for the most specific match in three phases: first exact matches and primitive widening (int to long to double), then autoboxing (int to Integer), and only then varargs. So print(5) with overloads print(long) and print(Integer) picks print(long). If two candidates are equally specific, you get an "ambiguous method call" compile error. A famous case is calling m(null) when both m(String) and m(Integer) exist.

Varargs (variable-length arguments, since Java 5) let a method accept zero or more values of one type with the syntax type... name. Inside the method the parameter is simply an array. Rules: a method can have only one varargs parameter and it must be the last parameter. String.format, List.of, Arrays.asList and most logging frameworks use varargs, which is why you can write List.of(1, 2, 3). Avoid overloading a varargs method with a single-argument version of the same type; the resolution rules become confusing for readers.

A recursive method is a method that calls itself. It solves a problem by reducing it to a smaller version of the same problem until it reaches a case so simple that the answer is known directly. Every correct recursive method has two parts:

• Base case — the condition that stops the recursion and returns a direct answer (for example, factorial of 0 is 1).
• Recursive case — the method calls itself with an input that moves closer to the base case (for example, n * factorial(n - 1)).

Each call creates a new stack frame, so a recursion that is 10,000 levels deep holds 10,000 frames at once. If you forget the base case, or the input never shrinks, the JVM throws a StackOverflowError. With the default thread stack size, even a simple recursive method usually fails after a few tens of thousands of nested calls, so recursion is not a tool for iterating over a million-element array. Use a loop for that.

Where recursion shines is naturally recursive data: directory trees, nested JSON, organisation charts, linked structures, and divide-and-conquer algorithms such as binary search, merge sort and quicksort. In those cases the recursive solution is shorter and clearer than the iterative one.

Watch out for exponential recursion. The naive Fibonacci implementation recomputes the same values millions of times; fib(45) takes seconds while the memoised version is instant. Memoisation (caching results in an array or map) turns exponential time into linear time. Interviewers love asking you to spot this.

An array is a fixed-size, ordered container of elements that all have the same type. Once created, its length can never change; if you need a growable list you will use ArrayList (covered in the Collections lecture). Arrays are objects that live on the heap, even when they hold primitives, so an array variable is a reference.

Three ways to create one:

• int[] marks = new int[5]; — five slots, each filled with the default value: 0 for numeric types, false for boolean, '\u0000' for char, and null for every reference type including String.
• int[] marks = {78, 92, 65}; — an array initialiser, allowed only at the point of declaration.
• marks = new int[]{78, 92, 65}; — the form you use when assigning later or passing an array as an argument.

Indexes start at 0 and end at length - 1. length is a field, not a method (compare String.length(), which is a method, and List.size()). Reading marks[5] on a five-element array throws ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5, which is probably the single most common runtime exception beginners see.

Iterate with a classic for loop when you need the index (to modify elements or print positions), and with the enhanced for loop (for (int m : marks)) when you only need the values. Note that assigning to the loop variable in an enhanced for loop does not change the array.

Because arrays are objects, int[] copy = marks; does not copy the data; both variables point at the same array. Use marks.clone() or Arrays.copyOf for a real copy. The style int marks[] is legal but discouraged; always write int[] marks so the type reads as "int array".

Java has no true matrix type; a two-dimensional array is simply an array of arrays. int[][] grid = new int[3][4]; creates one outer array holding three references, each pointing to an inner array of four ints. grid.length is the number of rows (3) and grid[0].length is the number of columns in row 0 (4). You access an element as grid[row][col], and you walk the whole thing with nested loops.

Because rows are independent arrays, they can have different lengths. Such a jagged array is created by allocating only the outer dimension (new int[3][]) and then assigning each row separately. This is handy for triangular data such as Pascal's triangle or a list of marks where each student took a different number of tests. Printing a 2D array directly gives something like [[I@1b6d3586; use Arrays.deepToString instead.

The java.util.Arrays class is a toolbox of static helper methods you will use daily:

• Arrays.toString(a) and Arrays.deepToString(a2d) — readable output.
• Arrays.sort(a) — in-place sort; a Dual-Pivot Quicksort for primitives and a stable TimSort for objects. Arrays.sort(a, from, to) sorts a range.
• Arrays.binarySearch(a, key) — O(log n) search, only on a sorted array; returns a negative insertion point when not found.
• Arrays.fill(a, value), Arrays.setAll(a, i -> i * i) — bulk initialisation.
• Arrays.copyOf(a, newLength) and Arrays.copyOfRange(a, from, to) — copies, padding with defaults if longer.
• Arrays.equals(a, b) and Arrays.deepEquals(a2d, b2d) — element-wise comparison; the inherited a.equals(b) only compares references.
• Arrays.asList(T...) — a fixed-size list view backed by the array (works for object arrays, not int[]), and Arrays.stream(a) — the entry point to the Stream API.

A String in Java is an object of the final class java.lang.String, and it is immutable: once created, its characters can never change. Every method that looks like it modifies a string (toUpperCase, replace, concat, substring, trim) actually returns a brand-new String and leaves the original untouched. Beginners write name.toUpperCase(); on its own line and wonder why nothing happened: you must assign the result, name = name.toUpperCase();.

Why did the designers choose immutability?

• Security — file paths, URLs, class names and database connection strings are passed as Strings. If they could be mutated after validation, a check could be bypassed.
• Thread safety — an object that cannot change can be shared between threads without locks.
• Hash caching — String caches its hashCode() after the first call, which makes it a fast and reliable HashMap key. That only works because the content cannot change.
• The string pool — immutability makes it safe for many variables to share one String object.

The string pool (also called the intern pool) is a special area on the heap where the JVM keeps one copy of each distinct string literal. When you write String a = "Java"; and later String b = "Java";, both variables point to the same pooled object, so a == b is true. But new String("Java") always creates a fresh object outside the pool, so a == c is false even though the contents are identical. Calling c.intern() returns the pooled instance. Since Java 7 the pool lives in the main heap (earlier it was in PermGen), and since Java 9 strings that contain only Latin-1 characters are stored as one byte per character ("compact strings"), halving memory for typical English and ASCII text.

Two more subtle facts: concatenating compile-time constants ("Ja" + "va") is folded by the compiler into the literal "Java", so it is pooled; but concatenating a non-final variable happens at runtime and produces a new object. You almost never need intern() in application code; it mainly exists for memory optimisation in very specific situations.

The String class has well over sixty methods. You do not need to memorise them all, but the following group covers 95% of day-to-day work and shows up constantly in interviews and coding tests.

Inspecting: length() returns the number of char units; charAt(i) returns the character at index i (0-based, throws StringIndexOutOfBoundsException if out of range); isEmpty() is true for ""; isBlank() (Java 11) is true for empty or whitespace-only strings, which is what you usually want for form validation.

Searching: indexOf(str) and lastIndexOf(str) return the position or -1; contains(str), startsWith(prefix), endsWith(suffix) return booleans. Searching is case-sensitive, so normalise with toLowerCase() first when needed.

Extracting: substring(begin) and substring(begin, end) — the end index is exclusive, so "Mumbai".substring(0, 3) is "Mum". toCharArray() gives a mutable char[], useful for in-place algorithms such as reversing or counting characters. chars() returns an IntStream of code points for stream-style processing.

Transforming: toUpperCase(), toLowerCase(), trim() (removes ASCII whitespace up to U+0020), strip(), stripLeading(), stripTrailing() (Java 11, Unicode-aware, preferred), replace(old, new) replaces all literal occurrences, replaceAll(regex, replacement) uses a regular expression, repeat(n) (Java 11), concat(other).

Splitting and joining: split(regex) returns a String[]; because the argument is a regex, splitting on a dot must be written split("\\.") and splitting on a pipe as split("\\|"). String.join(delimiter, parts...) is the inverse. lines() (Java 11) streams the lines of a multi-line string.

Converting: String.valueOf(42) turns anything into a String; Integer.parseInt("42") and Double.parseDouble("3.14") go the other way and throw NumberFormatException on bad input. Remember that "" + 42 also works but is considered sloppy for anything beyond quick debugging.

The single most common String bug in beginner code is comparing with ==. Learn the difference once and never make the mistake again:

• == compares references: are these two variables pointing at the same object? Because of the string pool this sometimes accidentally returns true for literals, which is exactly why the bug hides during testing and appears in production when the string comes from user input, a file, a database or new String(...).
• equals(Object) compares contents, character by character. This is what you want almost every time.
• equalsIgnoreCase(String) compares contents ignoring case, ideal for email addresses, usernames and commands.
• compareTo(String) returns a negative number, zero or a positive number depending on lexicographic (dictionary) order based on Unicode values, so uppercase letters sort before lowercase ("Zebra".compareTo("apple") is negative). Use compareToIgnoreCase for human-friendly sorting, or a Collator for locale-aware ordering. compareTo is what Arrays.sort and Collections.sort use for Strings.

Two defensive habits: first, when comparing with a constant, put the constant first, "ADMIN".equals(role), so that a null role returns false instead of throwing NullPointerException. Second, when both sides may be null, use Objects.equals(a, b), which treats two nulls as equal and never throws.

Good news: switch on a String (allowed since Java 7, including the switch expressions you learned in Lecture 3) uses equals internally, so it is safe. contains, startsWith and indexOf also compare by content. Only the bare == operator is the trap.

Because Strings are immutable, every += on a String inside a loop creates a new String and copies all the previous characters into it. Building a 10,000-line report that way performs roughly 10,000 copies of ever-growing text, which is O(n²) work and produces mountains of garbage for the collector. On a real project this is the difference between a report that renders in 20 milliseconds and one that takes several seconds.

java.lang.StringBuilder solves this. It is a mutable sequence of characters backed by an internal array (default capacity 16) that grows automatically when needed. Appending is amortised O(1), so building the same report is O(n). The key methods are:

• append(x) — accepts every primitive, char[], String, and any Object (via toString()); it returns the builder itself so calls can be chained.
• insert(index, x), delete(start, end), deleteCharAt(i), replace(start, end, str), setCharAt(i, c) — in-place edits.
• reverse() — the standard way to reverse a string in Java.
• length(), setLength(n) (truncate), charAt(i), indexOf(str).
• toString() — produce the final immutable String when you are done.

If you know the final size, pass it to the constructor, new StringBuilder(4096), to avoid repeated resizing. StringBuffer is the older, synchronised twin from Java 1.0; it is slower and almost never the right choice today because you rarely share a builder across threads. Prefer StringBuilder and mention StringBuffer only when an interviewer asks about the difference.

One clarification: a single expression such as "Hello, " + name + "!" is fine. Since Java 9 (JEP 280) the compiler translates such expressions into an efficient invokedynamic call that builds the result in one step. The problem is specifically repeated concatenation in a loop, and String.join or a StringBuilder is the fix. Also remember that StringBuilder does not override equals, so compare builders by calling toString() first.

Text blocks (finalised in Java 15, JEP 378) are multi-line string literals delimited by three double quotes. Before them, embedding a JSON payload, an SQL query or an HTML fragment meant a painful chain of + "...\n" with escaped quotes. A text block keeps the text readable exactly as it will appear.

The rules you must know:

• The opening """ must be followed by a line break; content starts on the next line.
• Incidental indentation is removed automatically: the compiler finds the least-indented line (including the line with the closing """) and strips that many leading spaces from every line. Moving the closing delimiter left or right therefore controls the indentation that is preserved.
• Each line ends with \n unless you end it with a backslash (\), which joins it to the next line. Use \s to keep a trailing space that would otherwise be stripped.
• Double quotes inside the block need no escaping; only a run of three quotes does.

String.format(pattern, args...) builds a string from a pattern with format specifiers. The most useful ones: %s (any value via toString), %d (integers), %f with a precision such as %.2f (two decimals), %,d (thousands separators), %05d (zero-padded to width 5), %-10s (left-aligned in a 10-character column), %10s (right-aligned), %x (hex), %b (boolean), %c (char), %e (scientific) and %n (platform line separator). System.out.printf uses the same syntax and prints directly. A mismatch between the specifier and the argument type, such as %d with a double, throws IllegalFormatConversionException at runtime, not compile time.

formatted(args...) (Java 15) is an instance method that does the same thing as String.format but reads naturally when the pattern is a text block: template.formatted(name, amount). Numeric formatting with %,d or %.2f follows the JVM's default locale; for currency and Indian lakh/crore grouping in real applications, use java.text.NumberFormat with an explicit locale instead of relying on defaults.

Here is where this lecture's material shows up in real Indian software projects, so you can see why it is worth mastering:

• Request validation in Spring Boot controllers — a validatePan(String pan) method checks length() == 10, matches("[A-Z]{5}[0-9]{4}[A-Z]") and returns a clear error message. isBlank(), strip() and toUpperCase() normalise user input before it reaches the database.
• Parsing files and messages — bank statements, UPI reconciliation files and GST returns arrive as CSV or fixed-width text. split, substring, Integer.parseInt and BigDecimal constructors turn each line into typed data; a String[] per line is the natural intermediate step.
• Building output — HTML emails, SMS templates, log messages and reports are assembled with StringBuilder, text blocks and formatted(). A payment gateway that formats "Rs 1,20,000.00 debited from A/c XX1234" uses exactly these APIs.
• Game boards, images and grids — a Sudoku validator, a Snake and Ladder board, a seating chart in a movie-ticket app and raw image pixels are all 2D arrays walked with nested loops.
• Tree-shaped data — recursion walks a folder tree to compute its size, flattens nested JSON for search indexing, or renders a category tree in an e-commerce catalogue.
• Flexible APIs — varargs power log.info("User {} placed order {}", userId, orderId), List.of(...), EnumSet.of(...) and Stream.of(...).
• Sorting and ranking — leaderboards, top-N products and percentile calculations start with Arrays.sort or Arrays.stream over a primitive array because they are the fastest option for numeric data.

The snippet below is a realistic helper you might find in a fintech codebase: it parses a transaction record, validates it and formats it for display, using almost everything from this lecture.

• Comparing strings with ==. Works by accident for literals, fails for input read from a user, file or database. Fix: equals, equalsIgnoreCase or Objects.equals; put the constant first to be null-safe.
• Ignoring the return value of a String method. s.trim(); on its own line does nothing because Strings are immutable. Fix: s = s.trim();.
• String concatenation in a loop. result += line inside a loop is O(n²). Fix: StringBuilder or String.join / Collectors.joining.
• Off-by-one errors. Looping with i <= arr.length throws ArrayIndexOutOfBoundsException on the last iteration. Fix: i < arr.length. The same applies to charAt(s.length()).
• Forgetting that split takes a regex. split(".") and split("|") silently give wrong results, and split("*") throws PatternSyntaxException. Fix: escape with two backslashes in source ("\\.") or use Pattern.quote(".").
• Expecting the caller to see a reassigned parameter. Assigning arr = new int[3] or name = "x" inside a method never changes the caller's variable. Fix: return the new value and assign it at the call site.
• Recursion without a correct base case or with an input that does not shrink, causing StackOverflowError. Fix: write the base case first and make sure every recursive call moves towards it; use iteration for large flat inputs.
• Comparing arrays with equals. a.equals(b) compares references. Fix: Arrays.equals for 1D and Arrays.deepEquals for nested arrays.
• Arrays.asList on a primitive array. Arrays.asList(new int[]{1,2,3}) gives a List<int[]> with one element. Fix: use Integer[] or Arrays.stream(arr).boxed().toList().
• Using length and length() interchangeably. Arrays have the field length; Strings have the method length(); collections have size().
• Ambiguous overloads. Having both process(int...) and process(Integer...) makes process(1) fail to compile. Fix: keep overload sets simple and avoid mixing boxed and primitive varargs.
• Modifying a String through the enhanced for loop. for (String s : names) s = s.trim(); changes only the loop variable. Fix: use an index loop and assign names[i] = names[i].trim().

Is Java pass-by-value or pass-by-reference?

Java is strictly pass-by-value. For primitives the value itself is copied; for objects the reference is copied. A method can change the contents of the object the reference points to, but it cannot make the caller's variable point to a different object. The classic failing swap(int, int) proves it.

Why is String immutable in Java?

For security (paths, URLs and class names cannot be changed after validation), thread safety (shared without locks), performance (the hash code is cached, making Strings ideal HashMap keys) and to make the string pool possible, since pooled objects can only be shared safely if nobody can modify them.

What is the difference between String, StringBuilder and StringBuffer?

String is immutable; every modification creates a new object. StringBuilder is mutable and fast, intended for single-threaded use, and is the right choice for building text in loops. StringBuffer is the older synchronised version; it is thread-safe but slower and rarely needed in modern code.

What is the difference between == and equals() for Strings?

== checks whether two references point to the same object; equals() checks whether two strings have the same characters. Because of the string pool, == may be true for identical literals but false for strings created at runtime, so always use equals() for content comparison.

How do I convert a String to an int in Java and what if it fails?

Use Integer.parseInt(str) (or Integer.valueOf for an Integer object). If the text is not a valid number, a NumberFormatException is thrown, so wrap the call in a try-catch when the input comes from users or files. Double.parseDouble and Long.parseLong follow the same pattern.

What is the difference between an array and an ArrayList in Java?

An array has a fixed length chosen at creation, can hold primitives directly and is slightly faster and more memory-efficient. An ArrayList grows automatically, offers methods like add, remove and contains, but can only hold objects (primitives are boxed). Use arrays for fixed-size numeric data and ArrayList for most application-level lists.

When should I use recursion instead of a loop in Java?

Use recursion when the data is naturally recursive (trees, nested structures, divide-and-conquer algorithms) and the depth is modest. Use a loop for flat, large inputs, because each recursive call consumes stack space and deep recursion throws StackOverflowError. Java does not perform tail-call optimisation.

What are text blocks in Java and which version introduced them?

Text blocks are multi-line string literals written between triple double quotes. They were previewed in Java 13 and 14 and became a standard feature in Java 15 (JEP 378), so they are available in every current LTS release including Java 21 and Java 25. They are ideal for JSON, SQL and HTML inside Java code.

Q1. What is a method signature, and is the return type part of it?

The signature is the method name plus the ordered parameter types. The return type, parameter names, access modifiers and thrown exceptions are not part of it. That is why two methods differing only in return type cannot coexist in one class.

Q2. Explain method overloading resolution when both print(long) and print(Integer) exist and you call print(5).

The compiler resolves overloads in phases: first without boxing or varargs (allowing primitive widening), then with boxing, then with varargs. int widens to long in phase one, so print(long) is chosen. Boxing to Integer is only considered if no phase-one candidate exists.

Q3. Why does "Ja" + "va" == "Java" return true but s + "va" == "Java" return false when s = "Ja"?

The first expression consists of compile-time constants, so the compiler folds it into the literal "Java", which lives in the string pool. The second involves a non-final variable, so the concatenation happens at runtime and creates a new String object outside the pool. Declaring s as final would make it a constant and restore the folding.

Q4. What does String.intern() do and when would you use it?

It returns the canonical pooled instance of a string, adding it to the pool if necessary. It can save memory when millions of duplicate strings are read from a file or database, but it is rarely needed and misuse can hurt performance, so most application code never calls it.

Q5. How does the JVM store a two-dimensional array?

As an array of references, each pointing to a separate inner array. The rows are independent objects that may have different lengths (jagged arrays) and are not guaranteed to be contiguous in memory. That is why grid[0].length must be used for the column count of a specific row.

Q6. What happens if a recursive method has no base case?

Each call pushes a new frame until the thread's stack is exhausted and the JVM throws StackOverflowError, which is an Error, not an Exception, so it should not be caught as a normal error-handling strategy. The fix is a correct base case and inputs that strictly move towards it.

Q7. Why is String a good HashMap key?

It is immutable, so its hash code cannot change while it sits in the map; the hash code is computed once and cached; and equals and hashCode are correctly implemented and consistent with each other. Mutable keys can get "lost" in a map after modification.

Q8. What is the time complexity of building a String with += in a loop versus StringBuilder?

Repeated += is O(n²) because each step copies all previous characters into a new String. StringBuilder.append is amortised O(1) per call, so the whole build is O(n). Since Java 9, a single concatenation expression is compiled to an efficient invokedynamic call, so the problem is specifically concatenation repeated across loop iterations.

Q9. Can a varargs method be called with an array? Can it be overloaded?

Yes, you can pass an array directly because the varargs parameter is an array. It can be overloaded, but the varargs version is chosen only in the last resolution phase, and mixing int... with Integer... overloads leads to ambiguity errors, so keep such overload sets simple.

Q10. What is the difference between trim() and strip()?

trim() removes characters with code points up to U+0020 (ASCII whitespace and control characters) from both ends. strip(), added in Java 11, uses Character.isWhitespace, so it also removes Unicode whitespace such as non-breaking or ideographic spaces. Prefer strip() in new code.

Build a small command-line marks report that uses every concept from this lecture. Create a file named MarksReport.java, compile it with javac MarksReport.java and run it with java MarksReport. The program should:

1. Store the marks of five students in four subjects in a 2D array and their names in a parallel String array.
2. Provide a method total(int[] marks) and an overloaded average for a single row and for the whole class.
3. Use a varargs method highest(int... values) to find the top mark of a row.
4. Use a recursive method to compute the sum of digits of each total (a common check-digit exercise).
5. Rank students with Arrays.sort on a copy of the totals and use Arrays.binarySearch to find each student's rank.
6. Build the report with a StringBuilder, a text block header and String.format / formatted columns.
7. Validate names with isBlank and normalise them with strip and toUpperCase, comparing with equals only.

Study the expected output in the comments, then extend the program: add a grade(double average) method that returns A, B, C or F using a switch expression, and a search(String name) method that uses equalsIgnoreCase to print one student's row. Try changing one student's marks to see the ranking update.

• A method is a named, reusable block with a return type, a name and typed parameters; its signature is the name plus parameter types, not the return type.
• Java is always pass-by-value: primitives are copied, and object references are copied, so methods can modify an object's contents but cannot reassign the caller's variable.
• Overloading lets several methods share a name with different parameter lists; the compiler resolves them by exact match and widening first, then boxing, then varargs (type... name, always last, received as an array).
• Recursion needs a base case and a shrinking input; it is perfect for trees and divide-and-conquer, but deep recursion causes StackOverflowError, so use loops for large flat data and memoisation to avoid exponential recomputation.
• Arrays are fixed-size objects with default values, 0-based indexes and a length field; 2D arrays are arrays of arrays and can be jagged. java.util.Arrays provides toString, sort, binarySearch, fill, setAll, copyOf, equals, deepEquals and stream.
• Strings are immutable; every "modifying" method returns a new String. Literals are shared through the string pool, which is why == is unreliable and equals / equalsIgnoreCase / compareTo must be used for comparison.
• Key String methods: length, charAt, substring, indexOf, contains, startsWith, strip, isBlank, replace, split (regex!), join, repeat, toCharArray, valueOf, parseInt.
• Use StringBuilder for building text in loops (O(n) instead of O(n²)); StringBuffer is its synchronised, older twin.
• Text blocks (Java 15) make multi-line JSON, SQL and HTML readable; String.format, printf and formatted() (Java 15) format values with specifiers such as %s, %d, %.2f, %,d, %-10s and %n.

Next lecture: Object-Oriented Programming Part 1 — Classes, Objects & Encapsulation