Java Standard Library / APIs

In spring, clocks jump forward (e.g. 02:00 to 03:00), so an hour of local time never happens. If you ask java.time for a ZonedDateTime in that missing hour, it pushes the time forward by the gap (the missing hour) instead of failing.

Duration measures an exact amount of time in seconds and nanoseconds (good for hours/minutes/seconds). Period measures an amount of dates in years, months and days. Use Duration for machine time, Period for calendar time.

DateTimeFormatter is immutable and thread-safe, so one instance can be shared everywhere. The old SimpleDateFormat keeps mutable state during parsing, so sharing it between threads corrupts results.

java.util.Date is mutable, not thread-safe, mixes a date and a time together, and has confusing deprecated methods. Use the java.time package (LocalDate, LocalDateTime, Instant) instead, which is clearer and immutable.

LocalDate is a date only (year-month-day), LocalTime is a time only (hour-minute-second), and LocalDateTime is both together. None of them carries a time zone. Use whichever matches the data you have.

equals() also checks scale, so 2.0 is not equal to 2.00. compareTo() ignores scale and compares the actual number, so 2.0 compareTo 2.00 returns 0. To check if two numbers are numerically equal, use compareTo() == 0.

double and float store numbers in binary, so many decimals like 0.1 can't be represented exactly and small errors creep in. BigDecimal stores decimals exactly, so it's the right choice for money.

BigInteger holds whole numbers of any size, so it never overflows like long does. It is immutable: every operation returns a new BigInteger instead of changing the original.

Math is a utility class of static math functions: abs (magnitude), pow (x to a power), sqrt (square root), max/min (larger/smaller of two), log/exp (natural log and e^x), and sin/cos/tan (trigonometry, in radians).

Use NumberFormat factory methods like NumberFormat.getInstance(locale), then call format(value). The Locale decides things like whether the decimal point is a dot or a comma and which grouping separator is used, so the output looks right for that region.

Primitives like int are not objects, so they can't be stored in collections (e.g. List) or used as generic types, and can't be null. Wrapper classes turn a primitive into an object so it can.

parseInt returns a primitive int. valueOf returns an Integer object (a wrapper). Both parse the text the same way, but you get different return types.

Autoboxing silently turns primitives into objects, which can (1) throw NullPointerException when a null wrapper is unboxed, (2) allocate many objects in loops hurting performance, and (3) make == compare object identity instead of value. Use primitives where possible and equals() to compare.

new Integer(5) always creates a brand-new object and wastes memory. Use Integer.valueOf(5) (or just autoboxing, Integer x = 5;) instead, which can reuse cached objects.

Wrappers offer static helpers (parseInt, valueOf, toString, compare, min/max, toBinaryString) and constants like Integer.MIN_VALUE and Integer.MAX_VALUE. Integer.compare(a, b) safely returns negative/zero/positive without the overflow bug of a - b.

^ matches the start of the text and $ matches the end. They are zero-width because they match a position, not an actual character, so they consume no part of the string.

A character class is a set in square brackets that matches exactly ONE character from that set. [abc] matches a single 'a', 'b', or 'c' (not the word "abc").

Pass Pattern.CASE_INSENSITIVE when compiling the pattern, or put (?i) at the start of the pattern string. Both make letters match regardless of upper or lower case, so "abc" matches "ABC".

A capturing group is the part of a pattern wrapped in parentheses (). After a successful match you read what it captured with matcher.group(n), where n is the group's number. group(0) is the whole match.

A lookaround is a regex condition that checks whether text around the current spot matches a pattern, without including that text in the match. "Zero-width" means it consumes no characters - the position does not move.

Use the .class literal (e.g. String.class) when you know the type at compile time, obj.getClass() to get the real runtime type of an existing object, and Class.forName("name") to look up a class by its String name at runtime.

Reflection can only see annotations marked to survive into the running program. If an annotation isn't kept at runtime, reflection methods like getAnnotation return nothing, even though the annotation was in the source.

Get a Method object from the class (e.g. clazz.getMethod("name", paramTypes)), then call method.invoke(target, args). The first argument is the object to call it on (null for static methods); it returns the method's result as an Object.

