Li Auto Java Campus Interview Guide: Salary Insights and Core Java Q&A

Li Auto (Java Campus Recruitment)

Based on the author’s collection, the 2026 Li Auto development‑position campus offers are limited but give a rough reference:

Testing: 25k × (14‑16 months)

Development: 25k × (14‑16 months)

Autonomous‑driving software: 32k × (14‑16 months)

Overall, annual compensation typically exceeds 350k CNY, with the highest cases reaching 400k CNY or more.

Although contracts may state 16‑month salaries, recent years’ year‑end bonuses at Li Auto have been hard to obtain in full; most candidates realistically receive around 14 months.

Year‑end bonuses depend on personal performance, company profitability, market conditions, and the value created by the employee’s department. When the company exceeds expectations, bonuses are more likely to be honored; otherwise they may be reduced or omitted.

Li Auto’s sales dropped from 2024 to 2025, reducing the likelihood of a full 16‑month package. Candidates are advised to base expectations on a 14‑month salary.

Hiring volume for development positions also fell in the 2026 batch compared with 2024, reflecting lower sales and fewer open roles.

Conversely, Li Auto has heavily invested in algorithm positions this year. Candidates hired under the “Li Auto+” plan can see monthly salaries of 50k‑60k CNY, signing bonuses of several tens of thousands, and top offers up to 70k‑80k CNY, pushing annual earnings into the seven‑figure range.

The CEO’s statement that Li Auto is essentially an artificial‑intelligence company explains the generous compensation for algorithm roles.

Java Campus Interview Cheat‑Sheet

1. Benefits of Inheritance vs. Interface and When to Choose

Inheritance enables code reuse: a subclass automatically inherits methods from its superclass, reducing duplication. However, it creates tight coupling and Java only supports single inheritance, limiting flexibility.

Interfaces define contracts without implementation, allowing multiple implementations and promoting decoupling. Clients depend only on the interface, making it easy to swap implementations.

If there is a clear "is‑a" relationship and substantial code reuse is needed, use inheritance (e.g., a BaseActivity for common UI logic).

If you need to define a capability that may have many implementations or require flexible swapping, use an interface (e.g., PaymentService with Alipay, WeChat, Card implementations).

General rule: prefer interfaces unless inheritance is clearly justified.

2. Common Java Map Implementations and Their Use‑Cases

HashMap : O(1) average operations, unordered, allows one null key and multiple null values. Not thread‑safe.

LinkedHashMap : Maintains insertion order (or access order with a flag). Slightly slower than HashMap; useful for LRU caches.

TreeMap : Sorted by key (natural order or Comparator), O(log n) operations, does not allow null keys.

Hashtable : Legacy synchronized map, poor performance; rarely used today.

ConcurrentHashMap : Designed for high concurrency. JDK 1.7 uses segment locks; JDK 1.8 switches to finer‑grained locking with volatile, CAS, and optional tree bins for large buckets.

3. Types of String in Java

String : Immutable, thread‑safe, stored in the string constant pool. Concatenation creates new objects.

StringBuilder : Mutable, not synchronized, ideal for single‑threaded frequent modifications.

StringBuffer : Mutable and synchronized, safe for multithreaded use but slower than StringBuilder.

4. How ConcurrentHashMap Works

JDK 1.7 ConcurrentHashMap

Uses an array of Segment objects (each a ReentrantLock) and an array of HashEntry linked‑list buckets. Each segment protects a portion of the map, allowing concurrent access to different segments.

JDK 1.8 ConcurrentHashMap

Replaces segment locks with a combination of volatile, CAS, and synchronized blocks. When a bucket becomes large, it is transformed into a red‑black tree, reducing lookup from O(n) to O(log n).

Insertion steps (simplified):

If the bucket is empty, initialize it with CAS.

If not empty, compute the target node; if the node is null, set it with CAS.

If the node exists, synchronize, traverse the bucket, replace or add the node, and optionally convert the list to a tree.

5. Strong vs. Weak References

Strong reference : Normal object reference (e.g., Object obj = new Object();). The GC will never reclaim the object while a strong reference exists.

Weak reference : Created via

WeakReference<Object> weakRef = new WeakReference<>(new Object());

. The GC will reclaim the referent regardless of memory pressure.

6. Why Java Can Still Leak Memory Despite GC

GC only collects objects that are unreachable from GC roots. If an object remains reachable—through static collections, unclosed resources, ThreadLocal values, or keys whose hashCode changes—it will not be reclaimed, causing memory leaks.

7. Quick Steps to Locate a Memory Leak

Confirm the leak: use jstat -gcutil <pid> 1000 or monitor memory graphs for continuously rising old‑gen usage.

Dump a live heap snapshot: jmap -dump:live,format=b,file=heap.hprof <pid> (or enable -XX:+HeapDumpOnOutOfMemoryError).

Analyze with MAT (Eclipse Memory Analyzer): look at Leak Suspects, Histogram, and Path to GC Roots (exclude weak refs). Identify static collections, ThreadLocal, or other strong references holding the leaked objects.

Optionally compare two heap dumps to spot the biggest growth.

8. Common Design Patterns

Singleton, Factory, Strategy, etc.

9. Factory Pattern Overview and Benefits

Simple Factory : Central method creates objects based on a parameter (e.g., payment type).

Factory Method : Defines a factory interface; each concrete factory creates a specific product, improving extensibility.

Abstract Factory : Creates families of related objects (e.g., UI components for different platforms).

Benefits: decouples client code from concrete classes, eases extension, and centralizes creation logic.

10. Callback Registration Pattern

Registering callbacks is an implementation of the Observer (publish‑subscribe) pattern, allowing event sources to notify interested listeners without tight coupling.

11. Common Ways to Create Threads in Java

Extend Thread or implement Runnable (basic but less flexible).

Implement Callable for tasks that return results.

Use thread pools via ExecutorService (e.g., ThreadPoolExecutor) with custom core size, max size, queue, and rejection policy for production‑grade concurrency control.

12. Who Executes a Future?

A Future is just a result holder; the actual execution is performed by a thread pool’s worker thread that runs the submitted Callable or Runnable.

13. Understanding Deadlocks

A deadlock occurs when multiple threads hold resources the others need, forming a circular wait. Four necessary conditions: mutual exclusion, hold‑and‑wait, no preemption, and circular wait. Breaking any condition—commonly by enforcing a consistent lock acquisition order—prevents deadlocks.