Why Transsion’s Java Jobs Offer 30‑40k Salaries and How to Ace Their Easy Interview

Java program compilation to execution

The compilation flow proceeds from .java source to .class bytecode, then to native machine code. The JVM class loader loads the bytecode; the interpreter executes it line‑by‑line, which is relatively slow. Frequently executed “hot” methods are compiled at runtime by the Just‑In‑Time (JIT) compiler into native code, which is cached for subsequent runs. This dual nature explains why Java is both compiled and interpreted.

HotSpot uses lazy evaluation: only the hot code that consumes the majority of resources is JIT‑compiled. The JVM continuously gathers execution statistics and optimises hot paths, so the more a method is executed, the faster it becomes.

Why a virtual machine

Cross‑platform : Java bytecode runs on any platform with a matching JVM, enabling “write once, run anywhere”.

Automatic memory management : Built‑in garbage collection automatically reclaims unused objects, reducing leaks and crashes.

Performance optimisation : The JIT compiler dynamically translates hot code into efficient native instructions, approaching native‑language speed.

Java vs C++

Java does not expose raw pointers, providing safer memory access.

Java classes support single inheritance; multiple inheritance is achieved via interfaces.

Java has automatic garbage collection; C++ requires manual memory release.

C++ supports both method and operator overloading; Java supports only method overloading.

Exception vs Error

All throwable types inherit from java.lang.Throwable. Exception represents recoverable conditions that can be caught (checked vs. unchecked). Error denotes unrecoverable JVM failures such as VirtualMachineError, OutOfMemoryError, or NoClassDefFoundError, which should not be caught.

Java Collections framework

The framework is built on two primary interfaces: Collection for single‑element containers and Map for key‑value pairs. Collection further splits into List, Set, and Queue. The hierarchy diagram is shown below.

Note: the diagram omits some abstract classes (e.g., AbstractList, NavigableSet) and auxiliary classes; source code can be consulted for details.

LinkedList insertion and deletion complexity

Head insert/delete: O(1) – only the head pointer changes.

Tail insert/delete: O(1) – only the tail pointer changes.

Arbitrary position insert/delete: O(n) – average traversal of n/4 elements before pointer adjustment.

Example: deleting node 9 requires traversing to the node and then updating pointers via the unlink method (source shown in the diagram).

Why HashMap buckets turn into red‑black trees

When a bucket’s linked list grows long, lookup degrades to O(n). Converting the bucket to a self‑balancing red‑black tree reduces lookup time to O(log n), improving performance for large chains.

Concurrency vs. parallelism

Concurrency : Multiple tasks make progress within overlapping time slices.

Parallelism : Multiple tasks execute simultaneously on different CPU cores.

Motivation for multithreading

Low‑level view : Threads are lightweight compared to processes; context‑switch cost is lower, and multi‑core CPUs allow true simultaneous execution.

Internet‑scale demand : Modern services often need millions of concurrent requests; multithreaded programming provides the foundation for high‑throughput systems.

Single‑core era : With a single thread blocked on I/O, the process stalls, yielding ~50 % CPU utilisation. Additional threads keep the CPU busy while others wait for I/O.

Multi‑core era : Multiple threads can be mapped to separate cores, roughly dividing execution time by the number of cores when there is no contention.

Reference

LinkedList source‑code analysis: https://javaguide.cn/java/collection/linkedlist-source-code.html