A dynamic proxy is a class Java builds at runtime that implements one or more interfaces. You create it with Proxy.newProxyInstance, passing a class loader, the interfaces, and an InvocationHandler whose invoke method runs for every call.

Since Java 9, setAccessible(true) throws InaccessibleObjectException when the target type lives in a module whose package isn't opened for deep reflection. You fix it by opening that package — via an 'opens' directive in module-info or an --add-opens flag at launch.

Annotation processing is a hook in the Java compiler that runs your code during compilation. It reads annotations in the source, and can generate brand-new source files. It cannot change existing files.

@Override tells the compiler a method is meant to replace one from a parent class or interface. If it doesn't actually match a parent method, you get a compile error. It catches typos and wrong signatures early.

You declare a custom annotation with the @interface keyword instead of interface. Inside, each method (with no body) becomes a configurable element you can set when you use the annotation, like @MyAnno(name = "x").

Extend AbstractProcessor, declare which annotations you handle with @SupportedAnnotationTypes and the Java version with @SupportedSourceVersion. Override process(), where RoundEnvironment.getElementsAnnotatedWith() gives you the annotated code to read and generate from.

An element's type can be a primitive, String, Class, an enum, another annotation, or a single-dimension array of those. You can't use arbitrary objects, collections like List, or nested arrays.

When restoring an Externalizable object, Java first creates an empty instance by calling its public no-arg constructor, then calls readExternal to fill in the data. Without that constructor, deserialization fails with InvalidClassException.

The non-serializable parent must have an accessible no-argument constructor. During deserialization Java does not read the parent's fields from the stream; instead it calls that no-arg constructor to set up the parent part of the object.

Both let an object be saved as bytes and restored. Serializable saves fields automatically; Externalizable makes you write the saving and loading code yourself in writeExternal and readExternal, giving full control of the format.

Once the parent also implements Serializable, its fields get written to and restored from the stream like the child's. Java no longer needs to call the parent's no-arg constructor, so that constructor is no longer required and the parent's constructors are skipped during deserialization.

In writeExternal you write each value you want to keep; in readExternal you read them back in exactly the same order and assign them to fields. The biggest pitfall is reading in a different order or count than you wrote.

requires says your module depends on another module so you can use its code. exports makes one of your packages visible to other modules. Without an export, a package stays internal and other modules cannot use it, even if it is public.

The classpath (-cp) is the old flat list of JARs where everything is visible to everything; code there forms the unnamed module. The module path (-p) is the JPMS list where each JAR is a module. A plain JAR is part of the unnamed module on the classpath, but an automatic module on the module path.

The classpath is a flat list of JARs/folders the JVM scans to find classes, with no boundaries between them. The module path holds modules that declare their names and dependencies in module-info, so the JVM resolves and enforces them.

Reliable configuration means the module system checks all dependencies up front. Each module declares what it needs with 'requires', so missing or duplicate modules are caught when the program starts instead of failing later with a runtime error.

Strong encapsulation means only the packages a module explicitly exports are usable by other modules. A public class in a non-exported package is hidden, so 'public' no longer means 'visible to everyone' — it means visible only within the module unless the package is exported.

Objects.equals(a, b) compares two values for equality but won't crash if either is null. It returns true if both are null, false if only one is, and otherwise calls a.equals(b). Plain a.equals(b) throws if a is null.

Objects.requireNonNull(x) throws a NullPointerException immediately if x is null, otherwise returns x. You use it to validate arguments early - usually in constructors - so a bad null fails right away with a clear message instead of later somewhere confusing.

Objects.hash(field1, field2, ...) takes the fields that define equality and combines them into one int hash code. You return it from hashCode(): return Objects.hash(name, email);. It handles nulls automatically.

requireNonNullElse(x, fallback) returns x if it's not null, otherwise the fallback - so you get a default instead of an exception. Objects.toString(obj, nullDefault) returns obj.toString() if obj isn't null, otherwise the given default string. Both substitute a value for null instead of throwing like requireNonNull does.

Use requireNonNull when null means a bug and you want to fail fast; use requireNonNullElse when null is fine and you just want a default; use Objects.equals/hash to safely compare and hash nullable fields; use Optional mainly for return values that may be absent, not for parameters or fields.